/* ******************************************************************************* * Copyright (C) 2010-2014, International Business Machines * Corporation and others. All Rights Reserved. ******************************************************************************* * file name: uts46.cpp * encoding: US-ASCII * 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/idna.h" #include "unicode/normalizer2.h" #include "unicode/uscript.h" #include "unicode/ustring.h" #include "unicode/utf16.h" #include "cmemory.h" #include "cstring.h" #include "punycode.h" #include "ubidi_props.h" #include "ustr_imp.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 UChar *s=dest.getBuffer(); const UChar *limit=s+dest.length(); while(s0x7f) { return FALSE; } } return TRUE; } static UBool isASCIIOkBiDi(const UChar *s, int32_t length); static UBool isASCIIOkBiDi(const char *s, int32_t length); // IDNA class default implementations -------------------------------------- *** IDNA::~IDNA() {} void IDNA::labelToASCII_UTF8(const 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(const 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(const 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(const 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; virtual UnicodeString & labelToUnicode(const UnicodeString &label, UnicodeString &dest, IDNAInfo &info, UErrorCode &errorCode) const; virtual UnicodeString & nameToASCII(const UnicodeString &name, UnicodeString &dest, IDNAInfo &info, UErrorCode &errorCode) const; virtual UnicodeString & nameToUnicode(const UnicodeString &name, UnicodeString &dest, IDNAInfo &info, UErrorCode &errorCode) const; virtual void labelToASCII_UTF8(const StringPiece &label, ByteSink &dest, IDNAInfo &info, UErrorCode &errorCode) const; virtual void labelToUnicodeUTF8(const StringPiece &label, ByteSink &dest, IDNAInfo &info, UErrorCode &errorCode) const; virtual void nameToASCII_UTF8(const StringPiece &name, ByteSink &dest, IDNAInfo &info, UErrorCode &errorCode) const; virtual void nameToUnicodeUTF8(const StringPiece &name, ByteSink &dest, IDNAInfo &info, UErrorCode &errorCode) const; private: UnicodeString & process(const UnicodeString &src, UBool isLabel, UBool toASCII, UnicodeString &dest, IDNAInfo &info, UErrorCode &errorCode) const; void processUTF8(const 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) const; void checkLabelBiDi(const UChar *label, int32_t labelLength, IDNAInfo &info) const; UBool isLabelOkContextJ(const UChar *label, int32_t labelLength) const; void checkLabelContextO(const UChar *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==NULL) { errorCode=U_MEMORY_ALLOCATION_ERROR; } else if(U_FAILURE(errorCode)) { delete idna; idna=NULL; } return idna; } else { return NULL; } } // UTS46 implementation ---------------------------------------------------- *** UTS46::UTS46(uint32_t opt, UErrorCode &errorCode) : uts46Norm2(*Normalizer2::getInstance(NULL, "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(const StringPiece &label, ByteSink &dest, IDNAInfo &info, UErrorCode &errorCode) const { processUTF8(label, TRUE, TRUE, dest, info, errorCode); } void UTS46::labelToUnicodeUTF8(const StringPiece &label, ByteSink &dest, IDNAInfo &info, UErrorCode &errorCode) const { processUTF8(label, TRUE, FALSE, dest, info, errorCode); } void UTS46::nameToASCII_UTF8(const StringPiece &name, ByteSink &dest, IDNAInfo &info, UErrorCode &errorCode) const { processUTF8(name, FALSE, TRUE, dest, info, errorCode); } void UTS46::nameToUnicodeUTF8(const 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 UChar *srcArray=src.getBuffer(); if(&dest==&src || srcArray==NULL) { 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; } UChar *destArray=dest.getBuffer(srcLength); if(destArray==NULL) { 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 || labelStart0x7f) { 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(const 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==NULL && 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 || labelStart0x7f 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 UChar *destArray=dest.getBuffer(); int32_t destLength=dest.length(); int32_t labelLimit=labelStart; while(labelLimit=0x200c)) { info.isTransDiff=TRUE; if(doMapDevChars) { destLength=mapDevChars(dest, labelStart, labelLimit, errorCode); if(U_FAILURE(errorCode)) { return dest; } destArray=dest.getBuffer(); // Do not increment labelLimit in case c was removed. // All deviation characters have been mapped, no need to check for them again. doMapDevChars=FALSE; } else { ++labelLimit; } } else { ++labelLimit; } } // Permit an empty label at the end (0=4 && label[0]==0x78 && label[1]==0x6e && label[2]==0x2d && label[3]==0x2d) { // Label starts with "xn--", try to un-Punycode it. wasPunycode=TRUE; UChar *unicodeBuffer=fromPunycode.getBuffer(-1); // capacity==-1: most labels should fit if(unicodeBuffer==NULL) { // 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(), NULL, &punycodeErrorCode); if(punycodeErrorCode==U_BUFFER_OVERFLOW_ERROR) { fromPunycode.releaseBuffer(0); unicodeBuffer=fromPunycode.getBuffer(unicodeLength); if(unicodeBuffer==NULL) { errorCode=U_MEMORY_ALLOCATION_ERROR; return labelLength; } punycodeErrorCode=U_ZERO_ERROR; unicodeLength=u_strFromPunycode(label+4, labelLength-4, unicodeBuffer, fromPunycode.getCapacity(), NULL, &punycodeErrorCode); } fromPunycode.releaseBuffer(unicodeLength); if(U_FAILURE(punycodeErrorCode)) { info.labelErrors|=UIDNA_ERROR_PUNYCODE; return markBadACELabel(dest, labelStart, labelLength, toASCII, info); } // 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); } 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); } // 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. UChar *s=(UChar *)label; const UChar *limit=label+labelLength; UChar 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 { UChar 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(disallowNonLDHDot && isNonASCIIDisallowedSTD3Valid(c)) { info.labelErrors|=UIDNA_ERROR_DISALLOWED; *s=0xfffd; } else if(c==0xfffd) { info.labelErrors|=UIDNA_ERROR_DISALLOWED; } } ++s; } while(sreplace(labelStart, cpLength, (UChar)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; UChar *buffer=punycode.getBuffer(63); // 63==maximum DNS label length if(buffer==NULL) { 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, NULL, &errorCode); if(errorCode==U_BUFFER_OVERFLOW_ERROR) { errorCode=U_ZERO_ERROR; punycode.releaseBuffer(4); buffer=punycode.getBuffer(4+punycodeLength); if(buffer==NULL) { errorCode=U_MEMORY_ALLOCATION_ERROR; return destLabelLength; } punycodeLength=u_strToPunycode(label, labelLength, buffer+4, punycode.getCapacity()-4, NULL, &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); } 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); } } return replaceLabel(dest, destLabelStart, destLabelLength, *labelString, labelLength); } // 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) const { UBool disallowNonLDHDot=(options&UIDNA_USE_STD3_RULES)!=0; UBool isASCII=TRUE; UBool onlyLDH=TRUE; const UChar *label=dest.getBuffer()+labelStart; // Ok to cast away const because we own the UnicodeString. UChar *s=(UChar *)label+4; // After the initial "xn--". const UChar *limit=label+labelLength; do { UChar 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; } } while(++s63) { 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 UChar *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; } // Get the directionalities of the intervening characters. uint32_t mask=0; while(ilabelStart) { 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; ilabelStart) { 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 UChar *label, int32_t labelLength) const { const UBiDiProps *bdp=ubidi_getSingleton(); // [IDNA2008-Tables] // 200C..200D ; CONTEXTJ # ZERO WIDTH NON-JOINER..ZERO WIDTH JOINER for(int32_t i=0; i0) { 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(IDNA::createUTS46Instance(options, *pErrorCode)); } U_CAPI void U_EXPORT2 uidna_close(UIDNA *idna) { delete reinterpret_cast(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==NULL || pInfo->size<16) { *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; return FALSE; } if( (label==NULL ? length!=0 : length<-1) || (dest==NULL ? capacity!=0 : capacity<0) || (dest==label && label!=NULL) ) { *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 UChar *label, int32_t length, UChar *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(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 UChar *label, int32_t length, UChar *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(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 UChar *name, int32_t length, UChar *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(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 UChar *name, int32_t length, UChar *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(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 ? uprv_strlen(label) : length); CheckedArrayByteSink sink(dest, capacity); IDNAInfo info; reinterpret_cast(idna)->labelToASCII_UTF8(src, sink, info, *pErrorCode); idnaInfoToStruct(info, pInfo); return u_terminateChars(dest, capacity, sink.NumberOfBytesAppended(), 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 ? uprv_strlen(label) : length); CheckedArrayByteSink sink(dest, capacity); IDNAInfo info; reinterpret_cast(idna)->labelToUnicodeUTF8(src, sink, info, *pErrorCode); idnaInfoToStruct(info, pInfo); return u_terminateChars(dest, capacity, sink.NumberOfBytesAppended(), 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 ? uprv_strlen(name) : length); CheckedArrayByteSink sink(dest, capacity); IDNAInfo info; reinterpret_cast(idna)->nameToASCII_UTF8(src, sink, info, *pErrorCode); idnaInfoToStruct(info, pInfo); return u_terminateChars(dest, capacity, sink.NumberOfBytesAppended(), 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 ? uprv_strlen(name) : length); CheckedArrayByteSink sink(dest, capacity); IDNAInfo info; reinterpret_cast(idna)->nameToUnicodeUTF8(src, sink, info, *pErrorCode); idnaInfoToStruct(info, pInfo); return u_terminateChars(dest, capacity, sink.NumberOfBytesAppended(), pErrorCode); } #endif // UCONFIG_NO_IDNA