1497 lines
56 KiB
C++
1497 lines
56 KiB
C++
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/*
|
|
*******************************************************************************
|
|
* Copyright (C) 2010-2015, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
*******************************************************************************
|
|
* file name: uts46.cpp
|
|
* encoding: UTF-8
|
|
* tab size: 8 (not used)
|
|
* indentation:4
|
|
*
|
|
* created on: 2010mar09
|
|
* created by: Markus W. Scherer
|
|
*/
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_IDNA
|
|
|
|
#include "unicode/bytestream.h"
|
|
#include "unicode/idna.h"
|
|
#include "unicode/normalizer2.h"
|
|
#include "unicode/uscript.h"
|
|
#include "unicode/ustring.h"
|
|
#include "unicode/utf16.h"
|
|
#include "bytesinkutil.h"
|
|
#include "cmemory.h"
|
|
#include "cstring.h"
|
|
#include "punycode.h"
|
|
#include "ubidi_props.h"
|
|
|
|
// Note about tests for UIDNA_ERROR_DOMAIN_NAME_TOO_LONG:
|
|
//
|
|
// The domain name length limit is 255 octets in an internal DNS representation
|
|
// where the last ("root") label is the empty label
|
|
// represented by length byte 0 alone.
|
|
// In a conventional string, this translates to 253 characters, or 254
|
|
// if there is a trailing dot for the root label.
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
// Severe errors which usually result in a U+FFFD replacement character in the result string.
|
|
const uint32_t severeErrors=
|
|
UIDNA_ERROR_LEADING_COMBINING_MARK|
|
|
UIDNA_ERROR_DISALLOWED|
|
|
UIDNA_ERROR_PUNYCODE|
|
|
UIDNA_ERROR_LABEL_HAS_DOT|
|
|
UIDNA_ERROR_INVALID_ACE_LABEL;
|
|
|
|
static inline UBool
|
|
isASCIIString(const UnicodeString &dest) {
|
|
const char16_t *s=dest.getBuffer();
|
|
const char16_t *limit=s+dest.length();
|
|
while(s<limit) {
|
|
if(*s++>0x7f) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static UBool
|
|
isASCIIOkBiDi(const char16_t *s, int32_t length);
|
|
|
|
static UBool
|
|
isASCIIOkBiDi(const char *s, int32_t length);
|
|
|
|
// IDNA class default implementations -------------------------------------- ***
|
|
|
|
IDNA::~IDNA() {}
|
|
|
|
void
|
|
IDNA::labelToASCII_UTF8(StringPiece label, ByteSink &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
if(U_SUCCESS(errorCode)) {
|
|
UnicodeString destString;
|
|
labelToASCII(UnicodeString::fromUTF8(label), destString,
|
|
info, errorCode).toUTF8(dest);
|
|
}
|
|
}
|
|
|
|
void
|
|
IDNA::labelToUnicodeUTF8(StringPiece label, ByteSink &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
if(U_SUCCESS(errorCode)) {
|
|
UnicodeString destString;
|
|
labelToUnicode(UnicodeString::fromUTF8(label), destString,
|
|
info, errorCode).toUTF8(dest);
|
|
}
|
|
}
|
|
|
|
void
|
|
IDNA::nameToASCII_UTF8(StringPiece name, ByteSink &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
if(U_SUCCESS(errorCode)) {
|
|
UnicodeString destString;
|
|
nameToASCII(UnicodeString::fromUTF8(name), destString,
|
|
info, errorCode).toUTF8(dest);
|
|
}
|
|
}
|
|
|
|
void
|
|
IDNA::nameToUnicodeUTF8(StringPiece name, ByteSink &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
if(U_SUCCESS(errorCode)) {
|
|
UnicodeString destString;
|
|
nameToUnicode(UnicodeString::fromUTF8(name), destString,
|
|
info, errorCode).toUTF8(dest);
|
|
}
|
|
}
|
|
|
|
// UTS46 class declaration ------------------------------------------------- ***
|
|
|
|
class UTS46 : public IDNA {
|
|
public:
|
|
UTS46(uint32_t options, UErrorCode &errorCode);
|
|
virtual ~UTS46();
|
|
|
|
virtual UnicodeString &
|
|
labelToASCII(const UnicodeString &label, UnicodeString &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const override;
|
|
|
|
virtual UnicodeString &
|
|
labelToUnicode(const UnicodeString &label, UnicodeString &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const override;
|
|
|
|
virtual UnicodeString &
|
|
nameToASCII(const UnicodeString &name, UnicodeString &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const override;
|
|
|
|
virtual UnicodeString &
|
|
nameToUnicode(const UnicodeString &name, UnicodeString &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const override;
|
|
|
|
virtual void
|
|
labelToASCII_UTF8(StringPiece label, ByteSink &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const override;
|
|
|
|
virtual void
|
|
labelToUnicodeUTF8(StringPiece label, ByteSink &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const override;
|
|
|
|
virtual void
|
|
nameToASCII_UTF8(StringPiece name, ByteSink &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const override;
|
|
|
|
virtual void
|
|
nameToUnicodeUTF8(StringPiece name, ByteSink &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const override;
|
|
|
|
private:
|
|
UnicodeString &
|
|
process(const UnicodeString &src,
|
|
UBool isLabel, UBool toASCII,
|
|
UnicodeString &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const;
|
|
|
|
void
|
|
processUTF8(StringPiece src,
|
|
UBool isLabel, UBool toASCII,
|
|
ByteSink &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const;
|
|
|
|
UnicodeString &
|
|
processUnicode(const UnicodeString &src,
|
|
int32_t labelStart, int32_t mappingStart,
|
|
UBool isLabel, UBool toASCII,
|
|
UnicodeString &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const;
|
|
|
|
// returns the new dest.length()
|
|
int32_t
|
|
mapDevChars(UnicodeString &dest, int32_t labelStart, int32_t mappingStart,
|
|
UErrorCode &errorCode) const;
|
|
|
|
// returns the new label length
|
|
int32_t
|
|
processLabel(UnicodeString &dest,
|
|
int32_t labelStart, int32_t labelLength,
|
|
UBool toASCII,
|
|
IDNAInfo &info, UErrorCode &errorCode) const;
|
|
int32_t
|
|
markBadACELabel(UnicodeString &dest,
|
|
int32_t labelStart, int32_t labelLength,
|
|
UBool toASCII, IDNAInfo &info, UErrorCode &errorCode) const;
|
|
|
|
void
|
|
checkLabelBiDi(const char16_t *label, int32_t labelLength, IDNAInfo &info) const;
|
|
|
|
UBool
|
|
isLabelOkContextJ(const char16_t *label, int32_t labelLength) const;
|
|
|
|
void
|
|
checkLabelContextO(const char16_t *label, int32_t labelLength, IDNAInfo &info) const;
|
|
|
|
const Normalizer2 &uts46Norm2; // uts46.nrm
|
|
uint32_t options;
|
|
};
|
|
|
|
IDNA *
|
|
IDNA::createUTS46Instance(uint32_t options, UErrorCode &errorCode) {
|
|
if(U_SUCCESS(errorCode)) {
|
|
IDNA *idna=new UTS46(options, errorCode);
|
|
if(idna==nullptr) {
|
|
errorCode=U_MEMORY_ALLOCATION_ERROR;
|
|
} else if(U_FAILURE(errorCode)) {
|
|
delete idna;
|
|
idna=nullptr;
|
|
}
|
|
return idna;
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
// UTS46 implementation ---------------------------------------------------- ***
|
|
|
|
UTS46::UTS46(uint32_t opt, UErrorCode &errorCode)
|
|
: uts46Norm2(*Normalizer2::getInstance(nullptr, "uts46", UNORM2_COMPOSE, errorCode)),
|
|
options(opt) {}
|
|
|
|
UTS46::~UTS46() {}
|
|
|
|
UnicodeString &
|
|
UTS46::labelToASCII(const UnicodeString &label, UnicodeString &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
return process(label, true, true, dest, info, errorCode);
|
|
}
|
|
|
|
UnicodeString &
|
|
UTS46::labelToUnicode(const UnicodeString &label, UnicodeString &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
return process(label, true, false, dest, info, errorCode);
|
|
}
|
|
|
|
UnicodeString &
|
|
UTS46::nameToASCII(const UnicodeString &name, UnicodeString &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
process(name, false, true, dest, info, errorCode);
|
|
if( dest.length()>=254 && (info.errors&UIDNA_ERROR_DOMAIN_NAME_TOO_LONG)==0 &&
|
|
isASCIIString(dest) &&
|
|
(dest.length()>254 || dest[253]!=0x2e)
|
|
) {
|
|
info.errors|=UIDNA_ERROR_DOMAIN_NAME_TOO_LONG;
|
|
}
|
|
return dest;
|
|
}
|
|
|
|
UnicodeString &
|
|
UTS46::nameToUnicode(const UnicodeString &name, UnicodeString &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
return process(name, false, false, dest, info, errorCode);
|
|
}
|
|
|
|
void
|
|
UTS46::labelToASCII_UTF8(StringPiece label, ByteSink &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
processUTF8(label, true, true, dest, info, errorCode);
|
|
}
|
|
|
|
void
|
|
UTS46::labelToUnicodeUTF8(StringPiece label, ByteSink &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
processUTF8(label, true, false, dest, info, errorCode);
|
|
}
|
|
|
|
void
|
|
UTS46::nameToASCII_UTF8(StringPiece name, ByteSink &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
processUTF8(name, false, true, dest, info, errorCode);
|
|
}
|
|
|
|
void
|
|
UTS46::nameToUnicodeUTF8(StringPiece name, ByteSink &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
processUTF8(name, false, false, dest, info, errorCode);
|
|
}
|
|
|
|
// UTS #46 data for ASCII characters.
|
|
// The normalizer (using uts46.nrm) maps uppercase ASCII letters to lowercase
|
|
// and passes through all other ASCII characters.
|
|
// If UIDNA_USE_STD3_RULES is set, then non-LDH characters are disallowed
|
|
// using this data.
|
|
// The ASCII fastpath also uses this data.
|
|
// Values: -1=disallowed 0==valid 1==mapped (lowercase)
|
|
static const int8_t asciiData[128]={
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
|
|
// 002D..002E; valid # HYPHEN-MINUS..FULL STOP
|
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, -1,
|
|
// 0030..0039; valid # DIGIT ZERO..DIGIT NINE
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1, -1,
|
|
// 0041..005A; mapped # LATIN CAPITAL LETTER A..LATIN CAPITAL LETTER Z
|
|
-1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,
|
|
// 0061..007A; valid # LATIN SMALL LETTER A..LATIN SMALL LETTER Z
|
|
-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, -1, -1
|
|
};
|
|
|
|
UnicodeString &
|
|
UTS46::process(const UnicodeString &src,
|
|
UBool isLabel, UBool toASCII,
|
|
UnicodeString &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
// uts46Norm2.normalize() would do all of this error checking and setup,
|
|
// but with the ASCII fastpath we do not always call it, and do not
|
|
// call it first.
|
|
if(U_FAILURE(errorCode)) {
|
|
dest.setToBogus();
|
|
return dest;
|
|
}
|
|
const char16_t *srcArray=src.getBuffer();
|
|
if(&dest==&src || srcArray==nullptr) {
|
|
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
|
|
dest.setToBogus();
|
|
return dest;
|
|
}
|
|
// Arguments are fine, reset output values.
|
|
dest.remove();
|
|
info.reset();
|
|
int32_t srcLength=src.length();
|
|
if(srcLength==0) {
|
|
info.errors|=UIDNA_ERROR_EMPTY_LABEL;
|
|
return dest;
|
|
}
|
|
char16_t *destArray=dest.getBuffer(srcLength);
|
|
if(destArray==nullptr) {
|
|
errorCode=U_MEMORY_ALLOCATION_ERROR;
|
|
return dest;
|
|
}
|
|
// ASCII fastpath
|
|
UBool disallowNonLDHDot=(options&UIDNA_USE_STD3_RULES)!=0;
|
|
int32_t labelStart=0;
|
|
int32_t i;
|
|
for(i=0;; ++i) {
|
|
if(i==srcLength) {
|
|
if(toASCII) {
|
|
if((i-labelStart)>63) {
|
|
info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
|
|
}
|
|
// There is a trailing dot if labelStart==i.
|
|
if(!isLabel && i>=254 && (i>254 || labelStart<i)) {
|
|
info.errors|=UIDNA_ERROR_DOMAIN_NAME_TOO_LONG;
|
|
}
|
|
}
|
|
info.errors|=info.labelErrors;
|
|
dest.releaseBuffer(i);
|
|
return dest;
|
|
}
|
|
char16_t c=srcArray[i];
|
|
if(c>0x7f) {
|
|
break;
|
|
}
|
|
int cData=asciiData[c];
|
|
if(cData>0) {
|
|
destArray[i]=c+0x20; // Lowercase an uppercase ASCII letter.
|
|
} else if(cData<0 && disallowNonLDHDot) {
|
|
break; // Replacing with U+FFFD can be complicated for toASCII.
|
|
} else {
|
|
destArray[i]=c;
|
|
if(c==0x2d) { // hyphen
|
|
if(i==(labelStart+3) && srcArray[i-1]==0x2d) {
|
|
// "??--..." is Punycode or forbidden.
|
|
++i; // '-' was copied to dest already
|
|
break;
|
|
}
|
|
if(i==labelStart) {
|
|
// label starts with "-"
|
|
info.labelErrors|=UIDNA_ERROR_LEADING_HYPHEN;
|
|
}
|
|
if((i+1)==srcLength || srcArray[i+1]==0x2e) {
|
|
// label ends with "-"
|
|
info.labelErrors|=UIDNA_ERROR_TRAILING_HYPHEN;
|
|
}
|
|
} else if(c==0x2e) { // dot
|
|
if(isLabel) {
|
|
// Replacing with U+FFFD can be complicated for toASCII.
|
|
++i; // '.' was copied to dest already
|
|
break;
|
|
}
|
|
if(i==labelStart) {
|
|
info.labelErrors|=UIDNA_ERROR_EMPTY_LABEL;
|
|
}
|
|
if(toASCII && (i-labelStart)>63) {
|
|
info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
|
|
}
|
|
info.errors|=info.labelErrors;
|
|
info.labelErrors=0;
|
|
labelStart=i+1;
|
|
}
|
|
}
|
|
}
|
|
info.errors|=info.labelErrors;
|
|
dest.releaseBuffer(i);
|
|
processUnicode(src, labelStart, i, isLabel, toASCII, dest, info, errorCode);
|
|
if( info.isBiDi && U_SUCCESS(errorCode) && (info.errors&severeErrors)==0 &&
|
|
(!info.isOkBiDi || (labelStart>0 && !isASCIIOkBiDi(dest.getBuffer(), labelStart)))
|
|
) {
|
|
info.errors|=UIDNA_ERROR_BIDI;
|
|
}
|
|
return dest;
|
|
}
|
|
|
|
void
|
|
UTS46::processUTF8(StringPiece src,
|
|
UBool isLabel, UBool toASCII,
|
|
ByteSink &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
if(U_FAILURE(errorCode)) {
|
|
return;
|
|
}
|
|
const char *srcArray=src.data();
|
|
int32_t srcLength=src.length();
|
|
if(srcArray==nullptr && srcLength!=0) {
|
|
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
|
|
return;
|
|
}
|
|
// Arguments are fine, reset output values.
|
|
info.reset();
|
|
if(srcLength==0) {
|
|
info.errors|=UIDNA_ERROR_EMPTY_LABEL;
|
|
dest.Flush();
|
|
return;
|
|
}
|
|
UnicodeString destString;
|
|
int32_t labelStart=0;
|
|
if(srcLength<=256) { // length of stackArray[]
|
|
// ASCII fastpath
|
|
char stackArray[256];
|
|
int32_t destCapacity;
|
|
char *destArray=dest.GetAppendBuffer(srcLength, srcLength+20,
|
|
stackArray, UPRV_LENGTHOF(stackArray), &destCapacity);
|
|
UBool disallowNonLDHDot=(options&UIDNA_USE_STD3_RULES)!=0;
|
|
int32_t i;
|
|
for(i=0;; ++i) {
|
|
if(i==srcLength) {
|
|
if(toASCII) {
|
|
if((i-labelStart)>63) {
|
|
info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
|
|
}
|
|
// There is a trailing dot if labelStart==i.
|
|
if(!isLabel && i>=254 && (i>254 || labelStart<i)) {
|
|
info.errors|=UIDNA_ERROR_DOMAIN_NAME_TOO_LONG;
|
|
}
|
|
}
|
|
info.errors|=info.labelErrors;
|
|
dest.Append(destArray, i);
|
|
dest.Flush();
|
|
return;
|
|
}
|
|
char c=srcArray[i];
|
|
if((int8_t)c<0) { // (uint8_t)c>0x7f
|
|
break;
|
|
}
|
|
int cData=asciiData[(int)c]; // Cast: gcc warns about indexing with a char.
|
|
if(cData>0) {
|
|
destArray[i]=c+0x20; // Lowercase an uppercase ASCII letter.
|
|
} else if(cData<0 && disallowNonLDHDot) {
|
|
break; // Replacing with U+FFFD can be complicated for toASCII.
|
|
} else {
|
|
destArray[i]=c;
|
|
if(c==0x2d) { // hyphen
|
|
if(i==(labelStart+3) && srcArray[i-1]==0x2d) {
|
|
// "??--..." is Punycode or forbidden.
|
|
break;
|
|
}
|
|
if(i==labelStart) {
|
|
// label starts with "-"
|
|
info.labelErrors|=UIDNA_ERROR_LEADING_HYPHEN;
|
|
}
|
|
if((i+1)==srcLength || srcArray[i+1]==0x2e) {
|
|
// label ends with "-"
|
|
info.labelErrors|=UIDNA_ERROR_TRAILING_HYPHEN;
|
|
}
|
|
} else if(c==0x2e) { // dot
|
|
if(isLabel) {
|
|
break; // Replacing with U+FFFD can be complicated for toASCII.
|
|
}
|
|
if(i==labelStart) {
|
|
info.labelErrors|=UIDNA_ERROR_EMPTY_LABEL;
|
|
}
|
|
if(toASCII && (i-labelStart)>63) {
|
|
info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
|
|
}
|
|
info.errors|=info.labelErrors;
|
|
info.labelErrors=0;
|
|
labelStart=i+1;
|
|
}
|
|
}
|
|
}
|
|
info.errors|=info.labelErrors;
|
|
// Convert the processed ASCII prefix of the current label to UTF-16.
|
|
int32_t mappingStart=i-labelStart;
|
|
destString=UnicodeString::fromUTF8(StringPiece(destArray+labelStart, mappingStart));
|
|
// Output the previous ASCII labels and process the rest of src in UTF-16.
|
|
dest.Append(destArray, labelStart);
|
|
processUnicode(UnicodeString::fromUTF8(StringPiece(src, labelStart)), 0, mappingStart,
|
|
isLabel, toASCII,
|
|
destString, info, errorCode);
|
|
} else {
|
|
// src is too long for the ASCII fastpath implementation.
|
|
processUnicode(UnicodeString::fromUTF8(src), 0, 0,
|
|
isLabel, toASCII,
|
|
destString, info, errorCode);
|
|
}
|
|
destString.toUTF8(dest); // calls dest.Flush()
|
|
if(toASCII && !isLabel) {
|
|
// length==labelStart==254 means that there is a trailing dot (ok) and
|
|
// destString is empty (do not index at 253-labelStart).
|
|
int32_t length=labelStart+destString.length();
|
|
if( length>=254 && isASCIIString(destString) &&
|
|
(length>254 ||
|
|
(labelStart<254 && destString[253-labelStart]!=0x2e))
|
|
) {
|
|
info.errors|=UIDNA_ERROR_DOMAIN_NAME_TOO_LONG;
|
|
}
|
|
}
|
|
if( info.isBiDi && U_SUCCESS(errorCode) && (info.errors&severeErrors)==0 &&
|
|
(!info.isOkBiDi || (labelStart>0 && !isASCIIOkBiDi(srcArray, labelStart)))
|
|
) {
|
|
info.errors|=UIDNA_ERROR_BIDI;
|
|
}
|
|
}
|
|
|
|
UnicodeString &
|
|
UTS46::processUnicode(const UnicodeString &src,
|
|
int32_t labelStart, int32_t mappingStart,
|
|
UBool isLabel, UBool toASCII,
|
|
UnicodeString &dest,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
if(mappingStart==0) {
|
|
uts46Norm2.normalize(src, dest, errorCode);
|
|
} else {
|
|
uts46Norm2.normalizeSecondAndAppend(dest, src.tempSubString(mappingStart), errorCode);
|
|
}
|
|
if(U_FAILURE(errorCode)) {
|
|
return dest;
|
|
}
|
|
UBool doMapDevChars=
|
|
toASCII ? (options&UIDNA_NONTRANSITIONAL_TO_ASCII)==0 :
|
|
(options&UIDNA_NONTRANSITIONAL_TO_UNICODE)==0;
|
|
const char16_t *destArray=dest.getBuffer();
|
|
int32_t destLength=dest.length();
|
|
int32_t labelLimit=labelStart;
|
|
while(labelLimit<destLength) {
|
|
char16_t c=destArray[labelLimit];
|
|
if(c==0x2e && !isLabel) {
|
|
int32_t labelLength=labelLimit-labelStart;
|
|
int32_t newLength=processLabel(dest, labelStart, labelLength,
|
|
toASCII, info, errorCode);
|
|
info.errors|=info.labelErrors;
|
|
info.labelErrors=0;
|
|
if(U_FAILURE(errorCode)) {
|
|
return dest;
|
|
}
|
|
destArray=dest.getBuffer();
|
|
destLength+=newLength-labelLength;
|
|
labelLimit=labelStart+=newLength+1;
|
|
continue;
|
|
} else if(c<0xdf) {
|
|
// pass
|
|
} else if(c<=0x200d && (c==0xdf || c==0x3c2 || c>=0x200c)) {
|
|
info.isTransDiff=true;
|
|
if(doMapDevChars) {
|
|
destLength=mapDevChars(dest, labelStart, labelLimit, errorCode);
|
|
if(U_FAILURE(errorCode)) {
|
|
return dest;
|
|
}
|
|
destArray=dest.getBuffer();
|
|
// All deviation characters have been mapped, no need to check for them again.
|
|
doMapDevChars=false;
|
|
// Do not increment labelLimit in case c was removed.
|
|
continue;
|
|
}
|
|
} else if(U16_IS_SURROGATE(c)) {
|
|
if(U16_IS_SURROGATE_LEAD(c) ?
|
|
(labelLimit+1)==destLength || !U16_IS_TRAIL(destArray[labelLimit+1]) :
|
|
labelLimit==labelStart || !U16_IS_LEAD(destArray[labelLimit-1])) {
|
|
// Map an unpaired surrogate to U+FFFD before normalization so that when
|
|
// that removes characters we do not turn two unpaired ones into a pair.
|
|
info.labelErrors|=UIDNA_ERROR_DISALLOWED;
|
|
dest.setCharAt(labelLimit, 0xfffd);
|
|
destArray=dest.getBuffer();
|
|
}
|
|
}
|
|
++labelLimit;
|
|
}
|
|
// Permit an empty label at the end (0<labelStart==labelLimit==destLength is ok)
|
|
// but not an empty label elsewhere nor a completely empty domain name.
|
|
// processLabel() sets UIDNA_ERROR_EMPTY_LABEL when labelLength==0.
|
|
if(0==labelStart || labelStart<labelLimit) {
|
|
processLabel(dest, labelStart, labelLimit-labelStart,
|
|
toASCII, info, errorCode);
|
|
info.errors|=info.labelErrors;
|
|
}
|
|
return dest;
|
|
}
|
|
|
|
int32_t
|
|
UTS46::mapDevChars(UnicodeString &dest, int32_t labelStart, int32_t mappingStart,
|
|
UErrorCode &errorCode) const {
|
|
if(U_FAILURE(errorCode)) {
|
|
return 0;
|
|
}
|
|
int32_t length=dest.length();
|
|
char16_t *s=dest.getBuffer(dest[mappingStart]==0xdf ? length+1 : length);
|
|
if(s==nullptr) {
|
|
errorCode=U_MEMORY_ALLOCATION_ERROR;
|
|
return length;
|
|
}
|
|
int32_t capacity=dest.getCapacity();
|
|
UBool didMapDevChars=false;
|
|
int32_t readIndex=mappingStart, writeIndex=mappingStart;
|
|
do {
|
|
char16_t c=s[readIndex++];
|
|
switch(c) {
|
|
case 0xdf:
|
|
// Map sharp s to ss.
|
|
didMapDevChars=true;
|
|
s[writeIndex++]=0x73; // Replace sharp s with first s.
|
|
// Insert second s and account for possible buffer reallocation.
|
|
if(writeIndex==readIndex) {
|
|
if(length==capacity) {
|
|
dest.releaseBuffer(length);
|
|
s=dest.getBuffer(length+1);
|
|
if(s==nullptr) {
|
|
errorCode=U_MEMORY_ALLOCATION_ERROR;
|
|
return length;
|
|
}
|
|
capacity=dest.getCapacity();
|
|
}
|
|
u_memmove(s+writeIndex+1, s+writeIndex, length-writeIndex);
|
|
++readIndex;
|
|
}
|
|
s[writeIndex++]=0x73;
|
|
++length;
|
|
break;
|
|
case 0x3c2: // Map final sigma to nonfinal sigma.
|
|
didMapDevChars=true;
|
|
s[writeIndex++]=0x3c3;
|
|
break;
|
|
case 0x200c: // Ignore/remove ZWNJ.
|
|
case 0x200d: // Ignore/remove ZWJ.
|
|
didMapDevChars=true;
|
|
--length;
|
|
break;
|
|
default:
|
|
// Only really necessary if writeIndex was different from readIndex.
|
|
s[writeIndex++]=c;
|
|
break;
|
|
}
|
|
} while(writeIndex<length);
|
|
dest.releaseBuffer(length);
|
|
if(didMapDevChars) {
|
|
// Mapping deviation characters might have resulted in an un-NFC string.
|
|
// We could use either the NFC or the UTS #46 normalizer.
|
|
// By using the UTS #46 normalizer again, we avoid having to load a second .nrm data file.
|
|
UnicodeString normalized;
|
|
uts46Norm2.normalize(dest.tempSubString(labelStart), normalized, errorCode);
|
|
if(U_SUCCESS(errorCode)) {
|
|
dest.replace(labelStart, 0x7fffffff, normalized);
|
|
if(dest.isBogus()) {
|
|
errorCode=U_MEMORY_ALLOCATION_ERROR;
|
|
}
|
|
return dest.length();
|
|
}
|
|
}
|
|
return length;
|
|
}
|
|
|
|
// Replace the label in dest with the label string, if the label was modified.
|
|
// If &label==&dest then the label was modified in-place and labelLength
|
|
// is the new label length, different from label.length().
|
|
// If &label!=&dest then labelLength==label.length().
|
|
// Returns labelLength (= the new label length).
|
|
static int32_t
|
|
replaceLabel(UnicodeString &dest, int32_t destLabelStart, int32_t destLabelLength,
|
|
const UnicodeString &label, int32_t labelLength, UErrorCode &errorCode) {
|
|
if(U_FAILURE(errorCode)) {
|
|
return 0;
|
|
}
|
|
if(&label!=&dest) {
|
|
dest.replace(destLabelStart, destLabelLength, label);
|
|
if(dest.isBogus()) {
|
|
errorCode=U_MEMORY_ALLOCATION_ERROR;
|
|
return 0;
|
|
}
|
|
}
|
|
return labelLength;
|
|
}
|
|
|
|
int32_t
|
|
UTS46::processLabel(UnicodeString &dest,
|
|
int32_t labelStart, int32_t labelLength,
|
|
UBool toASCII,
|
|
IDNAInfo &info, UErrorCode &errorCode) const {
|
|
if(U_FAILURE(errorCode)) {
|
|
return 0;
|
|
}
|
|
UnicodeString fromPunycode;
|
|
UnicodeString *labelString;
|
|
const char16_t *label=dest.getBuffer()+labelStart;
|
|
int32_t destLabelStart=labelStart;
|
|
int32_t destLabelLength=labelLength;
|
|
UBool wasPunycode;
|
|
if(labelLength>=4 && label[0]==0x78 && label[1]==0x6e && label[2]==0x2d && label[3]==0x2d) {
|
|
// Label starts with "xn--", try to un-Punycode it.
|
|
// In IDNA2008, labels like "xn--" (decodes to an empty string) and
|
|
// "xn--ASCII-" (decodes to just "ASCII") fail the round-trip validation from
|
|
// comparing the ToUnicode input with the back-to-ToASCII output.
|
|
// They are alternate encodings of the respective ASCII labels.
|
|
// Ignore "xn---" here: It will fail Punycode.decode() which logically comes before
|
|
// the round-trip verification.
|
|
if(labelLength==4 || (labelLength>5 && label[labelLength-1]==u'-')) {
|
|
info.labelErrors|=UIDNA_ERROR_INVALID_ACE_LABEL;
|
|
return markBadACELabel(dest, labelStart, labelLength, toASCII, info, errorCode);
|
|
}
|
|
wasPunycode=true;
|
|
char16_t *unicodeBuffer=fromPunycode.getBuffer(-1); // capacity==-1: most labels should fit
|
|
if(unicodeBuffer==nullptr) {
|
|
// Should never occur if we used capacity==-1 which uses the internal buffer.
|
|
errorCode=U_MEMORY_ALLOCATION_ERROR;
|
|
return labelLength;
|
|
}
|
|
UErrorCode punycodeErrorCode=U_ZERO_ERROR;
|
|
int32_t unicodeLength=u_strFromPunycode(label+4, labelLength-4,
|
|
unicodeBuffer, fromPunycode.getCapacity(),
|
|
nullptr, &punycodeErrorCode);
|
|
if(punycodeErrorCode==U_BUFFER_OVERFLOW_ERROR) {
|
|
fromPunycode.releaseBuffer(0);
|
|
unicodeBuffer=fromPunycode.getBuffer(unicodeLength);
|
|
if(unicodeBuffer==nullptr) {
|
|
errorCode=U_MEMORY_ALLOCATION_ERROR;
|
|
return labelLength;
|
|
}
|
|
punycodeErrorCode=U_ZERO_ERROR;
|
|
unicodeLength=u_strFromPunycode(label+4, labelLength-4,
|
|
unicodeBuffer, fromPunycode.getCapacity(),
|
|
nullptr, &punycodeErrorCode);
|
|
}
|
|
fromPunycode.releaseBuffer(unicodeLength);
|
|
if(U_FAILURE(punycodeErrorCode)) {
|
|
info.labelErrors|=UIDNA_ERROR_PUNYCODE;
|
|
return markBadACELabel(dest, labelStart, labelLength, toASCII, info, errorCode);
|
|
}
|
|
// Check for NFC, and for characters that are not
|
|
// valid or deviation characters according to the normalizer.
|
|
// If there is something wrong, then the string will change.
|
|
// Note that the normalizer passes through non-LDH ASCII and deviation characters.
|
|
// Deviation characters are ok in Punycode even in transitional processing.
|
|
// In the code further below, if we find non-LDH ASCII and we have UIDNA_USE_STD3_RULES
|
|
// then we will set UIDNA_ERROR_INVALID_ACE_LABEL there too.
|
|
UBool isValid=uts46Norm2.isNormalized(fromPunycode, errorCode);
|
|
if(U_FAILURE(errorCode)) {
|
|
return labelLength;
|
|
}
|
|
if(!isValid) {
|
|
info.labelErrors|=UIDNA_ERROR_INVALID_ACE_LABEL;
|
|
return markBadACELabel(dest, labelStart, labelLength, toASCII, info, errorCode);
|
|
}
|
|
labelString=&fromPunycode;
|
|
label=fromPunycode.getBuffer();
|
|
labelStart=0;
|
|
labelLength=fromPunycode.length();
|
|
} else {
|
|
wasPunycode=false;
|
|
labelString=&dest;
|
|
}
|
|
// Validity check
|
|
if(labelLength==0) {
|
|
info.labelErrors|=UIDNA_ERROR_EMPTY_LABEL;
|
|
return replaceLabel(dest, destLabelStart, destLabelLength,
|
|
*labelString, labelLength, errorCode);
|
|
}
|
|
// labelLength>0
|
|
if(labelLength>=4 && label[2]==0x2d && label[3]==0x2d) {
|
|
// label starts with "??--"
|
|
info.labelErrors|=UIDNA_ERROR_HYPHEN_3_4;
|
|
}
|
|
if(label[0]==0x2d) {
|
|
// label starts with "-"
|
|
info.labelErrors|=UIDNA_ERROR_LEADING_HYPHEN;
|
|
}
|
|
if(label[labelLength-1]==0x2d) {
|
|
// label ends with "-"
|
|
info.labelErrors|=UIDNA_ERROR_TRAILING_HYPHEN;
|
|
}
|
|
// If the label was not a Punycode label, then it was the result of
|
|
// mapping, normalization and label segmentation.
|
|
// If the label was in Punycode, then we mapped it again above
|
|
// and checked its validity.
|
|
// Now we handle the STD3 restriction to LDH characters (if set)
|
|
// and we look for U+FFFD which indicates disallowed characters
|
|
// in a non-Punycode label or U+FFFD itself in a Punycode label.
|
|
// We also check for dots which can come from the input to a single-label function.
|
|
// Ok to cast away const because we own the UnicodeString.
|
|
char16_t *s=(char16_t *)label;
|
|
const char16_t *limit=label+labelLength;
|
|
char16_t oredChars=0;
|
|
// If we enforce STD3 rules, then ASCII characters other than LDH and dot are disallowed.
|
|
UBool disallowNonLDHDot=(options&UIDNA_USE_STD3_RULES)!=0;
|
|
do {
|
|
char16_t c=*s;
|
|
if(c<=0x7f) {
|
|
if(c==0x2e) {
|
|
info.labelErrors|=UIDNA_ERROR_LABEL_HAS_DOT;
|
|
*s=0xfffd;
|
|
} else if(disallowNonLDHDot && asciiData[c]<0) {
|
|
info.labelErrors|=UIDNA_ERROR_DISALLOWED;
|
|
*s=0xfffd;
|
|
}
|
|
} else {
|
|
oredChars|=c;
|
|
if(c==0xfffd) {
|
|
info.labelErrors|=UIDNA_ERROR_DISALLOWED;
|
|
}
|
|
}
|
|
++s;
|
|
} while(s<limit);
|
|
// Check for a leading combining mark after other validity checks
|
|
// so that we don't report UIDNA_ERROR_DISALLOWED for the U+FFFD from here.
|
|
UChar32 c;
|
|
int32_t cpLength=0;
|
|
// "Unsafe" is ok because unpaired surrogates were mapped to U+FFFD.
|
|
U16_NEXT_UNSAFE(label, cpLength, c);
|
|
if((U_GET_GC_MASK(c)&U_GC_M_MASK)!=0) {
|
|
info.labelErrors|=UIDNA_ERROR_LEADING_COMBINING_MARK;
|
|
labelString->replace(labelStart, cpLength, (char16_t)0xfffd);
|
|
label=labelString->getBuffer()+labelStart;
|
|
labelLength+=1-cpLength;
|
|
if(labelString==&dest) {
|
|
destLabelLength=labelLength;
|
|
}
|
|
}
|
|
if((info.labelErrors&severeErrors)==0) {
|
|
// Do contextual checks only if we do not have U+FFFD from a severe error
|
|
// because U+FFFD can make these checks fail.
|
|
if((options&UIDNA_CHECK_BIDI)!=0 && (!info.isBiDi || info.isOkBiDi)) {
|
|
checkLabelBiDi(label, labelLength, info);
|
|
}
|
|
if( (options&UIDNA_CHECK_CONTEXTJ)!=0 && (oredChars&0x200c)==0x200c &&
|
|
!isLabelOkContextJ(label, labelLength)
|
|
) {
|
|
info.labelErrors|=UIDNA_ERROR_CONTEXTJ;
|
|
}
|
|
if((options&UIDNA_CHECK_CONTEXTO)!=0 && oredChars>=0xb7) {
|
|
checkLabelContextO(label, labelLength, info);
|
|
}
|
|
if(toASCII) {
|
|
if(wasPunycode) {
|
|
// Leave a Punycode label unchanged if it has no severe errors.
|
|
if(destLabelLength>63) {
|
|
info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
|
|
}
|
|
return destLabelLength;
|
|
} else if(oredChars>=0x80) {
|
|
// Contains non-ASCII characters.
|
|
UnicodeString punycode;
|
|
char16_t *buffer=punycode.getBuffer(63); // 63==maximum DNS label length
|
|
if(buffer==nullptr) {
|
|
errorCode=U_MEMORY_ALLOCATION_ERROR;
|
|
return destLabelLength;
|
|
}
|
|
buffer[0]=0x78; // Write "xn--".
|
|
buffer[1]=0x6e;
|
|
buffer[2]=0x2d;
|
|
buffer[3]=0x2d;
|
|
int32_t punycodeLength=u_strToPunycode(label, labelLength,
|
|
buffer+4, punycode.getCapacity()-4,
|
|
nullptr, &errorCode);
|
|
if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
|
|
errorCode=U_ZERO_ERROR;
|
|
punycode.releaseBuffer(4);
|
|
buffer=punycode.getBuffer(4+punycodeLength);
|
|
if(buffer==nullptr) {
|
|
errorCode=U_MEMORY_ALLOCATION_ERROR;
|
|
return destLabelLength;
|
|
}
|
|
punycodeLength=u_strToPunycode(label, labelLength,
|
|
buffer+4, punycode.getCapacity()-4,
|
|
nullptr, &errorCode);
|
|
}
|
|
punycodeLength+=4;
|
|
punycode.releaseBuffer(punycodeLength);
|
|
if(U_FAILURE(errorCode)) {
|
|
return destLabelLength;
|
|
}
|
|
if(punycodeLength>63) {
|
|
info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
|
|
}
|
|
return replaceLabel(dest, destLabelStart, destLabelLength,
|
|
punycode, punycodeLength, errorCode);
|
|
} else {
|
|
// all-ASCII label
|
|
if(labelLength>63) {
|
|
info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// If a Punycode label has severe errors,
|
|
// then leave it but make sure it does not look valid.
|
|
if(wasPunycode) {
|
|
info.labelErrors|=UIDNA_ERROR_INVALID_ACE_LABEL;
|
|
return markBadACELabel(dest, destLabelStart, destLabelLength, toASCII, info, errorCode);
|
|
}
|
|
}
|
|
return replaceLabel(dest, destLabelStart, destLabelLength,
|
|
*labelString, labelLength, errorCode);
|
|
}
|
|
|
|
// Make sure an ACE label does not look valid.
|
|
// Append U+FFFD if the label has only LDH characters.
|
|
// If UIDNA_USE_STD3_RULES, also replace disallowed ASCII characters with U+FFFD.
|
|
int32_t
|
|
UTS46::markBadACELabel(UnicodeString &dest,
|
|
int32_t labelStart, int32_t labelLength,
|
|
UBool toASCII, IDNAInfo &info, UErrorCode &errorCode) const {
|
|
if(U_FAILURE(errorCode)) {
|
|
return 0;
|
|
}
|
|
UBool disallowNonLDHDot=(options&UIDNA_USE_STD3_RULES)!=0;
|
|
UBool isASCII=true;
|
|
UBool onlyLDH=true;
|
|
const char16_t *label=dest.getBuffer()+labelStart;
|
|
const char16_t *limit=label+labelLength;
|
|
// Start after the initial "xn--".
|
|
// Ok to cast away const because we own the UnicodeString.
|
|
for(char16_t *s=const_cast<char16_t *>(label+4); s<limit; ++s) {
|
|
char16_t c=*s;
|
|
if(c<=0x7f) {
|
|
if(c==0x2e) {
|
|
info.labelErrors|=UIDNA_ERROR_LABEL_HAS_DOT;
|
|
*s=0xfffd;
|
|
isASCII=onlyLDH=false;
|
|
} else if(asciiData[c]<0) {
|
|
onlyLDH=false;
|
|
if(disallowNonLDHDot) {
|
|
*s=0xfffd;
|
|
isASCII=false;
|
|
}
|
|
}
|
|
} else {
|
|
isASCII=onlyLDH=false;
|
|
}
|
|
}
|
|
if(onlyLDH) {
|
|
dest.insert(labelStart+labelLength, (char16_t)0xfffd);
|
|
if(dest.isBogus()) {
|
|
errorCode=U_MEMORY_ALLOCATION_ERROR;
|
|
return 0;
|
|
}
|
|
++labelLength;
|
|
} else {
|
|
if(toASCII && isASCII && labelLength>63) {
|
|
info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
|
|
}
|
|
}
|
|
return labelLength;
|
|
}
|
|
|
|
const uint32_t L_MASK=U_MASK(U_LEFT_TO_RIGHT);
|
|
const uint32_t R_AL_MASK=U_MASK(U_RIGHT_TO_LEFT)|U_MASK(U_RIGHT_TO_LEFT_ARABIC);
|
|
const uint32_t L_R_AL_MASK=L_MASK|R_AL_MASK;
|
|
|
|
const uint32_t R_AL_AN_MASK=R_AL_MASK|U_MASK(U_ARABIC_NUMBER);
|
|
|
|
const uint32_t EN_AN_MASK=U_MASK(U_EUROPEAN_NUMBER)|U_MASK(U_ARABIC_NUMBER);
|
|
const uint32_t R_AL_EN_AN_MASK=R_AL_MASK|EN_AN_MASK;
|
|
const uint32_t L_EN_MASK=L_MASK|U_MASK(U_EUROPEAN_NUMBER);
|
|
|
|
const uint32_t ES_CS_ET_ON_BN_NSM_MASK=
|
|
U_MASK(U_EUROPEAN_NUMBER_SEPARATOR)|
|
|
U_MASK(U_COMMON_NUMBER_SEPARATOR)|
|
|
U_MASK(U_EUROPEAN_NUMBER_TERMINATOR)|
|
|
U_MASK(U_OTHER_NEUTRAL)|
|
|
U_MASK(U_BOUNDARY_NEUTRAL)|
|
|
U_MASK(U_DIR_NON_SPACING_MARK);
|
|
const uint32_t L_EN_ES_CS_ET_ON_BN_NSM_MASK=L_EN_MASK|ES_CS_ET_ON_BN_NSM_MASK;
|
|
const uint32_t R_AL_AN_EN_ES_CS_ET_ON_BN_NSM_MASK=R_AL_MASK|EN_AN_MASK|ES_CS_ET_ON_BN_NSM_MASK;
|
|
|
|
// We scan the whole label and check both for whether it contains RTL characters
|
|
// and whether it passes the BiDi Rule.
|
|
// In a BiDi domain name, all labels must pass the BiDi Rule, but we might find
|
|
// that a domain name is a BiDi domain name (has an RTL label) only after
|
|
// processing several earlier labels.
|
|
void
|
|
UTS46::checkLabelBiDi(const char16_t *label, int32_t labelLength, IDNAInfo &info) const {
|
|
// IDNA2008 BiDi rule
|
|
// Get the directionality of the first character.
|
|
UChar32 c;
|
|
int32_t i=0;
|
|
U16_NEXT_UNSAFE(label, i, c);
|
|
uint32_t firstMask=U_MASK(u_charDirection(c));
|
|
// 1. The first character must be a character with BIDI property L, R
|
|
// or AL. If it has the R or AL property, it is an RTL label; if it
|
|
// has the L property, it is an LTR label.
|
|
if((firstMask&~L_R_AL_MASK)!=0) {
|
|
info.isOkBiDi=false;
|
|
}
|
|
// Get the directionality of the last non-NSM character.
|
|
uint32_t lastMask;
|
|
for(;;) {
|
|
if(i>=labelLength) {
|
|
lastMask=firstMask;
|
|
break;
|
|
}
|
|
U16_PREV_UNSAFE(label, labelLength, c);
|
|
UCharDirection dir=u_charDirection(c);
|
|
if(dir!=U_DIR_NON_SPACING_MARK) {
|
|
lastMask=U_MASK(dir);
|
|
break;
|
|
}
|
|
}
|
|
// 3. In an RTL label, the end of the label must be a character with
|
|
// BIDI property R, AL, EN or AN, followed by zero or more
|
|
// characters with BIDI property NSM.
|
|
// 6. In an LTR label, the end of the label must be a character with
|
|
// BIDI property L or EN, followed by zero or more characters with
|
|
// BIDI property NSM.
|
|
if( (firstMask&L_MASK)!=0 ?
|
|
(lastMask&~L_EN_MASK)!=0 :
|
|
(lastMask&~R_AL_EN_AN_MASK)!=0
|
|
) {
|
|
info.isOkBiDi=false;
|
|
}
|
|
// Add the directionalities of the intervening characters.
|
|
uint32_t mask=firstMask|lastMask;
|
|
while(i<labelLength) {
|
|
U16_NEXT_UNSAFE(label, i, c);
|
|
mask|=U_MASK(u_charDirection(c));
|
|
}
|
|
if(firstMask&L_MASK) {
|
|
// 5. In an LTR label, only characters with the BIDI properties L, EN,
|
|
// ES, CS, ET, ON, BN and NSM are allowed.
|
|
if((mask&~L_EN_ES_CS_ET_ON_BN_NSM_MASK)!=0) {
|
|
info.isOkBiDi=false;
|
|
}
|
|
} else {
|
|
// 2. In an RTL label, only characters with the BIDI properties R, AL,
|
|
// AN, EN, ES, CS, ET, ON, BN and NSM are allowed.
|
|
if((mask&~R_AL_AN_EN_ES_CS_ET_ON_BN_NSM_MASK)!=0) {
|
|
info.isOkBiDi=false;
|
|
}
|
|
// 4. In an RTL label, if an EN is present, no AN may be present, and
|
|
// vice versa.
|
|
if((mask&EN_AN_MASK)==EN_AN_MASK) {
|
|
info.isOkBiDi=false;
|
|
}
|
|
}
|
|
// An RTL label is a label that contains at least one character of type
|
|
// R, AL or AN. [...]
|
|
// A "BIDI domain name" is a domain name that contains at least one RTL
|
|
// label. [...]
|
|
// The following rule, consisting of six conditions, applies to labels
|
|
// in BIDI domain names.
|
|
if((mask&R_AL_AN_MASK)!=0) {
|
|
info.isBiDi=true;
|
|
}
|
|
}
|
|
|
|
// Special code for the ASCII prefix of a BiDi domain name.
|
|
// The ASCII prefix is all-LTR.
|
|
|
|
// IDNA2008 BiDi rule, parts relevant to ASCII labels:
|
|
// 1. The first character must be a character with BIDI property L [...]
|
|
// 5. In an LTR label, only characters with the BIDI properties L, EN,
|
|
// ES, CS, ET, ON, BN and NSM are allowed.
|
|
// 6. In an LTR label, the end of the label must be a character with
|
|
// BIDI property L or EN [...]
|
|
|
|
// UTF-16 version, called for mapped ASCII prefix.
|
|
// Cannot contain uppercase A-Z.
|
|
// s[length-1] must be the trailing dot.
|
|
static UBool
|
|
isASCIIOkBiDi(const char16_t *s, int32_t length) {
|
|
int32_t labelStart=0;
|
|
for(int32_t i=0; i<length; ++i) {
|
|
char16_t c=s[i];
|
|
if(c==0x2e) { // dot
|
|
if(i>labelStart) {
|
|
c=s[i-1];
|
|
if(!(0x61<=c && c<=0x7a) && !(0x30<=c && c<=0x39)) {
|
|
// Last character in the label is not an L or EN.
|
|
return false;
|
|
}
|
|
}
|
|
labelStart=i+1;
|
|
} else if(i==labelStart) {
|
|
if(!(0x61<=c && c<=0x7a)) {
|
|
// First character in the label is not an L.
|
|
return false;
|
|
}
|
|
} else {
|
|
if(c<=0x20 && (c>=0x1c || (9<=c && c<=0xd))) {
|
|
// Intermediate character in the label is a B, S or WS.
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// UTF-8 version, called for source ASCII prefix.
|
|
// Can contain uppercase A-Z.
|
|
// s[length-1] must be the trailing dot.
|
|
static UBool
|
|
isASCIIOkBiDi(const char *s, int32_t length) {
|
|
int32_t labelStart=0;
|
|
for(int32_t i=0; i<length; ++i) {
|
|
char c=s[i];
|
|
if(c==0x2e) { // dot
|
|
if(i>labelStart) {
|
|
c=s[i-1];
|
|
if(!(0x61<=c && c<=0x7a) && !(0x41<=c && c<=0x5a) && !(0x30<=c && c<=0x39)) {
|
|
// Last character in the label is not an L or EN.
|
|
return false;
|
|
}
|
|
}
|
|
labelStart=i+1;
|
|
} else if(i==labelStart) {
|
|
if(!(0x61<=c && c<=0x7a) && !(0x41<=c && c<=0x5a)) {
|
|
// First character in the label is not an L.
|
|
return false;
|
|
}
|
|
} else {
|
|
if(c<=0x20 && (c>=0x1c || (9<=c && c<=0xd))) {
|
|
// Intermediate character in the label is a B, S or WS.
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
UBool
|
|
UTS46::isLabelOkContextJ(const char16_t *label, int32_t labelLength) const {
|
|
// [IDNA2008-Tables]
|
|
// 200C..200D ; CONTEXTJ # ZERO WIDTH NON-JOINER..ZERO WIDTH JOINER
|
|
for(int32_t i=0; i<labelLength; ++i) {
|
|
if(label[i]==0x200c) {
|
|
// Appendix A.1. ZERO WIDTH NON-JOINER
|
|
// Rule Set:
|
|
// False;
|
|
// If Canonical_Combining_Class(Before(cp)) .eq. Virama Then True;
|
|
// If RegExpMatch((Joining_Type:{L,D})(Joining_Type:T)*\u200C
|
|
// (Joining_Type:T)*(Joining_Type:{R,D})) Then True;
|
|
if(i==0) {
|
|
return false;
|
|
}
|
|
UChar32 c;
|
|
int32_t j=i;
|
|
U16_PREV_UNSAFE(label, j, c);
|
|
if(uts46Norm2.getCombiningClass(c)==9) {
|
|
continue;
|
|
}
|
|
// check precontext (Joining_Type:{L,D})(Joining_Type:T)*
|
|
for(;;) {
|
|
UJoiningType type=ubidi_getJoiningType(c);
|
|
if(type==U_JT_TRANSPARENT) {
|
|
if(j==0) {
|
|
return false;
|
|
}
|
|
U16_PREV_UNSAFE(label, j, c);
|
|
} else if(type==U_JT_LEFT_JOINING || type==U_JT_DUAL_JOINING) {
|
|
break; // precontext fulfilled
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
// check postcontext (Joining_Type:T)*(Joining_Type:{R,D})
|
|
for(j=i+1;;) {
|
|
if(j==labelLength) {
|
|
return false;
|
|
}
|
|
U16_NEXT_UNSAFE(label, j, c);
|
|
UJoiningType type=ubidi_getJoiningType(c);
|
|
if(type==U_JT_TRANSPARENT) {
|
|
// just skip this character
|
|
} else if(type==U_JT_RIGHT_JOINING || type==U_JT_DUAL_JOINING) {
|
|
break; // postcontext fulfilled
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
} else if(label[i]==0x200d) {
|
|
// Appendix A.2. ZERO WIDTH JOINER (U+200D)
|
|
// Rule Set:
|
|
// False;
|
|
// If Canonical_Combining_Class(Before(cp)) .eq. Virama Then True;
|
|
if(i==0) {
|
|
return false;
|
|
}
|
|
UChar32 c;
|
|
int32_t j=i;
|
|
U16_PREV_UNSAFE(label, j, c);
|
|
if(uts46Norm2.getCombiningClass(c)!=9) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void
|
|
UTS46::checkLabelContextO(const char16_t *label, int32_t labelLength, IDNAInfo &info) const {
|
|
int32_t labelEnd=labelLength-1; // inclusive
|
|
int32_t arabicDigits=0; // -1 for 066x, +1 for 06Fx
|
|
for(int32_t i=0; i<=labelEnd; ++i) {
|
|
UChar32 c=label[i];
|
|
if(c<0xb7) {
|
|
// ASCII fastpath
|
|
} else if(c<=0x6f9) {
|
|
if(c==0xb7) {
|
|
// Appendix A.3. MIDDLE DOT (U+00B7)
|
|
// Rule Set:
|
|
// False;
|
|
// If Before(cp) .eq. U+006C And
|
|
// After(cp) .eq. U+006C Then True;
|
|
if(!(0<i && label[i-1]==0x6c &&
|
|
i<labelEnd && label[i+1]==0x6c)) {
|
|
info.labelErrors|=UIDNA_ERROR_CONTEXTO_PUNCTUATION;
|
|
}
|
|
} else if(c==0x375) {
|
|
// Appendix A.4. GREEK LOWER NUMERAL SIGN (KERAIA) (U+0375)
|
|
// Rule Set:
|
|
// False;
|
|
// If Script(After(cp)) .eq. Greek Then True;
|
|
UScriptCode script=USCRIPT_INVALID_CODE;
|
|
if(i<labelEnd) {
|
|
UErrorCode errorCode=U_ZERO_ERROR;
|
|
int32_t j=i+1;
|
|
U16_NEXT(label, j, labelLength, c);
|
|
script=uscript_getScript(c, &errorCode);
|
|
}
|
|
if(script!=USCRIPT_GREEK) {
|
|
info.labelErrors|=UIDNA_ERROR_CONTEXTO_PUNCTUATION;
|
|
}
|
|
} else if(c==0x5f3 || c==0x5f4) {
|
|
// Appendix A.5. HEBREW PUNCTUATION GERESH (U+05F3)
|
|
// Rule Set:
|
|
// False;
|
|
// If Script(Before(cp)) .eq. Hebrew Then True;
|
|
//
|
|
// Appendix A.6. HEBREW PUNCTUATION GERSHAYIM (U+05F4)
|
|
// Rule Set:
|
|
// False;
|
|
// If Script(Before(cp)) .eq. Hebrew Then True;
|
|
UScriptCode script=USCRIPT_INVALID_CODE;
|
|
if(0<i) {
|
|
UErrorCode errorCode=U_ZERO_ERROR;
|
|
int32_t j=i;
|
|
U16_PREV(label, 0, j, c);
|
|
script=uscript_getScript(c, &errorCode);
|
|
}
|
|
if(script!=USCRIPT_HEBREW) {
|
|
info.labelErrors|=UIDNA_ERROR_CONTEXTO_PUNCTUATION;
|
|
}
|
|
} else if(0x660<=c /* && c<=0x6f9 */) {
|
|
// Appendix A.8. ARABIC-INDIC DIGITS (0660..0669)
|
|
// Rule Set:
|
|
// True;
|
|
// For All Characters:
|
|
// If cp .in. 06F0..06F9 Then False;
|
|
// End For;
|
|
//
|
|
// Appendix A.9. EXTENDED ARABIC-INDIC DIGITS (06F0..06F9)
|
|
// Rule Set:
|
|
// True;
|
|
// For All Characters:
|
|
// If cp .in. 0660..0669 Then False;
|
|
// End For;
|
|
if(c<=0x669) {
|
|
if(arabicDigits>0) {
|
|
info.labelErrors|=UIDNA_ERROR_CONTEXTO_DIGITS;
|
|
}
|
|
arabicDigits=-1;
|
|
} else if(0x6f0<=c) {
|
|
if(arabicDigits<0) {
|
|
info.labelErrors|=UIDNA_ERROR_CONTEXTO_DIGITS;
|
|
}
|
|
arabicDigits=1;
|
|
}
|
|
}
|
|
} else if(c==0x30fb) {
|
|
// Appendix A.7. KATAKANA MIDDLE DOT (U+30FB)
|
|
// Rule Set:
|
|
// False;
|
|
// For All Characters:
|
|
// If Script(cp) .in. {Hiragana, Katakana, Han} Then True;
|
|
// End For;
|
|
UErrorCode errorCode=U_ZERO_ERROR;
|
|
for(int j=0;;) {
|
|
if(j>labelEnd) {
|
|
info.labelErrors|=UIDNA_ERROR_CONTEXTO_PUNCTUATION;
|
|
break;
|
|
}
|
|
U16_NEXT(label, j, labelLength, c);
|
|
UScriptCode script=uscript_getScript(c, &errorCode);
|
|
if(script==USCRIPT_HIRAGANA || script==USCRIPT_KATAKANA || script==USCRIPT_HAN) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
U_NAMESPACE_END
|
|
|
|
// C API ------------------------------------------------------------------- ***
|
|
|
|
U_NAMESPACE_USE
|
|
|
|
U_CAPI UIDNA * U_EXPORT2
|
|
uidna_openUTS46(uint32_t options, UErrorCode *pErrorCode) {
|
|
return reinterpret_cast<UIDNA *>(IDNA::createUTS46Instance(options, *pErrorCode));
|
|
}
|
|
|
|
U_CAPI void U_EXPORT2
|
|
uidna_close(UIDNA *idna) {
|
|
delete reinterpret_cast<IDNA *>(idna);
|
|
}
|
|
|
|
static UBool
|
|
checkArgs(const void *label, int32_t length,
|
|
void *dest, int32_t capacity,
|
|
UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
|
|
if(U_FAILURE(*pErrorCode)) {
|
|
return false;
|
|
}
|
|
// sizeof(UIDNAInfo)=16 in the first API version.
|
|
if(pInfo==nullptr || pInfo->size<16) {
|
|
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
|
|
return false;
|
|
}
|
|
if( (label==nullptr ? length!=0 : length<-1) ||
|
|
(dest==nullptr ? capacity!=0 : capacity<0) ||
|
|
(dest==label && label!=nullptr)
|
|
) {
|
|
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
|
|
return false;
|
|
}
|
|
// Set all *pInfo bytes to 0 except for the size field itself.
|
|
uprv_memset(&pInfo->size+1, 0, pInfo->size-sizeof(pInfo->size));
|
|
return true;
|
|
}
|
|
|
|
static void
|
|
idnaInfoToStruct(IDNAInfo &info, UIDNAInfo *pInfo) {
|
|
pInfo->isTransitionalDifferent=info.isTransitionalDifferent();
|
|
pInfo->errors=info.getErrors();
|
|
}
|
|
|
|
U_CAPI int32_t U_EXPORT2
|
|
uidna_labelToASCII(const UIDNA *idna,
|
|
const char16_t *label, int32_t length,
|
|
char16_t *dest, int32_t capacity,
|
|
UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
|
|
if(!checkArgs(label, length, dest, capacity, pInfo, pErrorCode)) {
|
|
return 0;
|
|
}
|
|
UnicodeString src((UBool)(length<0), label, length);
|
|
UnicodeString destString(dest, 0, capacity);
|
|
IDNAInfo info;
|
|
reinterpret_cast<const IDNA *>(idna)->labelToASCII(src, destString, info, *pErrorCode);
|
|
idnaInfoToStruct(info, pInfo);
|
|
return destString.extract(dest, capacity, *pErrorCode);
|
|
}
|
|
|
|
U_CAPI int32_t U_EXPORT2
|
|
uidna_labelToUnicode(const UIDNA *idna,
|
|
const char16_t *label, int32_t length,
|
|
char16_t *dest, int32_t capacity,
|
|
UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
|
|
if(!checkArgs(label, length, dest, capacity, pInfo, pErrorCode)) {
|
|
return 0;
|
|
}
|
|
UnicodeString src((UBool)(length<0), label, length);
|
|
UnicodeString destString(dest, 0, capacity);
|
|
IDNAInfo info;
|
|
reinterpret_cast<const IDNA *>(idna)->labelToUnicode(src, destString, info, *pErrorCode);
|
|
idnaInfoToStruct(info, pInfo);
|
|
return destString.extract(dest, capacity, *pErrorCode);
|
|
}
|
|
|
|
U_CAPI int32_t U_EXPORT2
|
|
uidna_nameToASCII(const UIDNA *idna,
|
|
const char16_t *name, int32_t length,
|
|
char16_t *dest, int32_t capacity,
|
|
UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
|
|
if(!checkArgs(name, length, dest, capacity, pInfo, pErrorCode)) {
|
|
return 0;
|
|
}
|
|
UnicodeString src((UBool)(length<0), name, length);
|
|
UnicodeString destString(dest, 0, capacity);
|
|
IDNAInfo info;
|
|
reinterpret_cast<const IDNA *>(idna)->nameToASCII(src, destString, info, *pErrorCode);
|
|
idnaInfoToStruct(info, pInfo);
|
|
return destString.extract(dest, capacity, *pErrorCode);
|
|
}
|
|
|
|
U_CAPI int32_t U_EXPORT2
|
|
uidna_nameToUnicode(const UIDNA *idna,
|
|
const char16_t *name, int32_t length,
|
|
char16_t *dest, int32_t capacity,
|
|
UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
|
|
if(!checkArgs(name, length, dest, capacity, pInfo, pErrorCode)) {
|
|
return 0;
|
|
}
|
|
UnicodeString src((UBool)(length<0), name, length);
|
|
UnicodeString destString(dest, 0, capacity);
|
|
IDNAInfo info;
|
|
reinterpret_cast<const IDNA *>(idna)->nameToUnicode(src, destString, info, *pErrorCode);
|
|
idnaInfoToStruct(info, pInfo);
|
|
return destString.extract(dest, capacity, *pErrorCode);
|
|
}
|
|
|
|
U_CAPI int32_t U_EXPORT2
|
|
uidna_labelToASCII_UTF8(const UIDNA *idna,
|
|
const char *label, int32_t length,
|
|
char *dest, int32_t capacity,
|
|
UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
|
|
if(!checkArgs(label, length, dest, capacity, pInfo, pErrorCode)) {
|
|
return 0;
|
|
}
|
|
StringPiece src(label, length<0 ? static_cast<int32_t>(uprv_strlen(label)) : length);
|
|
return ByteSinkUtil::viaByteSinkToTerminatedChars(
|
|
dest, capacity,
|
|
[&](ByteSink& sink, UErrorCode& status) {
|
|
IDNAInfo info;
|
|
reinterpret_cast<const IDNA *>(idna)->labelToASCII_UTF8(src, sink, info, status);
|
|
idnaInfoToStruct(info, pInfo);
|
|
},
|
|
*pErrorCode);
|
|
}
|
|
|
|
U_CAPI int32_t U_EXPORT2
|
|
uidna_labelToUnicodeUTF8(const UIDNA *idna,
|
|
const char *label, int32_t length,
|
|
char *dest, int32_t capacity,
|
|
UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
|
|
if(!checkArgs(label, length, dest, capacity, pInfo, pErrorCode)) {
|
|
return 0;
|
|
}
|
|
StringPiece src(label, length<0 ? static_cast<int32_t>(uprv_strlen(label)) : length);
|
|
return ByteSinkUtil::viaByteSinkToTerminatedChars(
|
|
dest, capacity,
|
|
[&](ByteSink& sink, UErrorCode& status) {
|
|
IDNAInfo info;
|
|
reinterpret_cast<const IDNA *>(idna)->labelToUnicodeUTF8(src, sink, info, status);
|
|
idnaInfoToStruct(info, pInfo);
|
|
},
|
|
*pErrorCode);
|
|
}
|
|
|
|
U_CAPI int32_t U_EXPORT2
|
|
uidna_nameToASCII_UTF8(const UIDNA *idna,
|
|
const char *name, int32_t length,
|
|
char *dest, int32_t capacity,
|
|
UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
|
|
if(!checkArgs(name, length, dest, capacity, pInfo, pErrorCode)) {
|
|
return 0;
|
|
}
|
|
StringPiece src(name, length<0 ? static_cast<int32_t>(uprv_strlen(name)) : length);
|
|
return ByteSinkUtil::viaByteSinkToTerminatedChars(
|
|
dest, capacity,
|
|
[&](ByteSink& sink, UErrorCode& status) {
|
|
IDNAInfo info;
|
|
reinterpret_cast<const IDNA *>(idna)->nameToASCII_UTF8(src, sink, info, status);
|
|
idnaInfoToStruct(info, pInfo);
|
|
},
|
|
*pErrorCode);
|
|
}
|
|
|
|
U_CAPI int32_t U_EXPORT2
|
|
uidna_nameToUnicodeUTF8(const UIDNA *idna,
|
|
const char *name, int32_t length,
|
|
char *dest, int32_t capacity,
|
|
UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
|
|
if(!checkArgs(name, length, dest, capacity, pInfo, pErrorCode)) {
|
|
return 0;
|
|
}
|
|
StringPiece src(name, length<0 ? static_cast<int32_t>(uprv_strlen(name)) : length);
|
|
return ByteSinkUtil::viaByteSinkToTerminatedChars(
|
|
dest, capacity,
|
|
[&](ByteSink& sink, UErrorCode& status) {
|
|
IDNAInfo info;
|
|
reinterpret_cast<const IDNA *>(idna)->nameToUnicodeUTF8(src, sink, info, status);
|
|
idnaInfoToStruct(info, pInfo);
|
|
},
|
|
*pErrorCode);
|
|
}
|
|
|
|
#endif // UCONFIG_NO_IDNA
|