icuSources/common/uts46.cpp

   1 /*
   2 *******************************************************************************
   3 *   Copyright (C) 2010-2014, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 *******************************************************************************
   6 *   file name:  uts46.cpp
   7 *   encoding:   US-ASCII
   8 *   tab size:   8 (not used)
   9 *   indentation:4
  10 *
  11 *   created on: 2010mar09
  12 *   created by: Markus W. Scherer
  13 */
  14
  15 #include "unicode/utypes.h"
  16
  17 #if !UCONFIG_NO_IDNA
  18
  19 #include "unicode/idna.h"
  20 #include "unicode/normalizer2.h"
  21 #include "unicode/uscript.h"
  22 #include "unicode/ustring.h"
  23 #include "unicode/utf16.h"
  24 #include "cmemory.h"
  25 #include "cstring.h"
  26 #include "punycode.h"
  27 #include "ubidi_props.h"
  28 #include "ustr_imp.h"
  29
  30 // Note about tests for UIDNA_ERROR_DOMAIN_NAME_TOO_LONG:
  31 //
  32 // The domain name length limit is 255 octets in an internal DNS representation
  33 // where the last ("root") label is the empty label
  34 // represented by length byte 0 alone.
  35 // In a conventional string, this translates to 253 characters, or 254
  36 // if there is a trailing dot for the root label.
  37
  38 U_NAMESPACE_BEGIN
  39
  40 // Severe errors which usually result in a U+FFFD replacement character in the result string.
  41 const uint32_t severeErrors=
  42     UIDNA_ERROR_LEADING_COMBINING_MARK|
  43     UIDNA_ERROR_DISALLOWED|
  44     UIDNA_ERROR_PUNYCODE|
  45     UIDNA_ERROR_LABEL_HAS_DOT|
  46     UIDNA_ERROR_INVALID_ACE_LABEL;
  47
  48 static inline UBool
  49 isASCIIString(const UnicodeString &dest) {
  50     const UChar *s=dest.getBuffer();
  51     const UChar *limit=s+dest.length();
  52     while(s<limit) {
  53         if(*s++>0x7f) {
  54             return FALSE;
  55         }
  56     }
  57     return TRUE;
  58 }
  59
  60 static UBool
  61 isASCIIOkBiDi(const UChar *s, int32_t length);
  62
  63 static UBool
  64 isASCIIOkBiDi(const char *s, int32_t length);
  65
  66 // IDNA class default implementations -------------------------------------- ***
  67
  68 IDNA::~IDNA() {}
  69
  70 void
  71 IDNA::labelToASCII_UTF8(const StringPiece &label, ByteSink &dest,
  72                         IDNAInfo &info, UErrorCode &errorCode) const {
  73     if(U_SUCCESS(errorCode)) {
  74         UnicodeString destString;
  75         labelToASCII(UnicodeString::fromUTF8(label), destString,
  76                      info, errorCode).toUTF8(dest);
  77     }
  78 }
  79
  80 void
  81 IDNA::labelToUnicodeUTF8(const StringPiece &label, ByteSink &dest,
  82                          IDNAInfo &info, UErrorCode &errorCode) const {
  83     if(U_SUCCESS(errorCode)) {
  84         UnicodeString destString;
  85         labelToUnicode(UnicodeString::fromUTF8(label), destString,
  86                        info, errorCode).toUTF8(dest);
  87     }
  88 }
  89
  90 void
  91 IDNA::nameToASCII_UTF8(const StringPiece &name, ByteSink &dest,
  92                        IDNAInfo &info, UErrorCode &errorCode) const {
  93     if(U_SUCCESS(errorCode)) {
  94         UnicodeString destString;
  95         nameToASCII(UnicodeString::fromUTF8(name), destString,
  96                     info, errorCode).toUTF8(dest);
  97     }
  98 }
  99
 100 void
 101 IDNA::nameToUnicodeUTF8(const StringPiece &name, ByteSink &dest,
 102                         IDNAInfo &info, UErrorCode &errorCode) const {
 103     if(U_SUCCESS(errorCode)) {
 104         UnicodeString destString;
 105         nameToUnicode(UnicodeString::fromUTF8(name), destString,
 106                       info, errorCode).toUTF8(dest);
 107     }
 108 }
 109
 110 // UTS46 class declaration ------------------------------------------------- ***
 111
 112 class UTS46 : public IDNA {
 113 public:
 114     UTS46(uint32_t options, UErrorCode &errorCode);
 115     virtual ~UTS46();
 116
 117     virtual UnicodeString &
 118     labelToASCII(const UnicodeString &label, UnicodeString &dest,
 119                  IDNAInfo &info, UErrorCode &errorCode) const;
 120
 121     virtual UnicodeString &
 122     labelToUnicode(const UnicodeString &label, UnicodeString &dest,
 123                    IDNAInfo &info, UErrorCode &errorCode) const;
 124
 125     virtual UnicodeString &
 126     nameToASCII(const UnicodeString &name, UnicodeString &dest,
 127                 IDNAInfo &info, UErrorCode &errorCode) const;
 128
 129     virtual UnicodeString &
 130     nameToUnicode(const UnicodeString &name, UnicodeString &dest,
 131                   IDNAInfo &info, UErrorCode &errorCode) const;
 132
 133     virtual void
 134     labelToASCII_UTF8(const StringPiece &label, ByteSink &dest,
 135                       IDNAInfo &info, UErrorCode &errorCode) const;
 136
 137     virtual void
 138     labelToUnicodeUTF8(const StringPiece &label, ByteSink &dest,
 139                        IDNAInfo &info, UErrorCode &errorCode) const;
 140
 141     virtual void
 142     nameToASCII_UTF8(const StringPiece &name, ByteSink &dest,
 143                      IDNAInfo &info, UErrorCode &errorCode) const;
 144
 145     virtual void
 146     nameToUnicodeUTF8(const StringPiece &name, ByteSink &dest,
 147                       IDNAInfo &info, UErrorCode &errorCode) const;
 148
 149 private:
 150     UnicodeString &
 151     process(const UnicodeString &src,
 152             UBool isLabel, UBool toASCII,
 153             UnicodeString &dest,
 154             IDNAInfo &info, UErrorCode &errorCode) const;
 155
 156     void
 157     processUTF8(const StringPiece &src,
 158                 UBool isLabel, UBool toASCII,
 159                 ByteSink &dest,
 160                 IDNAInfo &info, UErrorCode &errorCode) const;
 161
 162     UnicodeString &
 163     processUnicode(const UnicodeString &src,
 164                    int32_t labelStart, int32_t mappingStart,
 165                    UBool isLabel, UBool toASCII,
 166                    UnicodeString &dest,
 167                    IDNAInfo &info, UErrorCode &errorCode) const;
 168
 169     // returns the new dest.length()
 170     int32_t
 171     mapDevChars(UnicodeString &dest, int32_t labelStart, int32_t mappingStart,
 172                 UErrorCode &errorCode) const;
 173
 174     // returns the new label length
 175     int32_t
 176     processLabel(UnicodeString &dest,
 177                  int32_t labelStart, int32_t labelLength,
 178                  UBool toASCII,
 179                  IDNAInfo &info, UErrorCode &errorCode) const;
 180     int32_t
 181     markBadACELabel(UnicodeString &dest,
 182                     int32_t labelStart, int32_t labelLength,
 183                     UBool toASCII, IDNAInfo &info) const;
 184
 185     void
 186     checkLabelBiDi(const UChar *label, int32_t labelLength, IDNAInfo &info) const;
 187
 188     UBool
 189     isLabelOkContextJ(const UChar *label, int32_t labelLength) const;
 190
 191     void
 192     checkLabelContextO(const UChar *label, int32_t labelLength, IDNAInfo &info) const;
 193
 194     const Normalizer2 &uts46Norm2;  // uts46.nrm
 195     uint32_t options;
 196 };
 197
 198 IDNA *
 199 IDNA::createUTS46Instance(uint32_t options, UErrorCode &errorCode) {
 200     if(U_SUCCESS(errorCode)) {
 201         IDNA *idna=new UTS46(options, errorCode);
 202         if(idna==NULL) {
 203             errorCode=U_MEMORY_ALLOCATION_ERROR;
 204         } else if(U_FAILURE(errorCode)) {
 205             delete idna;
 206             idna=NULL;
 207         }
 208         return idna;
 209     } else {
 210         return NULL;
 211     }
 212 }
 213
 214 // UTS46 implementation ---------------------------------------------------- ***
 215
 216 UTS46::UTS46(uint32_t opt, UErrorCode &errorCode)
 217         : uts46Norm2(*Normalizer2::getInstance(NULL, "uts46", UNORM2_COMPOSE, errorCode)),
 218           options(opt) {}
 219
 220 UTS46::~UTS46() {}
 221
 222 UnicodeString &
 223 UTS46::labelToASCII(const UnicodeString &label, UnicodeString &dest,
 224                     IDNAInfo &info, UErrorCode &errorCode) const {
 225     return process(label, TRUE, TRUE, dest, info, errorCode);
 226 }
 227
 228 UnicodeString &
 229 UTS46::labelToUnicode(const UnicodeString &label, UnicodeString &dest,
 230                       IDNAInfo &info, UErrorCode &errorCode) const {
 231     return process(label, TRUE, FALSE, dest, info, errorCode);
 232 }
 233
 234 UnicodeString &
 235 UTS46::nameToASCII(const UnicodeString &name, UnicodeString &dest,
 236                    IDNAInfo &info, UErrorCode &errorCode) const {
 237     process(name, FALSE, TRUE, dest, info, errorCode);
 238     if( dest.length()>=254 && (info.errors&UIDNA_ERROR_DOMAIN_NAME_TOO_LONG)==0 &&
 239         isASCIIString(dest) &&
 240         (dest.length()>254 || dest[253]!=0x2e)
 241     ) {
 242         info.errors|=UIDNA_ERROR_DOMAIN_NAME_TOO_LONG;
 243     }
 244     return dest;
 245 }
 246
 247 UnicodeString &
 248 UTS46::nameToUnicode(const UnicodeString &name, UnicodeString &dest,
 249                      IDNAInfo &info, UErrorCode &errorCode) const {
 250     return process(name, FALSE, FALSE, dest, info, errorCode);
 251 }
 252
 253 void
 254 UTS46::labelToASCII_UTF8(const StringPiece &label, ByteSink &dest,
 255                          IDNAInfo &info, UErrorCode &errorCode) const {
 256     processUTF8(label, TRUE, TRUE, dest, info, errorCode);
 257 }
 258
 259 void
 260 UTS46::labelToUnicodeUTF8(const StringPiece &label, ByteSink &dest,
 261                           IDNAInfo &info, UErrorCode &errorCode) const {
 262     processUTF8(label, TRUE, FALSE, dest, info, errorCode);
 263 }
 264
 265 void
 266 UTS46::nameToASCII_UTF8(const StringPiece &name, ByteSink &dest,
 267                         IDNAInfo &info, UErrorCode &errorCode) const {
 268     processUTF8(name, FALSE, TRUE, dest, info, errorCode);
 269 }
 270
 271 void
 272 UTS46::nameToUnicodeUTF8(const StringPiece &name, ByteSink &dest,
 273                          IDNAInfo &info, UErrorCode &errorCode) const {
 274     processUTF8(name, FALSE, FALSE, dest, info, errorCode);
 275 }
 276
 277 // UTS #46 data for ASCII characters.
 278 // The normalizer (using uts46.nrm) maps uppercase ASCII letters to lowercase
 279 // and passes through all other ASCII characters.
 280 // If UIDNA_USE_STD3_RULES is set, then non-LDH characters are disallowed
 281 // using this data.
 282 // The ASCII fastpath also uses this data.
 283 // Values: -1=disallowed  0==valid  1==mapped (lowercase)
 284 static const int8_t asciiData[128]={
 285     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 286     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 287     // 002D..002E; valid  #  HYPHEN-MINUS..FULL STOP
 288     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  0,  0, -1,
 289     // 0030..0039; valid  #  DIGIT ZERO..DIGIT NINE
 290      0,  0,  0,  0,  0,  0,  0,  0,  0,  0, -1, -1, -1, -1, -1, -1,
 291     // 0041..005A; mapped  #  LATIN CAPITAL LETTER A..LATIN CAPITAL LETTER Z
 292     -1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
 293      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1, -1, -1, -1, -1, -1,
 294     // 0061..007A; valid  #  LATIN SMALL LETTER A..LATIN SMALL LETTER Z
 295     -1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
 296      0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, -1, -1, -1, -1, -1
 297 };
 298
 299 UnicodeString &
 300 UTS46::process(const UnicodeString &src,
 301                UBool isLabel, UBool toASCII,
 302                UnicodeString &dest,
 303                IDNAInfo &info, UErrorCode &errorCode) const {
 304     // uts46Norm2.normalize() would do all of this error checking and setup,
 305     // but with the ASCII fastpath we do not always call it, and do not
 306     // call it first.
 307     if(U_FAILURE(errorCode)) {
 308         dest.setToBogus();
 309         return dest;
 310     }
 311     const UChar *srcArray=src.getBuffer();
 312     if(&dest==&src || srcArray==NULL) {
 313         errorCode=U_ILLEGAL_ARGUMENT_ERROR;
 314         dest.setToBogus();
 315         return dest;
 316     }
 317     // Arguments are fine, reset output values.
 318     dest.remove();
 319     info.reset();
 320     int32_t srcLength=src.length();
 321     if(srcLength==0) {
 322         info.errors|=UIDNA_ERROR_EMPTY_LABEL;
 323         return dest;
 324     }
 325     UChar *destArray=dest.getBuffer(srcLength);
 326     if(destArray==NULL) {
 327         errorCode=U_MEMORY_ALLOCATION_ERROR;
 328         return dest;
 329     }
 330     // ASCII fastpath
 331     UBool disallowNonLDHDot=(options&UIDNA_USE_STD3_RULES)!=0;
 332     int32_t labelStart=0;
 333     int32_t i;
 334     for(i=0;; ++i) {
 335         if(i==srcLength) {
 336             if(toASCII) {
 337                 if((i-labelStart)>63) {
 338                     info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
 339                 }
 340                 // There is a trailing dot if labelStart==i.
 341                 if(!isLabel && i>=254 && (i>254 || labelStart<i)) {
 342                     info.errors|=UIDNA_ERROR_DOMAIN_NAME_TOO_LONG;
 343                 }
 344             }
 345             info.errors|=info.labelErrors;
 346             dest.releaseBuffer(i);
 347             return dest;
 348         }
 349         UChar c=srcArray[i];
 350         if(c>0x7f) {
 351             break;
 352         }
 353         int cData=asciiData[c];
 354         if(cData>0) {
 355             destArray[i]=c+0x20;  // Lowercase an uppercase ASCII letter.
 356         } else if(cData<0 && disallowNonLDHDot) {
 357             break;  // Replacing with U+FFFD can be complicated for toASCII.
 358         } else {
 359             destArray[i]=c;
 360             if(c==0x2d) {  // hyphen
 361                 if(i==(labelStart+3) && srcArray[i-1]==0x2d) {
 362                     // "??--..." is Punycode or forbidden.
 363                     ++i;  // '-' was copied to dest already
 364                     break;
 365                 }
 366                 if(i==labelStart) {
 367                     // label starts with "-"
 368                     info.labelErrors|=UIDNA_ERROR_LEADING_HYPHEN;
 369                 }
 370                 if((i+1)==srcLength || srcArray[i+1]==0x2e) {
 371                     // label ends with "-"
 372                     info.labelErrors|=UIDNA_ERROR_TRAILING_HYPHEN;
 373                 }
 374             } else if(c==0x2e) {  // dot
 375                 if(isLabel) {
 376                     // Replacing with U+FFFD can be complicated for toASCII.
 377                     ++i;  // '.' was copied to dest already
 378                     break;
 379                 }
 380                 if(i==labelStart) {
 381                     info.labelErrors|=UIDNA_ERROR_EMPTY_LABEL;
 382                 }
 383                 if(toASCII && (i-labelStart)>63) {
 384                     info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
 385                 }
 386                 info.errors|=info.labelErrors;
 387                 info.labelErrors=0;
 388                 labelStart=i+1;
 389             }
 390         }
 391     }
 392     info.errors|=info.labelErrors;
 393     dest.releaseBuffer(i);
 394     processUnicode(src, labelStart, i, isLabel, toASCII, dest, info, errorCode);
 395     if( info.isBiDi && U_SUCCESS(errorCode) && (info.errors&severeErrors)==0 &&
 396         (!info.isOkBiDi || (labelStart>0 && !isASCIIOkBiDi(dest.getBuffer(), labelStart)))
 397     ) {
 398         info.errors|=UIDNA_ERROR_BIDI;
 399     }
 400     return dest;
 401 }
 402
 403 void
 404 UTS46::processUTF8(const StringPiece &src,
 405                    UBool isLabel, UBool toASCII,
 406                    ByteSink &dest,
 407                    IDNAInfo &info, UErrorCode &errorCode) const {
 408     if(U_FAILURE(errorCode)) {
 409         return;
 410     }
 411     const char *srcArray=src.data();
 412     int32_t srcLength=src.length();
 413     if(srcArray==NULL && srcLength!=0) {
 414         errorCode=U_ILLEGAL_ARGUMENT_ERROR;
 415         return;
 416     }
 417     // Arguments are fine, reset output values.
 418     info.reset();
 419     if(srcLength==0) {
 420         info.errors|=UIDNA_ERROR_EMPTY_LABEL;
 421         dest.Flush();
 422         return;
 423     }
 424     UnicodeString destString;
 425     int32_t labelStart=0;
 426     if(srcLength<=256) {  // length of stackArray[]
 427         // ASCII fastpath
 428         char stackArray[256];
 429         int32_t destCapacity;
 430         char *destArray=dest.GetAppendBuffer(srcLength, srcLength+20,
 431                                              stackArray, UPRV_LENGTHOF(stackArray), &destCapacity);
 432         UBool disallowNonLDHDot=(options&UIDNA_USE_STD3_RULES)!=0;
 433         int32_t i;
 434         for(i=0;; ++i) {
 435             if(i==srcLength) {
 436                 if(toASCII) {
 437                     if((i-labelStart)>63) {
 438                         info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
 439                     }
 440                     // There is a trailing dot if labelStart==i.
 441                     if(!isLabel && i>=254 && (i>254 || labelStart<i)) {
 442                         info.errors|=UIDNA_ERROR_DOMAIN_NAME_TOO_LONG;
 443                     }
 444                 }
 445                 info.errors|=info.labelErrors;
 446                 dest.Append(destArray, i);
 447                 dest.Flush();
 448                 return;
 449             }
 450             char c=srcArray[i];
 451             if((int8_t)c<0) {  // (uint8_t)c>0x7f
 452                 break;
 453             }
 454             int cData=asciiData[(int)c];  // Cast: gcc warns about indexing with a char.
 455             if(cData>0) {
 456                 destArray[i]=c+0x20;  // Lowercase an uppercase ASCII letter.
 457             } else if(cData<0 && disallowNonLDHDot) {
 458                 break;  // Replacing with U+FFFD can be complicated for toASCII.
 459             } else {
 460                 destArray[i]=c;
 461                 if(c==0x2d) {  // hyphen
 462                     if(i==(labelStart+3) && srcArray[i-1]==0x2d) {
 463                         // "??--..." is Punycode or forbidden.
 464                         break;
 465                     }
 466                     if(i==labelStart) {
 467                         // label starts with "-"
 468                         info.labelErrors|=UIDNA_ERROR_LEADING_HYPHEN;
 469                     }
 470                     if((i+1)==srcLength || srcArray[i+1]==0x2e) {
 471                         // label ends with "-"
 472                         info.labelErrors|=UIDNA_ERROR_TRAILING_HYPHEN;
 473                     }
 474                 } else if(c==0x2e) {  // dot
 475                     if(isLabel) {
 476                         break;  // Replacing with U+FFFD can be complicated for toASCII.
 477                     }
 478                     if(i==labelStart) {
 479                         info.labelErrors|=UIDNA_ERROR_EMPTY_LABEL;
 480                     }
 481                     if(toASCII && (i-labelStart)>63) {
 482                         info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
 483                     }
 484                     info.errors|=info.labelErrors;
 485                     info.labelErrors=0;
 486                     labelStart=i+1;
 487                 }
 488             }
 489         }
 490         info.errors|=info.labelErrors;
 491         // Convert the processed ASCII prefix of the current label to UTF-16.
 492         int32_t mappingStart=i-labelStart;
 493         destString=UnicodeString::fromUTF8(StringPiece(destArray+labelStart, mappingStart));
 494         // Output the previous ASCII labels and process the rest of src in UTF-16.
 495         dest.Append(destArray, labelStart);
 496         processUnicode(UnicodeString::fromUTF8(StringPiece(src, labelStart)), 0, mappingStart,
 497                        isLabel, toASCII,
 498                        destString, info, errorCode);
 499     } else {
 500         // src is too long for the ASCII fastpath implementation.
 501         processUnicode(UnicodeString::fromUTF8(src), 0, 0,
 502                        isLabel, toASCII,
 503                        destString, info, errorCode);
 504     }
 505     destString.toUTF8(dest);  // calls dest.Flush()
 506     if(toASCII && !isLabel) {
 507         // length==labelStart==254 means that there is a trailing dot (ok) and
 508         // destString is empty (do not index at 253-labelStart).
 509         int32_t length=labelStart+destString.length();
 510         if( length>=254 && isASCIIString(destString) &&
 511             (length>254 ||
 512              (labelStart<254 && destString[253-labelStart]!=0x2e))
 513         ) {
 514             info.errors|=UIDNA_ERROR_DOMAIN_NAME_TOO_LONG;
 515         }
 516     }
 517     if( info.isBiDi && U_SUCCESS(errorCode) && (info.errors&severeErrors)==0 &&
 518         (!info.isOkBiDi || (labelStart>0 && !isASCIIOkBiDi(srcArray, labelStart)))
 519     ) {
 520         info.errors|=UIDNA_ERROR_BIDI;
 521     }
 522 }
 523
 524 UnicodeString &
 525 UTS46::processUnicode(const UnicodeString &src,
 526                       int32_t labelStart, int32_t mappingStart,
 527                       UBool isLabel, UBool toASCII,
 528                       UnicodeString &dest,
 529                       IDNAInfo &info, UErrorCode &errorCode) const {
 530     if(mappingStart==0) {
 531         uts46Norm2.normalize(src, dest, errorCode);
 532     } else {
 533         uts46Norm2.normalizeSecondAndAppend(dest, src.tempSubString(mappingStart), errorCode);
 534     }
 535     if(U_FAILURE(errorCode)) {
 536         return dest;
 537     }
 538     UBool doMapDevChars=
 539         toASCII ? (options&UIDNA_NONTRANSITIONAL_TO_ASCII)==0 :
 540                   (options&UIDNA_NONTRANSITIONAL_TO_UNICODE)==0;
 541     const UChar *destArray=dest.getBuffer();
 542     int32_t destLength=dest.length();
 543     int32_t labelLimit=labelStart;
 544     while(labelLimit<destLength) {
 545         UChar c=destArray[labelLimit];
 546         if(c==0x2e && !isLabel) {
 547             int32_t labelLength=labelLimit-labelStart;
 548             int32_t newLength=processLabel(dest, labelStart, labelLength,
 549                                             toASCII, info, errorCode);
 550             info.errors|=info.labelErrors;
 551             info.labelErrors=0;
 552             if(U_FAILURE(errorCode)) {
 553                 return dest;
 554             }
 555             destArray=dest.getBuffer();
 556             destLength+=newLength-labelLength;
 557             labelLimit=labelStart+=newLength+1;
 558         } else if(0xdf<=c && c<=0x200d && (c==0xdf || c==0x3c2 || c>=0x200c)) {
 559             info.isTransDiff=TRUE;
 560             if(doMapDevChars) {
 561                 destLength=mapDevChars(dest, labelStart, labelLimit, errorCode);
 562                 if(U_FAILURE(errorCode)) {
 563                     return dest;
 564                 }
 565                 destArray=dest.getBuffer();
 566                 // Do not increment labelLimit in case c was removed.
 567                 // All deviation characters have been mapped, no need to check for them again.
 568                 doMapDevChars=FALSE;
 569             } else {
 570                 ++labelLimit;
 571             }
 572         } else {
 573             ++labelLimit;
 574         }
 575     }
 576     // Permit an empty label at the end (0<labelStart==labelLimit==destLength is ok)
 577     // but not an empty label elsewhere nor a completely empty domain name.
 578     // processLabel() sets UIDNA_ERROR_EMPTY_LABEL when labelLength==0.
 579     if(0==labelStart || labelStart<labelLimit) {
 580         processLabel(dest, labelStart, labelLimit-labelStart,
 581                       toASCII, info, errorCode);
 582         info.errors|=info.labelErrors;
 583     }
 584     return dest;
 585 }
 586
 587 int32_t
 588 UTS46::mapDevChars(UnicodeString &dest, int32_t labelStart, int32_t mappingStart,
 589                    UErrorCode &errorCode) const {
 590     int32_t length=dest.length();
 591     UChar *s=dest.getBuffer(dest[mappingStart]==0xdf ? length+1 : length);
 592     if(s==NULL) {
 593         errorCode=U_MEMORY_ALLOCATION_ERROR;
 594         return length;
 595     }
 596     int32_t capacity=dest.getCapacity();
 597     UBool didMapDevChars=FALSE;
 598     int32_t readIndex=mappingStart, writeIndex=mappingStart;
 599     do {
 600         UChar c=s[readIndex++];
 601         switch(c) {
 602         case 0xdf:
 603             // Map sharp s to ss.
 604             didMapDevChars=TRUE;
 605             s[writeIndex++]=0x73;  // Replace sharp s with first s.
 606             // Insert second s and account for possible buffer reallocation.
 607             if(writeIndex==readIndex) {
 608                 if(length==capacity) {
 609                     dest.releaseBuffer(length);
 610                     s=dest.getBuffer(length+1);
 611                     if(s==NULL) {
 612                         errorCode=U_MEMORY_ALLOCATION_ERROR;
 613                         return length;
 614                     }
 615                     capacity=dest.getCapacity();
 616                 }
 617                 u_memmove(s+writeIndex+1, s+writeIndex, length-writeIndex);
 618                 ++readIndex;
 619             }
 620             s[writeIndex++]=0x73;
 621             ++length;
 622             break;
 623         case 0x3c2:  // Map final sigma to nonfinal sigma.
 624             didMapDevChars=TRUE;
 625             s[writeIndex++]=0x3c3;
 626             break;
 627         case 0x200c:  // Ignore/remove ZWNJ.
 628         case 0x200d:  // Ignore/remove ZWJ.
 629             didMapDevChars=TRUE;
 630             --length;
 631             break;
 632         default:
 633             // Only really necessary if writeIndex was different from readIndex.
 634             s[writeIndex++]=c;
 635             break;
 636         }
 637     } while(writeIndex<length);
 638     dest.releaseBuffer(length);
 639     if(didMapDevChars) {
 640         // Mapping deviation characters might have resulted in an un-NFC string.
 641         // We could use either the NFC or the UTS #46 normalizer.
 642         // By using the UTS #46 normalizer again, we avoid having to load a second .nrm data file.
 643         UnicodeString normalized;
 644         uts46Norm2.normalize(dest.tempSubString(labelStart), normalized, errorCode);
 645         if(U_SUCCESS(errorCode)) {
 646             dest.replace(labelStart, 0x7fffffff, normalized);
 647             return dest.length();
 648         }
 649     }
 650     return length;
 651 }
 652
 653 // Some non-ASCII characters are equivalent to sequences with
 654 // non-LDH ASCII characters. To find them:
 655 // grep disallowed_STD3_valid IdnaMappingTable.txt (or uts46.txt)
 656 static inline UBool
 657 isNonASCIIDisallowedSTD3Valid(UChar32 c) {
 658     return c==0x2260 || c==0x226E || c==0x226F;
 659 }
 660
 661 // Replace the label in dest with the label string, if the label was modified.
 662 // If &label==&dest then the label was modified in-place and labelLength
 663 // is the new label length, different from label.length().
 664 // If &label!=&dest then labelLength==label.length().
 665 // Returns labelLength (= the new label length).
 666 static int32_t
 667 replaceLabel(UnicodeString &dest, int32_t destLabelStart, int32_t destLabelLength,
 668              const UnicodeString &label, int32_t labelLength) {
 669     if(&label!=&dest) {
 670         dest.replace(destLabelStart, destLabelLength, label);
 671     }
 672     return labelLength;
 673 }
 674
 675 int32_t
 676 UTS46::processLabel(UnicodeString &dest,
 677                     int32_t labelStart, int32_t labelLength,
 678                     UBool toASCII,
 679                     IDNAInfo &info, UErrorCode &errorCode) const {
 680     UnicodeString fromPunycode;
 681     UnicodeString *labelString;
 682     const UChar *label=dest.getBuffer()+labelStart;
 683     int32_t destLabelStart=labelStart;
 684     int32_t destLabelLength=labelLength;
 685     UBool wasPunycode;
 686     if(labelLength>=4 && label[0]==0x78 && label[1]==0x6e && label[2]==0x2d && label[3]==0x2d) {
 687         // Label starts with "xn--", try to un-Punycode it.
 688         wasPunycode=TRUE;
 689         UChar *unicodeBuffer=fromPunycode.getBuffer(-1);  // capacity==-1: most labels should fit
 690         if(unicodeBuffer==NULL) {
 691             // Should never occur if we used capacity==-1 which uses the internal buffer.
 692             errorCode=U_MEMORY_ALLOCATION_ERROR;
 693             return labelLength;
 694         }
 695         UErrorCode punycodeErrorCode=U_ZERO_ERROR;
 696         int32_t unicodeLength=u_strFromPunycode(label+4, labelLength-4,
 697                                                 unicodeBuffer, fromPunycode.getCapacity(),
 698                                                 NULL, &punycodeErrorCode);
 699         if(punycodeErrorCode==U_BUFFER_OVERFLOW_ERROR) {
 700             fromPunycode.releaseBuffer(0);
 701             unicodeBuffer=fromPunycode.getBuffer(unicodeLength);
 702             if(unicodeBuffer==NULL) {
 703                 errorCode=U_MEMORY_ALLOCATION_ERROR;
 704                 return labelLength;
 705             }
 706             punycodeErrorCode=U_ZERO_ERROR;
 707             unicodeLength=u_strFromPunycode(label+4, labelLength-4,
 708                                             unicodeBuffer, fromPunycode.getCapacity(),
 709                                             NULL, &punycodeErrorCode);
 710         }
 711         fromPunycode.releaseBuffer(unicodeLength);
 712         if(U_FAILURE(punycodeErrorCode)) {
 713             info.labelErrors|=UIDNA_ERROR_PUNYCODE;
 714             return markBadACELabel(dest, labelStart, labelLength, toASCII, info);
 715         }
 716         // Check for NFC, and for characters that are not
 717         // valid or deviation characters according to the normalizer.
 718         // If there is something wrong, then the string will change.
 719         // Note that the normalizer passes through non-LDH ASCII and deviation characters.
 720         // Deviation characters are ok in Punycode even in transitional processing.
 721         // In the code further below, if we find non-LDH ASCII and we have UIDNA_USE_STD3_RULES
 722         // then we will set UIDNA_ERROR_INVALID_ACE_LABEL there too.
 723         UBool isValid=uts46Norm2.isNormalized(fromPunycode, errorCode);
 724         if(U_FAILURE(errorCode)) {
 725             return labelLength;
 726         }
 727         if(!isValid) {
 728             info.labelErrors|=UIDNA_ERROR_INVALID_ACE_LABEL;
 729             return markBadACELabel(dest, labelStart, labelLength, toASCII, info);
 730         }
 731         labelString=&fromPunycode;
 732         label=fromPunycode.getBuffer();
 733         labelStart=0;
 734         labelLength=fromPunycode.length();
 735     } else {
 736         wasPunycode=FALSE;
 737         labelString=&dest;
 738     }
 739     // Validity check
 740     if(labelLength==0) {
 741         info.labelErrors|=UIDNA_ERROR_EMPTY_LABEL;
 742         return replaceLabel(dest, destLabelStart, destLabelLength, *labelString, labelLength);
 743     }
 744     // labelLength>0
 745     if(labelLength>=4 && label[2]==0x2d && label[3]==0x2d) {
 746         // label starts with "??--"
 747         info.labelErrors|=UIDNA_ERROR_HYPHEN_3_4;
 748     }
 749     if(label[0]==0x2d) {
 750         // label starts with "-"
 751         info.labelErrors|=UIDNA_ERROR_LEADING_HYPHEN;
 752     }
 753     if(label[labelLength-1]==0x2d) {
 754         // label ends with "-"
 755         info.labelErrors|=UIDNA_ERROR_TRAILING_HYPHEN;
 756     }
 757     // If the label was not a Punycode label, then it was the result of
 758     // mapping, normalization and label segmentation.
 759     // If the label was in Punycode, then we mapped it again above
 760     // and checked its validity.
 761     // Now we handle the STD3 restriction to LDH characters (if set)
 762     // and we look for U+FFFD which indicates disallowed characters
 763     // in a non-Punycode label or U+FFFD itself in a Punycode label.
 764     // We also check for dots which can come from the input to a single-label function.
 765     // Ok to cast away const because we own the UnicodeString.
 766     UChar *s=(UChar *)label;
 767     const UChar *limit=label+labelLength;
 768     UChar oredChars=0;
 769     // If we enforce STD3 rules, then ASCII characters other than LDH and dot are disallowed.
 770     UBool disallowNonLDHDot=(options&UIDNA_USE_STD3_RULES)!=0;
 771     do {
 772         UChar c=*s;
 773         if(c<=0x7f) {
 774             if(c==0x2e) {
 775                 info.labelErrors|=UIDNA_ERROR_LABEL_HAS_DOT;
 776                 *s=0xfffd;
 777             } else if(disallowNonLDHDot && asciiData[c]<0) {
 778                 info.labelErrors|=UIDNA_ERROR_DISALLOWED;
 779                 *s=0xfffd;
 780             }
 781         } else {
 782             oredChars|=c;
 783             if(disallowNonLDHDot && isNonASCIIDisallowedSTD3Valid(c)) {
 784                 info.labelErrors|=UIDNA_ERROR_DISALLOWED;
 785                 *s=0xfffd;
 786             } else if(c==0xfffd) {
 787                 info.labelErrors|=UIDNA_ERROR_DISALLOWED;
 788             }
 789         }
 790         ++s;
 791     } while(s<limit);
 792     // Check for a leading combining mark after other validity checks
 793     // so that we don't report UIDNA_ERROR_DISALLOWED for the U+FFFD from here.
 794     UChar32 c;
 795     int32_t cpLength=0;
 796     // "Unsafe" is ok because unpaired surrogates were mapped to U+FFFD.
 797     U16_NEXT_UNSAFE(label, cpLength, c);
 798     if((U_GET_GC_MASK(c)&U_GC_M_MASK)!=0) {
 799         info.labelErrors|=UIDNA_ERROR_LEADING_COMBINING_MARK;
 800         labelString->replace(labelStart, cpLength, (UChar)0xfffd);
 801         label=labelString->getBuffer()+labelStart;
 802         labelLength+=1-cpLength;
 803         if(labelString==&dest) {
 804             destLabelLength=labelLength;
 805         }
 806     }
 807     if((info.labelErrors&severeErrors)==0) {
 808         // Do contextual checks only if we do not have U+FFFD from a severe error
 809         // because U+FFFD can make these checks fail.
 810         if((options&UIDNA_CHECK_BIDI)!=0 && (!info.isBiDi || info.isOkBiDi)) {
 811             checkLabelBiDi(label, labelLength, info);
 812         }
 813         if( (options&UIDNA_CHECK_CONTEXTJ)!=0 && (oredChars&0x200c)==0x200c &&
 814             !isLabelOkContextJ(label, labelLength)
 815         ) {
 816             info.labelErrors|=UIDNA_ERROR_CONTEXTJ;
 817         }
 818         if((options&UIDNA_CHECK_CONTEXTO)!=0 && oredChars>=0xb7) {
 819             checkLabelContextO(label, labelLength, info);
 820         }
 821         if(toASCII) {
 822             if(wasPunycode) {
 823                 // Leave a Punycode label unchanged if it has no severe errors.
 824                 if(destLabelLength>63) {
 825                     info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
 826                 }
 827                 return destLabelLength;
 828             } else if(oredChars>=0x80) {
 829                 // Contains non-ASCII characters.
 830                 UnicodeString punycode;
 831                 UChar *buffer=punycode.getBuffer(63);  // 63==maximum DNS label length
 832                 if(buffer==NULL) {
 833                     errorCode=U_MEMORY_ALLOCATION_ERROR;
 834                     return destLabelLength;
 835                 }
 836                 buffer[0]=0x78;  // Write "xn--".
 837                 buffer[1]=0x6e;
 838                 buffer[2]=0x2d;
 839                 buffer[3]=0x2d;
 840                 int32_t punycodeLength=u_strToPunycode(label, labelLength,
 841                                                       buffer+4, punycode.getCapacity()-4,
 842                                                       NULL, &errorCode);
 843                 if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
 844                     errorCode=U_ZERO_ERROR;
 845                     punycode.releaseBuffer(4);
 846                     buffer=punycode.getBuffer(4+punycodeLength);
 847                     if(buffer==NULL) {
 848                         errorCode=U_MEMORY_ALLOCATION_ERROR;
 849                         return destLabelLength;
 850                     }
 851                     punycodeLength=u_strToPunycode(label, labelLength,
 852                                                   buffer+4, punycode.getCapacity()-4,
 853                                                   NULL, &errorCode);
 854                 }
 855                 punycodeLength+=4;
 856                 punycode.releaseBuffer(punycodeLength);
 857                 if(U_FAILURE(errorCode)) {
 858                     return destLabelLength;
 859                 }
 860                 if(punycodeLength>63) {
 861                     info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
 862                 }
 863                 return replaceLabel(dest, destLabelStart, destLabelLength,
 864                                     punycode, punycodeLength);
 865             } else {
 866                 // all-ASCII label
 867                 if(labelLength>63) {
 868                     info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
 869                 }
 870             }
 871         }
 872     } else {
 873         // If a Punycode label has severe errors,
 874         // then leave it but make sure it does not look valid.
 875         if(wasPunycode) {
 876             info.labelErrors|=UIDNA_ERROR_INVALID_ACE_LABEL;
 877             return markBadACELabel(dest, destLabelStart, destLabelLength, toASCII, info);
 878         }
 879     }
 880     return replaceLabel(dest, destLabelStart, destLabelLength, *labelString, labelLength);
 881 }
 882
 883 // Make sure an ACE label does not look valid.
 884 // Append U+FFFD if the label has only LDH characters.
 885 // If UIDNA_USE_STD3_RULES, also replace disallowed ASCII characters with U+FFFD.
 886 int32_t
 887 UTS46::markBadACELabel(UnicodeString &dest,
 888                        int32_t labelStart, int32_t labelLength,
 889                        UBool toASCII, IDNAInfo &info) const {
 890     UBool disallowNonLDHDot=(options&UIDNA_USE_STD3_RULES)!=0;
 891     UBool isASCII=TRUE;
 892     UBool onlyLDH=TRUE;
 893     const UChar *label=dest.getBuffer()+labelStart;
 894     // Ok to cast away const because we own the UnicodeString.
 895     UChar *s=(UChar *)label+4;  // After the initial "xn--".
 896     const UChar *limit=label+labelLength;
 897     do {
 898         UChar c=*s;
 899         if(c<=0x7f) {
 900             if(c==0x2e) {
 901                 info.labelErrors|=UIDNA_ERROR_LABEL_HAS_DOT;
 902                 *s=0xfffd;
 903                 isASCII=onlyLDH=FALSE;
 904             } else if(asciiData[c]<0) {
 905                 onlyLDH=FALSE;
 906                 if(disallowNonLDHDot) {
 907                     *s=0xfffd;
 908                     isASCII=FALSE;
 909                 }
 910             }
 911         } else {
 912             isASCII=onlyLDH=FALSE;
 913         }
 914     } while(++s<limit);
 915     if(onlyLDH) {
 916         dest.insert(labelStart+labelLength, (UChar)0xfffd);
 917         ++labelLength;
 918     } else {
 919         if(toASCII && isASCII && labelLength>63) {
 920             info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
 921         }
 922     }
 923     return labelLength;
 924 }
 925
 926 const uint32_t L_MASK=U_MASK(U_LEFT_TO_RIGHT);
 927 const uint32_t R_AL_MASK=U_MASK(U_RIGHT_TO_LEFT)|U_MASK(U_RIGHT_TO_LEFT_ARABIC);
 928 const uint32_t L_R_AL_MASK=L_MASK|R_AL_MASK;
 929
 930 const uint32_t R_AL_AN_MASK=R_AL_MASK|U_MASK(U_ARABIC_NUMBER);
 931
 932 const uint32_t EN_AN_MASK=U_MASK(U_EUROPEAN_NUMBER)|U_MASK(U_ARABIC_NUMBER);
 933 const uint32_t R_AL_EN_AN_MASK=R_AL_MASK|EN_AN_MASK;
 934 const uint32_t L_EN_MASK=L_MASK|U_MASK(U_EUROPEAN_NUMBER);
 935
 936 const uint32_t ES_CS_ET_ON_BN_NSM_MASK=
 937     U_MASK(U_EUROPEAN_NUMBER_SEPARATOR)|
 938     U_MASK(U_COMMON_NUMBER_SEPARATOR)|
 939     U_MASK(U_EUROPEAN_NUMBER_TERMINATOR)|
 940     U_MASK(U_OTHER_NEUTRAL)|
 941     U_MASK(U_BOUNDARY_NEUTRAL)|
 942     U_MASK(U_DIR_NON_SPACING_MARK);
 943 const uint32_t L_EN_ES_CS_ET_ON_BN_NSM_MASK=L_EN_MASK|ES_CS_ET_ON_BN_NSM_MASK;
 944 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;
 945
 946 // We scan the whole label and check both for whether it contains RTL characters
 947 // and whether it passes the BiDi Rule.
 948 // In a BiDi domain name, all labels must pass the BiDi Rule, but we might find
 949 // that a domain name is a BiDi domain name (has an RTL label) only after
 950 // processing several earlier labels.
 951 void
 952 UTS46::checkLabelBiDi(const UChar *label, int32_t labelLength, IDNAInfo &info) const {
 953     // IDNA2008 BiDi rule
 954     // Get the directionality of the first character.
 955     UChar32 c;
 956     int32_t i=0;
 957     U16_NEXT_UNSAFE(label, i, c);
 958     uint32_t firstMask=U_MASK(u_charDirection(c));
 959     // 1. The first character must be a character with BIDI property L, R
 960     // or AL.  If it has the R or AL property, it is an RTL label; if it
 961     // has the L property, it is an LTR label.
 962     if((firstMask&~L_R_AL_MASK)!=0) {
 963         info.isOkBiDi=FALSE;
 964     }
 965     // Get the directionality of the last non-NSM character.
 966     uint32_t lastMask;
 967     for(;;) {
 968         if(i>=labelLength) {
 969             lastMask=firstMask;
 970             break;
 971         }
 972         U16_PREV_UNSAFE(label, labelLength, c);
 973         UCharDirection dir=u_charDirection(c);
 974         if(dir!=U_DIR_NON_SPACING_MARK) {
 975             lastMask=U_MASK(dir);
 976             break;
 977         }
 978     }
 979     // 3. In an RTL label, the end of the label must be a character with
 980     // BIDI property R, AL, EN or AN, followed by zero or more
 981     // characters with BIDI property NSM.
 982     // 6. In an LTR label, the end of the label must be a character with
 983     // BIDI property L or EN, followed by zero or more characters with
 984     // BIDI property NSM.
 985     if( (firstMask&L_MASK)!=0 ?
 986             (lastMask&~L_EN_MASK)!=0 :
 987             (lastMask&~R_AL_EN_AN_MASK)!=0
 988     ) {
 989         info.isOkBiDi=FALSE;
 990     }
 991     // Get the directionalities of the intervening characters.
 992     uint32_t mask=0;
 993     while(i<labelLength) {
 994         U16_NEXT_UNSAFE(label, i, c);
 995         mask|=U_MASK(u_charDirection(c));
 996     }
 997     if(firstMask&L_MASK) {
 998         // 5. In an LTR label, only characters with the BIDI properties L, EN,
 999         // ES, CS, ET, ON, BN and NSM are allowed.
1000         if((mask&~L_EN_ES_CS_ET_ON_BN_NSM_MASK)!=0) {
1001             info.isOkBiDi=FALSE;
1002         }
1003     } else {
1004         // 2. In an RTL label, only characters with the BIDI properties R, AL,
1005         // AN, EN, ES, CS, ET, ON, BN and NSM are allowed.
1006         if((mask&~R_AL_AN_EN_ES_CS_ET_ON_BN_NSM_MASK)!=0) {
1007             info.isOkBiDi=FALSE;
1008         }
1009         // 4. In an RTL label, if an EN is present, no AN may be present, and
1010         // vice versa.
1011         if((mask&EN_AN_MASK)==EN_AN_MASK) {
1012             info.isOkBiDi=FALSE;
1013         }
1014     }
1015     // An RTL label is a label that contains at least one character of type
1016     // R, AL or AN. [...]
1017     // A "BIDI domain name" is a domain name that contains at least one RTL
1018     // label. [...]
1019     // The following rule, consisting of six conditions, applies to labels
1020     // in BIDI domain names.
1021     if(((firstMask|mask|lastMask)&R_AL_AN_MASK)!=0) {
1022         info.isBiDi=TRUE;
1023     }
1024 }
1025
1026 // Special code for the ASCII prefix of a BiDi domain name.
1027 // The ASCII prefix is all-LTR.
1028
1029 // IDNA2008 BiDi rule, parts relevant to ASCII labels:
1030 // 1. The first character must be a character with BIDI property L [...]
1031 // 5. In an LTR label, only characters with the BIDI properties L, EN,
1032 // ES, CS, ET, ON, BN and NSM are allowed.
1033 // 6. In an LTR label, the end of the label must be a character with
1034 // BIDI property L or EN [...]
1035
1036 // UTF-16 version, called for mapped ASCII prefix.
1037 // Cannot contain uppercase A-Z.
1038 // s[length-1] must be the trailing dot.
1039 static UBool
1040 isASCIIOkBiDi(const UChar *s, int32_t length) {
1041     int32_t labelStart=0;
1042     for(int32_t i=0; i<length; ++i) {
1043         UChar c=s[i];
1044         if(c==0x2e) {  // dot
1045             if(i>labelStart) {
1046                 c=s[i-1];
1047                 if(!(0x61<=c && c<=0x7a) && !(0x30<=c && c<=0x39)) {
1048                     // Last character in the label is not an L or EN.
1049                     return FALSE;
1050                 }
1051             }
1052             labelStart=i+1;
1053         } else if(i==labelStart) {
1054             if(!(0x61<=c && c<=0x7a)) {
1055                 // First character in the label is not an L.
1056                 return FALSE;
1057             }
1058         } else {
1059             if(c<=0x20 && (c>=0x1c || (9<=c && c<=0xd))) {
1060                 // Intermediate character in the label is a B, S or WS.
1061                 return FALSE;
1062             }
1063         }
1064     }
1065     return TRUE;
1066 }
1067
1068 // UTF-8 version, called for source ASCII prefix.
1069 // Can contain uppercase A-Z.
1070 // s[length-1] must be the trailing dot.
1071 static UBool
1072 isASCIIOkBiDi(const char *s, int32_t length) {
1073     int32_t labelStart=0;
1074     for(int32_t i=0; i<length; ++i) {
1075         char c=s[i];
1076         if(c==0x2e) {  // dot
1077             if(i>labelStart) {
1078                 c=s[i-1];
1079                 if(!(0x61<=c && c<=0x7a) && !(0x41<=c && c<=0x5a) && !(0x30<=c && c<=0x39)) {
1080                     // Last character in the label is not an L or EN.
1081                     return FALSE;
1082                 }
1083             }
1084             labelStart=i+1;
1085         } else if(i==labelStart) {
1086             if(!(0x61<=c && c<=0x7a) && !(0x41<=c && c<=0x5a)) {
1087                 // First character in the label is not an L.
1088                 return FALSE;
1089             }
1090         } else {
1091             if(c<=0x20 && (c>=0x1c || (9<=c && c<=0xd))) {
1092                 // Intermediate character in the label is a B, S or WS.
1093                 return FALSE;
1094             }
1095         }
1096     }
1097     return TRUE;
1098 }
1099
1100 UBool
1101 UTS46::isLabelOkContextJ(const UChar *label, int32_t labelLength) const {
1102     const UBiDiProps *bdp=ubidi_getSingleton();
1103     // [IDNA2008-Tables]
1104     // 200C..200D  ; CONTEXTJ    # ZERO WIDTH NON-JOINER..ZERO WIDTH JOINER
1105     for(int32_t i=0; i<labelLength; ++i) {
1106         if(label[i]==0x200c) {
1107             // Appendix A.1. ZERO WIDTH NON-JOINER
1108             // Rule Set:
1109             //  False;
1110             //  If Canonical_Combining_Class(Before(cp)) .eq.  Virama Then True;
1111             //  If RegExpMatch((Joining_Type:{L,D})(Joining_Type:T)*\u200C
1112             //     (Joining_Type:T)*(Joining_Type:{R,D})) Then True;
1113             if(i==0) {
1114                 return FALSE;
1115             }
1116             UChar32 c;
1117             int32_t j=i;
1118             U16_PREV_UNSAFE(label, j, c);
1119             if(uts46Norm2.getCombiningClass(c)==9) {
1120                 continue;
1121             }
1122             // check precontext (Joining_Type:{L,D})(Joining_Type:T)*
1123             for(;;) {
1124                 UJoiningType type=ubidi_getJoiningType(bdp, c);
1125                 if(type==U_JT_TRANSPARENT) {
1126                     if(j==0) {
1127                         return FALSE;
1128                     }
1129                     U16_PREV_UNSAFE(label, j, c);
1130                 } else if(type==U_JT_LEFT_JOINING || type==U_JT_DUAL_JOINING) {
1131                     break;  // precontext fulfilled
1132                 } else {
1133                     return FALSE;
1134                 }
1135             }
1136             // check postcontext (Joining_Type:T)*(Joining_Type:{R,D})
1137             for(j=i+1;;) {
1138                 if(j==labelLength) {
1139                     return FALSE;
1140                 }
1141                 U16_NEXT_UNSAFE(label, j, c);
1142                 UJoiningType type=ubidi_getJoiningType(bdp, c);
1143                 if(type==U_JT_TRANSPARENT) {
1144                     // just skip this character
1145                 } else if(type==U_JT_RIGHT_JOINING || type==U_JT_DUAL_JOINING) {
1146                     break;  // postcontext fulfilled
1147                 } else {
1148                     return FALSE;
1149                 }
1150             }
1151         } else if(label[i]==0x200d) {
1152             // Appendix A.2. ZERO WIDTH JOINER (U+200D)
1153             // Rule Set:
1154             //  False;
1155             //  If Canonical_Combining_Class(Before(cp)) .eq.  Virama Then True;
1156             if(i==0) {
1157                 return FALSE;
1158             }
1159             UChar32 c;
1160             int32_t j=i;
1161             U16_PREV_UNSAFE(label, j, c);
1162             if(uts46Norm2.getCombiningClass(c)!=9) {
1163                 return FALSE;
1164             }
1165         }
1166     }
1167     return TRUE;
1168 }
1169
1170 void
1171 UTS46::checkLabelContextO(const UChar *label, int32_t labelLength, IDNAInfo &info) const {
1172     int32_t labelEnd=labelLength-1;  // inclusive
1173     int32_t arabicDigits=0;  // -1 for 066x, +1 for 06Fx
1174     for(int32_t i=0; i<=labelEnd; ++i) {
1175         UChar32 c=label[i];
1176         if(c<0xb7) {
1177             // ASCII fastpath
1178         } else if(c<=0x6f9) {
1179             if(c==0xb7) {
1180                 // Appendix A.3. MIDDLE DOT (U+00B7)
1181                 // Rule Set:
1182                 //  False;
1183                 //  If Before(cp) .eq.  U+006C And
1184                 //     After(cp) .eq.  U+006C Then True;
1185                 if(!(0<i && label[i-1]==0x6c &&
1186                      i<labelEnd && label[i+1]==0x6c)) {
1187                     info.labelErrors|=UIDNA_ERROR_CONTEXTO_PUNCTUATION;
1188                 }
1189             } else if(c==0x375) {
1190                 // Appendix A.4. GREEK LOWER NUMERAL SIGN (KERAIA) (U+0375)
1191                 // Rule Set:
1192                 //  False;
1193                 //  If Script(After(cp)) .eq.  Greek Then True;
1194                 UScriptCode script=USCRIPT_INVALID_CODE;
1195                 if(i<labelEnd) {
1196                     UErrorCode errorCode=U_ZERO_ERROR;
1197                     int32_t j=i+1;
1198                     U16_NEXT(label, j, labelLength, c);
1199                     script=uscript_getScript(c, &errorCode);
1200                 }
1201                 if(script!=USCRIPT_GREEK) {
1202                     info.labelErrors|=UIDNA_ERROR_CONTEXTO_PUNCTUATION;
1203                 }
1204             } else if(c==0x5f3 || c==0x5f4) {
1205                 // Appendix A.5. HEBREW PUNCTUATION GERESH (U+05F3)
1206                 // Rule Set:
1207                 //  False;
1208                 //  If Script(Before(cp)) .eq.  Hebrew Then True;
1209                 //
1210                 // Appendix A.6. HEBREW PUNCTUATION GERSHAYIM (U+05F4)
1211                 // Rule Set:
1212                 //  False;
1213                 //  If Script(Before(cp)) .eq.  Hebrew Then True;
1214                 UScriptCode script=USCRIPT_INVALID_CODE;
1215                 if(0<i) {
1216                     UErrorCode errorCode=U_ZERO_ERROR;
1217                     int32_t j=i;
1218                     U16_PREV(label, 0, j, c);
1219                     script=uscript_getScript(c, &errorCode);
1220                 }
1221                 if(script!=USCRIPT_HEBREW) {
1222                     info.labelErrors|=UIDNA_ERROR_CONTEXTO_PUNCTUATION;
1223                 }
1224             } else if(0x660<=c /* && c<=0x6f9 */) {
1225                 // Appendix A.8. ARABIC-INDIC DIGITS (0660..0669)
1226                 // Rule Set:
1227                 //  True;
1228                 //  For All Characters:
1229                 //    If cp .in. 06F0..06F9 Then False;
1230                 //  End For;
1231                 //
1232                 // Appendix A.9. EXTENDED ARABIC-INDIC DIGITS (06F0..06F9)
1233                 // Rule Set:
1234                 //  True;
1235                 //  For All Characters:
1236                 //    If cp .in. 0660..0669 Then False;
1237                 //  End For;
1238                 if(c<=0x669) {
1239                     if(arabicDigits>0) {
1240                         info.labelErrors|=UIDNA_ERROR_CONTEXTO_DIGITS;
1241                     }
1242                     arabicDigits=-1;
1243                 } else if(0x6f0<=c) {
1244                     if(arabicDigits<0) {
1245                         info.labelErrors|=UIDNA_ERROR_CONTEXTO_DIGITS;
1246                     }
1247                     arabicDigits=1;
1248                 }
1249             }
1250         } else if(c==0x30fb) {
1251             // Appendix A.7. KATAKANA MIDDLE DOT (U+30FB)
1252             // Rule Set:
1253             //  False;
1254             //  For All Characters:
1255             //    If Script(cp) .in. {Hiragana, Katakana, Han} Then True;
1256             //  End For;
1257             UErrorCode errorCode=U_ZERO_ERROR;
1258             for(int j=0;;) {
1259                 if(j>labelEnd) {
1260                     info.labelErrors|=UIDNA_ERROR_CONTEXTO_PUNCTUATION;
1261                     break;
1262                 }
1263                 U16_NEXT(label, j, labelLength, c);
1264                 UScriptCode script=uscript_getScript(c, &errorCode);
1265                 if(script==USCRIPT_HIRAGANA || script==USCRIPT_KATAKANA || script==USCRIPT_HAN) {
1266                     break;
1267                 }
1268             }
1269         }
1270     }
1271 }
1272
1273 U_NAMESPACE_END
1274
1275 // C API ------------------------------------------------------------------- ***
1276
1277 U_NAMESPACE_USE
1278
1279 U_CAPI UIDNA * U_EXPORT2
1280 uidna_openUTS46(uint32_t options, UErrorCode *pErrorCode) {
1281     return reinterpret_cast<UIDNA *>(IDNA::createUTS46Instance(options, *pErrorCode));
1282 }
1283
1284 U_CAPI void U_EXPORT2
1285 uidna_close(UIDNA *idna) {
1286     delete reinterpret_cast<IDNA *>(idna);
1287 }
1288
1289 static UBool
1290 checkArgs(const void *label, int32_t length,
1291           void *dest, int32_t capacity,
1292           UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
1293     if(U_FAILURE(*pErrorCode)) {
1294         return FALSE;
1295     }
1296     // sizeof(UIDNAInfo)=16 in the first API version.
1297     if(pInfo==NULL || pInfo->size<16) {
1298         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
1299         return FALSE;
1300     }
1301     if( (label==NULL ? length!=0 : length<-1) ||
1302         (dest==NULL ? capacity!=0 : capacity<0) ||
1303         (dest==label && label!=NULL)
1304     ) {
1305         *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
1306         return FALSE;
1307     }
1308     // Set all *pInfo bytes to 0 except for the size field itself.
1309     uprv_memset(&pInfo->size+1, 0, pInfo->size-sizeof(pInfo->size));
1310     return TRUE;
1311 }
1312
1313 static void
1314 idnaInfoToStruct(IDNAInfo &info, UIDNAInfo *pInfo) {
1315     pInfo->isTransitionalDifferent=info.isTransitionalDifferent();
1316     pInfo->errors=info.getErrors();
1317 }
1318
1319 U_CAPI int32_t U_EXPORT2
1320 uidna_labelToASCII(const UIDNA *idna,
1321                    const UChar *label, int32_t length,
1322                    UChar *dest, int32_t capacity,
1323                    UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
1324     if(!checkArgs(label, length, dest, capacity, pInfo, pErrorCode)) {
1325         return 0;
1326     }
1327     UnicodeString src((UBool)(length<0), label, length);
1328     UnicodeString destString(dest, 0, capacity);
1329     IDNAInfo info;
1330     reinterpret_cast<const IDNA *>(idna)->labelToASCII(src, destString, info, *pErrorCode);
1331     idnaInfoToStruct(info, pInfo);
1332     return destString.extract(dest, capacity, *pErrorCode);
1333 }
1334
1335 U_CAPI int32_t U_EXPORT2
1336 uidna_labelToUnicode(const UIDNA *idna,
1337                      const UChar *label, int32_t length,
1338                      UChar *dest, int32_t capacity,
1339                      UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
1340     if(!checkArgs(label, length, dest, capacity, pInfo, pErrorCode)) {
1341         return 0;
1342     }
1343     UnicodeString src((UBool)(length<0), label, length);
1344     UnicodeString destString(dest, 0, capacity);
1345     IDNAInfo info;
1346     reinterpret_cast<const IDNA *>(idna)->labelToUnicode(src, destString, info, *pErrorCode);
1347     idnaInfoToStruct(info, pInfo);
1348     return destString.extract(dest, capacity, *pErrorCode);
1349 }
1350
1351 U_CAPI int32_t U_EXPORT2
1352 uidna_nameToASCII(const UIDNA *idna,
1353                   const UChar *name, int32_t length,
1354                   UChar *dest, int32_t capacity,
1355                   UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
1356     if(!checkArgs(name, length, dest, capacity, pInfo, pErrorCode)) {
1357         return 0;
1358     }
1359     UnicodeString src((UBool)(length<0), name, length);
1360     UnicodeString destString(dest, 0, capacity);
1361     IDNAInfo info;
1362     reinterpret_cast<const IDNA *>(idna)->nameToASCII(src, destString, info, *pErrorCode);
1363     idnaInfoToStruct(info, pInfo);
1364     return destString.extract(dest, capacity, *pErrorCode);
1365 }
1366
1367 U_CAPI int32_t U_EXPORT2
1368 uidna_nameToUnicode(const UIDNA *idna,
1369                     const UChar *name, int32_t length,
1370                     UChar *dest, int32_t capacity,
1371                     UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
1372     if(!checkArgs(name, length, dest, capacity, pInfo, pErrorCode)) {
1373         return 0;
1374     }
1375     UnicodeString src((UBool)(length<0), name, length);
1376     UnicodeString destString(dest, 0, capacity);
1377     IDNAInfo info;
1378     reinterpret_cast<const IDNA *>(idna)->nameToUnicode(src, destString, info, *pErrorCode);
1379     idnaInfoToStruct(info, pInfo);
1380     return destString.extract(dest, capacity, *pErrorCode);
1381 }
1382
1383 U_CAPI int32_t U_EXPORT2
1384 uidna_labelToASCII_UTF8(const UIDNA *idna,
1385                         const char *label, int32_t length,
1386                         char *dest, int32_t capacity,
1387                         UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
1388     if(!checkArgs(label, length, dest, capacity, pInfo, pErrorCode)) {
1389         return 0;
1390     }
1391     StringPiece src(label, length<0 ? uprv_strlen(label) : length);
1392     CheckedArrayByteSink sink(dest, capacity);
1393     IDNAInfo info;
1394     reinterpret_cast<const IDNA *>(idna)->labelToASCII_UTF8(src, sink, info, *pErrorCode);
1395     idnaInfoToStruct(info, pInfo);
1396     return u_terminateChars(dest, capacity, sink.NumberOfBytesAppended(), pErrorCode);
1397 }
1398
1399 U_CAPI int32_t U_EXPORT2
1400 uidna_labelToUnicodeUTF8(const UIDNA *idna,
1401                          const char *label, int32_t length,
1402                          char *dest, int32_t capacity,
1403                          UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
1404     if(!checkArgs(label, length, dest, capacity, pInfo, pErrorCode)) {
1405         return 0;
1406     }
1407     StringPiece src(label, length<0 ? uprv_strlen(label) : length);
1408     CheckedArrayByteSink sink(dest, capacity);
1409     IDNAInfo info;
1410     reinterpret_cast<const IDNA *>(idna)->labelToUnicodeUTF8(src, sink, info, *pErrorCode);
1411     idnaInfoToStruct(info, pInfo);
1412     return u_terminateChars(dest, capacity, sink.NumberOfBytesAppended(), pErrorCode);
1413 }
1414
1415 U_CAPI int32_t U_EXPORT2
1416 uidna_nameToASCII_UTF8(const UIDNA *idna,
1417                        const char *name, int32_t length,
1418                        char *dest, int32_t capacity,
1419                        UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
1420     if(!checkArgs(name, length, dest, capacity, pInfo, pErrorCode)) {
1421         return 0;
1422     }
1423     StringPiece src(name, length<0 ? uprv_strlen(name) : length);
1424     CheckedArrayByteSink sink(dest, capacity);
1425     IDNAInfo info;
1426     reinterpret_cast<const IDNA *>(idna)->nameToASCII_UTF8(src, sink, info, *pErrorCode);
1427     idnaInfoToStruct(info, pInfo);
1428     return u_terminateChars(dest, capacity, sink.NumberOfBytesAppended(), pErrorCode);
1429 }
1430
1431 U_CAPI int32_t U_EXPORT2
1432 uidna_nameToUnicodeUTF8(const UIDNA *idna,
1433                         const char *name, int32_t length,
1434                         char *dest, int32_t capacity,
1435                         UIDNAInfo *pInfo, UErrorCode *pErrorCode) {
1436     if(!checkArgs(name, length, dest, capacity, pInfo, pErrorCode)) {
1437         return 0;
1438     }
1439     StringPiece src(name, length<0 ? uprv_strlen(name) : length);
1440     CheckedArrayByteSink sink(dest, capacity);
1441     IDNAInfo info;
1442     reinterpret_cast<const IDNA *>(idna)->nameToUnicodeUTF8(src, sink, info, *pErrorCode);
1443     idnaInfoToStruct(info, pInfo);
1444     return u_terminateChars(dest, capacity, sink.NumberOfBytesAppended(), pErrorCode);
1445 }
1446
1447 #endif  // UCONFIG_NO_IDNA