ICU 56 update step 1

source/common/uts46.cpp

 /*
 *******************************************************************************
-*   Copyright (C) 2010-2014, International Business Machines
+*   Copyright (C) 2010-2015, 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
 */
@@ skipping 159 matching lines @@
 
     // 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;
+                    UBool toASCII, IDNAInfo &info, UErrorCode &errorCode) 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;
 
@@ skipping 386 matching lines @@
         processLabel(dest, labelStart, labelLimit-labelStart,
                       toASCII, info, errorCode);
         info.errors|=info.labelErrors;
     }
     return dest;
 }
 
 int32_t
 UTS46::mapDevChars(UnicodeString &dest, int32_t labelStart, int32_t mappingStart,
                    UErrorCode &errorCode) const {
+    if(U_FAILURE(errorCode)) {
+        return 0;
+    }
     int32_t length=dest.length();
     UChar *s=dest.getBuffer(dest[mappingStart]==0xdf ? length+1 : length);
     if(s==NULL) {
         errorCode=U_MEMORY_ALLOCATION_ERROR;
         return length;
     }
     int32_t capacity=dest.getCapacity();
     UBool didMapDevChars=FALSE;
     int32_t readIndex=mappingStart, writeIndex=mappingStart;
     do {
@@ skipping 37 matching lines @@
     } while(writeIndex<length);
     dest.releaseBuffer(length);
     if(didMapDevChars) {
         // Mapping deviation characters might have resulted in an un-NFC string.
         // We could use either the NFC or the UTS #46 normalizer.
         // By using the UTS #46 normalizer again, we avoid having to load a second .nrm data file.
         UnicodeString normalized;
         uts46Norm2.normalize(dest.tempSubString(labelStart), normalized, errorCode);
         if(U_SUCCESS(errorCode)) {
             dest.replace(labelStart, 0x7fffffff, normalized);
+            if(dest.isBogus()) {
+                errorCode=U_MEMORY_ALLOCATION_ERROR;
+            }
             return dest.length();
         }
     }
     return length;
 }
 
 // Some non-ASCII characters are equivalent to sequences with
 // non-LDH ASCII characters. To find them:
 // grep disallowed_STD3_valid IdnaMappingTable.txt (or uts46.txt)
 static inline UBool
 isNonASCIIDisallowedSTD3Valid(UChar32 c) {
     return c==0x2260 || c==0x226E || c==0x226F;
 }
 
 // Replace the label in dest with the label string, if the label was modified.
 // If &label==&dest then the label was modified in-place and labelLength
 // is the new label length, different from label.length().
 // If &label!=&dest then labelLength==label.length().
 // Returns labelLength (= the new label length).
 static int32_t
 replaceLabel(UnicodeString &dest, int32_t destLabelStart, int32_t destLabelLength,
-             const UnicodeString &label, int32_t labelLength) {
+             const UnicodeString &label, int32_t labelLength, UErrorCode &errorCode) {
+    if(U_FAILURE(errorCode)) {
+        return 0;
+    }
     if(&label!=&dest) {
         dest.replace(destLabelStart, destLabelLength, label);
+        if(dest.isBogus()) {
+            errorCode=U_MEMORY_ALLOCATION_ERROR;
+            return 0;
+        }
     }
     return labelLength;
 }
 
 int32_t
 UTS46::processLabel(UnicodeString &dest,
                     int32_t labelStart, int32_t labelLength,
                     UBool toASCII,
                     IDNAInfo &info, UErrorCode &errorCode) const {
+    if(U_FAILURE(errorCode)) {
+        return 0;
+    }
     UnicodeString fromPunycode;
     UnicodeString *labelString;
     const UChar *label=dest.getBuffer()+labelStart;
     int32_t destLabelStart=labelStart;
     int32_t destLabelLength=labelLength;
     UBool wasPunycode;
     if(labelLength>=4 && label[0]==0x78 && label[1]==0x6e && label[2]==0x2d && label[3]==0x2d) {
         // Label starts with "xn--", try to un-Punycode it.
         wasPunycode=TRUE;
         UChar *unicodeBuffer=fromPunycode.getBuffer(-1);  // capacity==-1: most labels should fit
@@ skipping 14 matching lines @@
                 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);
+            return markBadACELabel(dest, labelStart, labelLength, toASCII, info, errorCode);
         }
         // Check for NFC, and for characters that are not
         // valid or deviation characters according to the normalizer.
         // If there is something wrong, then the string will change.
         // Note that the normalizer passes through non-LDH ASCII and deviation characters.
         // Deviation characters are ok in Punycode even in transitional processing.
         // In the code further below, if we find non-LDH ASCII and we have UIDNA_USE_STD3_RULES
         // then we will set UIDNA_ERROR_INVALID_ACE_LABEL there too.
         UBool isValid=uts46Norm2.isNormalized(fromPunycode, errorCode);
         if(U_FAILURE(errorCode)) {
             return labelLength;
         }
         if(!isValid) {
             info.labelErrors|=UIDNA_ERROR_INVALID_ACE_LABEL;
-            return markBadACELabel(dest, labelStart, labelLength, toASCII, info);
+            return markBadACELabel(dest, labelStart, labelLength, toASCII, info, errorCode);
         }
         labelString=&fromPunycode;
         label=fromPunycode.getBuffer();
         labelStart=0;
         labelLength=fromPunycode.length();
     } else {
         wasPunycode=FALSE;
         labelString=&dest;
     }
     // Validity check
     if(labelLength==0) {
         info.labelErrors|=UIDNA_ERROR_EMPTY_LABEL;
-        return replaceLabel(dest, destLabelStart, destLabelLength, *labelString, labelLength);
+        return replaceLabel(dest, destLabelStart, destLabelLength,
+                            *labelString, labelLength, errorCode);
     }
     // labelLength>0
     if(labelLength>=4 && label[2]==0x2d && label[3]==0x2d) {
         // label starts with "??--"
         info.labelErrors|=UIDNA_ERROR_HYPHEN_3_4;
     }
     if(label[0]==0x2d) {
         // label starts with "-"
         info.labelErrors|=UIDNA_ERROR_LEADING_HYPHEN;
     }
@@ skipping 101 matching lines @@
                 }
                 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);
+                                    punycode, punycodeLength, errorCode);
             } else {
                 // all-ASCII label
                 if(labelLength>63) {
                     info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
                 }
             }
         }
     } else {
         // If a Punycode label has severe errors,
         // then leave it but make sure it does not look valid.
         if(wasPunycode) {
             info.labelErrors|=UIDNA_ERROR_INVALID_ACE_LABEL;
-            return markBadACELabel(dest, destLabelStart, destLabelLength, toASCII, info);
+            return markBadACELabel(dest, destLabelStart, destLabelLength, toASCII, info, errorCode);
         }
     }
-    return replaceLabel(dest, destLabelStart, destLabelLength, *labelString, labelLength);
+    return replaceLabel(dest, destLabelStart, destLabelLength,
+                        *labelString, labelLength, errorCode);
 }
 
 // Make sure an ACE label does not look valid.
 // Append U+FFFD if the label has only LDH characters.
 // If UIDNA_USE_STD3_RULES, also replace disallowed ASCII characters with U+FFFD.
 int32_t
 UTS46::markBadACELabel(UnicodeString &dest,
                        int32_t labelStart, int32_t labelLength,
-                       UBool toASCII, IDNAInfo &info) const {
+                       UBool toASCII, IDNAInfo &info, UErrorCode &errorCode) const {
+    if(U_FAILURE(errorCode)) {
+        return 0;
+    }
     UBool disallowNonLDHDot=(options&UIDNA_USE_STD3_RULES)!=0;
     UBool isASCII=TRUE;
     UBool onlyLDH=TRUE;
     const 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(++s<limit);
     if(onlyLDH) {
         dest.insert(labelStart+labelLength, (UChar)0xfffd);
+        if(dest.isBogus()) {
+            errorCode=U_MEMORY_ALLOCATION_ERROR;
+            return 0;
+        }
         ++labelLength;
     } else {
         if(toASCII && isASCII && labelLength>63) {
             info.labelErrors|=UIDNA_ERROR_LABEL_TOO_LONG;
         }
     }
     return labelLength;
 }
 
 const uint32_t L_MASK=U_MASK(U_LEFT_TO_RIGHT);
@@ skipping 511 matching lines @@
     }
     StringPiece src(name, length<0 ? uprv_strlen(name) : length);
     CheckedArrayByteSink sink(dest, capacity);
     IDNAInfo info;
     reinterpret_cast<const IDNA *>(idna)->nameToUnicodeUTF8(src, sink, info, *pErrorCode);
     idnaInfoToStruct(info, pInfo);
     return u_terminateChars(dest, capacity, sink.NumberOfBytesAppended(), pErrorCode);
 }
 
 #endif  // UCONFIG_NO_IDNA