CFOldStylePList.c

   1 /*
   2  * Copyright (c) 2014 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 /*      CFOldStylePList.c
  25         Copyright (c) 1999-2014, Apple Inc. All rights reserved.
  26         Responsibility: Tony Parker
  27 */
  28
  29 #include <CoreFoundation/CFPropertyList.h>
  30 #include <CoreFoundation/CFDate.h>
  31 #include <CoreFoundation/CFNumber.h>
  32 #include <CoreFoundation/CFError.h>
  33 #include <CoreFoundation/CFStringEncodingConverter.h>
  34 #include "CFInternal.h"
  35 #include <CoreFoundation/CFCalendar.h>
  36 #include <CoreFoundation/CFSet.h>
  37
  38 #include <ctype.h>
  39
  40 //
  41 // Old NeXT-style property lists
  42 //
  43
  44 CF_INLINE void __CFPListRelease(CFTypeRef cf, CFAllocatorRef allocator) {
  45     if (cf && !(0)) CFRelease(cf);
  46 }
  47
  48 CF_PRIVATE CFErrorRef __CFPropertyListCreateError(CFIndex code, CFStringRef debugString, ...);
  49
  50 typedef struct {
  51     const UniChar *begin;
  52     const UniChar *curr;
  53     const UniChar *end;
  54     CFErrorRef error;
  55     CFAllocatorRef allocator;
  56     UInt32 mutabilityOption;
  57     CFMutableSetRef stringSet;  // set of all strings involved in this parse; allows us to share non-mutable strings in the returned plist
  58 } _CFStringsFileParseInfo;
  59
  60 // warning: doesn't have a good idea of Unicode line separators
  61 static UInt32 lineNumberStrings(_CFStringsFileParseInfo *pInfo) {
  62     const UniChar *p = pInfo->begin;
  63     UInt32 count = 1;
  64     while (p < pInfo->curr) {
  65         if (*p == '\r') {
  66             count ++;
  67             if (*(p + 1) == '\n')
  68                 p ++;
  69         } else if (*p == '\n') {
  70             count ++;
  71         }
  72         p ++;
  73     }
  74     return count;
  75 }
  76
  77 static CFTypeRef parsePlistObject(_CFStringsFileParseInfo *pInfo, bool requireObject);
  78
  79 #define isValidUnquotedStringCharacter(x) (((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') || ((x) >= '0' && (x) <= '9') || (x) == '_' || (x) == '$' || (x) == '/' || (x) == ':' || (x) == '.' || (x) == '-')
  80
  81 // Returns true if the advance found something before the end of the buffer, false otherwise
  82 static Boolean advanceToNonSpace(_CFStringsFileParseInfo *pInfo) {
  83     UniChar ch2;
  84     while (pInfo->curr < pInfo->end) {
  85         ch2 = *(pInfo->curr);
  86         pInfo->curr ++;
  87         if (ch2 >= 9 && ch2 <= 0x0d) continue;  // tab, newline, vt, form feed, carriage return
  88         if (ch2 == ' ' || ch2 == 0x2028 || ch2 == 0x2029) continue;     // space and Unicode line sep, para sep
  89         if (ch2 == '/') {
  90             if (pInfo->curr >= pInfo->end) {
  91                 // whoops; back up and return
  92                 pInfo->curr --;
  93                 return true;
  94             } else if (*(pInfo->curr) == '/') {
  95                 pInfo->curr ++;
  96                 while (pInfo->curr < pInfo->end) {      // go to end of comment line
  97                     UniChar ch3 = *(pInfo->curr);
  98                     if (ch3 == '\n' || ch3 == '\r' || ch3 == 0x2028 || ch3 == 0x2029) break;
  99                     pInfo->curr ++;
 100                 }
 101             } else if (*(pInfo->curr) == '*') {         // handle /* ... */
 102                 pInfo->curr ++;
 103                 while (pInfo->curr < pInfo->end) {
 104                     ch2 = *(pInfo->curr);
 105                     pInfo->curr ++;
 106                     if (ch2 == '*' && pInfo->curr < pInfo->end && *(pInfo->curr) == '/') {
 107                         pInfo->curr ++; // advance past the '/'
 108                         break;
 109                     }
 110                 }
 111             } else {
 112                 pInfo->curr --;
 113                 return true;
 114             }
 115         } else {
 116             pInfo->curr --;
 117             return true;
 118         }
 119     }
 120     return false;
 121 }
 122
 123 static UniChar getSlashedChar(_CFStringsFileParseInfo *pInfo) {
 124     UniChar ch = *(pInfo->curr);
 125     pInfo->curr ++;
 126     switch (ch) {
 127         case '0':
 128         case '1':
 129         case '2':
 130         case '3':
 131         case '4':
 132         case '5':
 133         case '6':
 134         case '7':  {
 135             uint8_t num = ch - '0';
 136             UniChar result;
 137             CFIndex usedCharLen;
 138             /* three digits maximum to avoid reading \000 followed by 5 as \5 ! */
 139             if ((ch = *(pInfo->curr)) >= '0' && ch <= '7') { // we use in this test the fact that the buffer is zero-terminated
 140                 pInfo->curr ++;
 141                 num = (num << 3) + ch - '0';
 142                 if ((pInfo->curr < pInfo->end) && (ch = *(pInfo->curr)) >= '0' && ch <= '7') {
 143                     pInfo->curr ++;
 144                     num = (num << 3) + ch - '0';
 145                 }
 146             }
 147             CFStringEncodingBytesToUnicode(kCFStringEncodingNextStepLatin, 0, &num, sizeof(uint8_t), NULL,  &result, 1, &usedCharLen);
 148             return (usedCharLen == 1) ? result : 0;
 149         }
 150         case 'U': {
 151             unsigned num = 0, numDigits = 4;    /* Parse four digits */
 152             while (pInfo->curr < pInfo->end && numDigits--) {
 153                 if (((ch = *(pInfo->curr)) < 128) && isxdigit(ch)) {
 154                     pInfo->curr ++;
 155                     num = (num << 4) + ((ch <= '9') ? (ch - '0') : ((ch <= 'F') ? (ch - 'A' + 10) : (ch - 'a' + 10)));
 156                 }
 157             }
 158             return num;
 159         }
 160         case 'a':       return '\a';    // Note: the meaning of '\a' varies with -traditional to gcc
 161         case 'b':       return '\b';
 162         case 'f':       return '\f';
 163         case 'n':       return '\n';
 164         case 'r':       return '\r';
 165         case 't':       return '\t';
 166         case 'v':       return '\v';
 167         case '"':       return '\"';
 168         case '\n':      return '\n';
 169     }
 170     return ch;
 171 }
 172
 173 static CFStringRef _uniqueStringForCharacters(_CFStringsFileParseInfo *pInfo, const UniChar *base, CFIndex length) {
 174     if (0 == length) return !(0) ? (CFStringRef)CFRetain(CFSTR("")) : CFSTR("");
 175     // This is to avoid having to promote the buffers of all the strings compared against
 176     // during the set probe; if a Unicode string is passed in, that's what happens.
 177     CFStringRef stringToUnique = NULL;
 178     Boolean use_stack = (length < 2048);
 179     STACK_BUFFER_DECL(uint8_t, buffer, use_stack ? length + 1 : 1);
 180     uint8_t *ascii = use_stack ? buffer : (uint8_t *)CFAllocatorAllocate(kCFAllocatorSystemDefault, length + 1, 0);
 181     for (CFIndex idx = 0; idx < length; idx++) {
 182         UniChar ch = base[idx];
 183         if (ch < 0x80) {
 184             ascii[idx] = (uint8_t)ch;
 185         } else {
 186             stringToUnique = CFStringCreateWithCharacters(pInfo->allocator, base, length);
 187             break;
 188         }
 189     }
 190     if (!stringToUnique) {
 191         ascii[length] = '\0';
 192         stringToUnique = CFStringCreateWithBytes(pInfo->allocator, ascii, length, kCFStringEncodingASCII, false);
 193     }
 194     if (ascii != buffer) CFAllocatorDeallocate(kCFAllocatorSystemDefault, ascii);
 195     CFStringRef uniqued = (CFStringRef)CFSetGetValue(pInfo->stringSet, stringToUnique);
 196     if (!uniqued) {
 197         CFSetAddValue(pInfo->stringSet, stringToUnique);
 198         uniqued = stringToUnique;
 199     }
 200     __CFPListRelease(stringToUnique, pInfo->allocator);
 201     if (uniqued && !(0)) CFRetain(uniqued);
 202     return uniqued;
 203 }
 204
 205 static CFStringRef _uniqueStringForString(_CFStringsFileParseInfo *pInfo, CFStringRef stringToUnique) {
 206     CFStringRef uniqued = (CFStringRef)CFSetGetValue(pInfo->stringSet, stringToUnique);
 207     if (!uniqued) {
 208         uniqued = (CFStringRef)__CFStringCollectionCopy(pInfo->allocator, stringToUnique);
 209         CFSetAddValue(pInfo->stringSet, uniqued);
 210         __CFTypeCollectionRelease(pInfo->allocator, uniqued);
 211     }
 212     if (uniqued && !(0)) CFRetain(uniqued);
 213     return uniqued;
 214 }
 215
 216 static CFStringRef parseQuotedPlistString(_CFStringsFileParseInfo *pInfo, UniChar quote) {
 217     CFMutableStringRef str = NULL;
 218     const UniChar *startMark = pInfo->curr;
 219     const UniChar *mark = pInfo->curr;
 220     while (pInfo->curr < pInfo->end) {
 221         UniChar ch = *(pInfo->curr);
 222         if (ch == quote) break;
 223         if (ch == '\\') {
 224             if (!str) str = CFStringCreateMutable(pInfo->allocator, 0);
 225             CFStringAppendCharacters(str, mark, pInfo->curr - mark);
 226             pInfo->curr ++;
 227             ch = getSlashedChar(pInfo);
 228             CFStringAppendCharacters(str, &ch, 1);
 229             mark = pInfo->curr;
 230         } else {
 231             // Note that the original NSParser code was much more complex at this point, but it had to deal with 8-bit characters in a non-UniChar stream.  We always have UniChar (we translated the data by the system encoding at the very beginning, hopefully), so this is safe.
 232             pInfo->curr ++;
 233         }
 234     }
 235     if (pInfo->end <= pInfo->curr) {
 236         __CFPListRelease(str, pInfo->allocator);
 237         pInfo->curr = startMark;
 238         pInfo->error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Unterminated quoted string starting on line %d"), lineNumberStrings(pInfo));
 239         return NULL;
 240     }
 241     if (!str) {
 242         if (pInfo->mutabilityOption == kCFPropertyListMutableContainersAndLeaves) {
 243             str = CFStringCreateMutable(pInfo->allocator, 0);
 244             CFStringAppendCharacters(str, mark, pInfo->curr - mark);
 245         } else {
 246             str = (CFMutableStringRef)_uniqueStringForCharacters(pInfo, mark, pInfo->curr-mark);
 247         }
 248     } else {
 249         if (mark != pInfo->curr) {
 250             CFStringAppendCharacters(str, mark, pInfo->curr - mark);
 251         }
 252         if (pInfo->mutabilityOption != kCFPropertyListMutableContainersAndLeaves) {
 253             CFStringRef uniqueString = _uniqueStringForString(pInfo, str);
 254             __CFPListRelease(str, pInfo->allocator);
 255             str = (CFMutableStringRef)uniqueString;
 256         }
 257     }
 258     pInfo->curr ++;  // Advance past the quote character before returning.
 259     if (pInfo->error) {
 260         CFRelease(pInfo->error);
 261         pInfo->error = NULL;
 262     }
 263     return str;
 264 }
 265
 266 static CFStringRef parseUnquotedPlistString(_CFStringsFileParseInfo *pInfo) {
 267     const UniChar *mark = pInfo->curr;
 268     while (pInfo->curr < pInfo->end) {
 269         UniChar ch = *pInfo->curr;
 270         if (isValidUnquotedStringCharacter(ch))
 271             pInfo->curr ++;
 272         else break;
 273     }
 274     if (pInfo->curr != mark) {
 275         if (pInfo->mutabilityOption != kCFPropertyListMutableContainersAndLeaves) {
 276             CFStringRef str = _uniqueStringForCharacters(pInfo, mark, pInfo->curr-mark);
 277             return str;
 278         } else {
 279             CFMutableStringRef str = CFStringCreateMutable(pInfo->allocator, 0);
 280             CFStringAppendCharacters(str, mark, pInfo->curr - mark);
 281             return str;
 282         }
 283     }
 284     pInfo->error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Unexpected EOF"));
 285     return NULL;
 286 }
 287
 288 static CFStringRef parsePlistString(_CFStringsFileParseInfo *pInfo, bool requireObject) {
 289     UniChar ch;
 290     Boolean foundChar = advanceToNonSpace(pInfo);
 291     if (!foundChar) {
 292         if (requireObject) {
 293             pInfo->error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Unexpected EOF while parsing string"));
 294         }
 295         return NULL;
 296     }
 297     ch = *(pInfo->curr);
 298     if (ch == '\'' || ch == '\"') {
 299         pInfo->curr ++;
 300         return parseQuotedPlistString(pInfo, ch);
 301     } else if (isValidUnquotedStringCharacter(ch)) {
 302         return parseUnquotedPlistString(pInfo);
 303     } else {
 304         if (requireObject) {
 305             pInfo->error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Invalid string character at line %d"), lineNumberStrings(pInfo));
 306         }
 307         return NULL;
 308     }
 309 }
 310
 311 static CFTypeRef parsePlistArray(_CFStringsFileParseInfo *pInfo) {
 312     CFMutableArrayRef array = CFArrayCreateMutable(pInfo->allocator, 0, &kCFTypeArrayCallBacks);
 313     CFTypeRef tmp = parsePlistObject(pInfo, false);
 314     Boolean foundChar;
 315     while (tmp) {
 316         CFArrayAppendValue(array, tmp);
 317         __CFPListRelease(tmp, pInfo->allocator);
 318         foundChar = advanceToNonSpace(pInfo);
 319         if (!foundChar) {
 320             __CFPListRelease(array, pInfo->allocator);
 321             pInfo->error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Expected ',' for array at line %d"), lineNumberStrings(pInfo));
 322             return NULL;
 323         }
 324         if (*pInfo->curr != ',') {
 325             tmp = NULL;
 326         } else {
 327             pInfo->curr ++;
 328             tmp = parsePlistObject(pInfo, false);
 329         }
 330     }
 331     foundChar = advanceToNonSpace(pInfo);
 332     if (!foundChar || *pInfo->curr != ')') {
 333         __CFPListRelease(array, pInfo->allocator);
 334         pInfo->error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Expected terminating ')' for array at line %d"), lineNumberStrings(pInfo));
 335         return NULL;
 336     }
 337     if (pInfo->error) {
 338         CFRelease(pInfo->error);
 339         pInfo->error = NULL;
 340     }
 341     pInfo->curr ++;
 342     return array;
 343 }
 344
 345 __attribute__((noinline)) void _CFPropertyListMissingSemicolon(UInt32 line) {
 346     CFLog(kCFLogLevelWarning, CFSTR("CFPropertyListCreateFromXMLData(): Old-style plist parser: missing semicolon in dictionary on line %d. Parsing will be abandoned. Break on _CFPropertyListMissingSemicolon to debug."), line);
 347 }
 348
 349 __attribute__((noinline)) void _CFPropertyListMissingSemicolonOrValue(UInt32 line) {
 350     CFLog(kCFLogLevelWarning, CFSTR("CFPropertyListCreateFromXMLData(): Old-style plist parser: missing semicolon or value in dictionary on line %d. Parsing will be abandoned. Break on _CFPropertyListMissingSemicolonOrValue to debug."), line);
 351 }
 352
 353 static CFDictionaryRef parsePlistDictContent(_CFStringsFileParseInfo *pInfo) {
 354     CFMutableDictionaryRef dict = CFDictionaryCreateMutable(pInfo->allocator, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 355     CFStringRef key = NULL;
 356     Boolean failedParse = false;
 357     key = parsePlistString(pInfo, false);
 358     while (key) {
 359         CFTypeRef value;
 360         Boolean foundChar = advanceToNonSpace(pInfo);
 361         if (!foundChar) {
 362             UInt32 line = lineNumberStrings(pInfo);
 363             _CFPropertyListMissingSemicolonOrValue(line);
 364             failedParse = true;
 365             pInfo->error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Missing ';' on line %d"), line);
 366             break;
 367         }
 368
 369         if (*pInfo->curr == ';') {
 370             /* This is a strings file using the shortcut format */
 371             /* although this check here really applies to all plists. */
 372             value = CFRetain(key);
 373         } else if (*pInfo->curr == '=') {
 374             pInfo->curr ++;
 375             value = parsePlistObject(pInfo, true);
 376             if (!value) {
 377                 failedParse = true;
 378                 break;
 379             }
 380         } else {
 381             pInfo->error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Unexpected ';' or '=' after key at line %d"), lineNumberStrings(pInfo));
 382             failedParse = true;
 383             break;
 384         }
 385         CFDictionarySetValue(dict, key, value);
 386         __CFPListRelease(key, pInfo->allocator);
 387         key = NULL;
 388         __CFPListRelease(value, pInfo->allocator);
 389         value = NULL;
 390         foundChar = advanceToNonSpace(pInfo);
 391         if (foundChar && *pInfo->curr == ';') {
 392             pInfo->curr ++;
 393             key = parsePlistString(pInfo, false);
 394         } else if (true || !foundChar) {
 395             UInt32 line = lineNumberStrings(pInfo);
 396             _CFPropertyListMissingSemicolon(line);
 397             failedParse = true;
 398             pInfo->error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Missing ';' on line %d"), line);
 399         }
 400     }
 401
 402     if (failedParse) {
 403         __CFPListRelease(key, pInfo->allocator);
 404         __CFPListRelease(dict, pInfo->allocator);
 405         return NULL;
 406     }
 407     if (pInfo->error) {
 408         CFRelease(pInfo->error);
 409         pInfo->error = NULL;
 410     }
 411     return dict;
 412 }
 413
 414 static CFTypeRef parsePlistDict(_CFStringsFileParseInfo *pInfo) {
 415     CFDictionaryRef dict = parsePlistDictContent(pInfo);
 416     if (!dict) return NULL;
 417     Boolean foundChar = advanceToNonSpace(pInfo);
 418     if (!foundChar || *pInfo->curr != '}') {
 419         __CFPListRelease(dict, pInfo->allocator);
 420         pInfo->error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Expected terminating '}' for dictionary at line %d"), lineNumberStrings(pInfo));
 421         return NULL;
 422     }
 423     pInfo->curr ++;
 424     return dict;
 425 }
 426
 427 CF_INLINE unsigned char fromHexDigit(unsigned char ch) {
 428     if (isdigit(ch)) return ch - '0';
 429     if ((ch >= 'a') && (ch <= 'f')) return ch - 'a' + 10;
 430     if ((ch >= 'A') && (ch <= 'F')) return ch - 'A' + 10;
 431     return 0xff; // Just choose a large number for the error code
 432 }
 433
 434 /* Gets up to bytesSize bytes from a plist data. Returns number of bytes actually read. Leaves cursor at first non-space, non-hex character.
 435  -1 is returned for unexpected char, -2 for uneven number of hex digits
 436  */
 437 static int getDataBytes(_CFStringsFileParseInfo *pInfo, unsigned char *bytes, int bytesSize) {
 438     int numBytesRead = 0;
 439     while ((pInfo->curr < pInfo->end) && (numBytesRead < bytesSize)) {
 440         int first, second;
 441         UniChar ch1 = *pInfo->curr;
 442         if (ch1 == '>') return numBytesRead;  // Meaning we're done
 443         first = fromHexDigit((unsigned char)ch1);
 444         if (first != 0xff) {    // If the first char is a hex, then try to read a second hex
 445             pInfo->curr++;
 446             if (pInfo->curr >= pInfo->end) return -2;   // Error: uneven number of hex digits
 447             UniChar ch2 = *pInfo->curr;
 448             second = fromHexDigit((unsigned char)ch2);
 449             if (second == 0xff) return -2;  // Error: uneven number of hex digits
 450             bytes[numBytesRead++] = (first << 4) + second;
 451             pInfo->curr++;
 452         } else if (ch1 == ' ' || ch1 == '\n' || ch1 == '\t' || ch1 == '\r' || ch1 == 0x2028 || ch1 == 0x2029) {
 453             pInfo->curr++;
 454         } else {
 455             return -1;  // Error: unexpected character
 456         }
 457     }
 458     return numBytesRead;    // This does likely mean we didn't encounter a '>', but we'll let the caller deal with that
 459 }
 460
 461 #define numBytes 400
 462 static CFTypeRef parsePlistData(_CFStringsFileParseInfo *pInfo) {
 463     CFMutableDataRef result = CFDataCreateMutable(pInfo->allocator, 0);
 464
 465     // Read hex bytes and append them to result
 466     while (1) {
 467         unsigned char bytes[numBytes];
 468         int numBytesRead = getDataBytes(pInfo, bytes, numBytes);
 469         if (numBytesRead < 0) {
 470             __CFPListRelease(result, pInfo->allocator);
 471             switch (numBytesRead) {
 472                 case -2:
 473                     pInfo->error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Malformed data byte group at line %d; uneven length"), lineNumberStrings(pInfo));
 474                     break;
 475                 default:
 476                     pInfo->error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Malformed data byte group at line %d; invalid hex"), lineNumberStrings(pInfo));
 477                     break;
 478             }
 479             return NULL;
 480         }
 481         if (numBytesRead == 0) break;
 482         CFDataAppendBytes(result, bytes, numBytesRead);
 483     }
 484
 485     if (pInfo->error) {
 486         CFRelease(pInfo->error);
 487         pInfo->error = NULL;
 488     }
 489
 490     if (*(pInfo->curr) == '>') {
 491         pInfo->curr ++; // Move past '>'
 492         return result;
 493     } else {
 494         __CFPListRelease(result, pInfo->allocator);
 495         pInfo->error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Expected terminating '>' for data at line %d"), lineNumberStrings(pInfo));
 496         return NULL;
 497     }
 498 }
 499 #undef numBytes
 500
 501 // Returned object is retained; caller must free.
 502 static CFTypeRef parsePlistObject(_CFStringsFileParseInfo *pInfo, bool requireObject) {
 503     UniChar ch;
 504     Boolean foundChar = advanceToNonSpace(pInfo);
 505     if (!foundChar) {
 506         if (requireObject) {
 507             pInfo->error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Unexpected EOF while parsing plist"));
 508         }
 509         return NULL;
 510     }
 511     ch = *(pInfo->curr);
 512     pInfo->curr ++;
 513     if (ch == '{') {
 514         return parsePlistDict(pInfo);
 515     } else if (ch == '(') {
 516         return parsePlistArray(pInfo);
 517     } else if (ch == '<') {
 518         return parsePlistData(pInfo);
 519     } else if (ch == '\'' || ch == '\"') {
 520         return parseQuotedPlistString(pInfo, ch);
 521     } else if (isValidUnquotedStringCharacter(ch)) {
 522         pInfo->curr --;
 523         return parseUnquotedPlistString(pInfo);
 524     } else {
 525         pInfo->curr --;  // Must back off the charcter we just read
 526         if (requireObject) {
 527             pInfo->error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Unexpected character '0x%x' at line %d"), ch, lineNumberStrings(pInfo));
 528         }
 529         return NULL;
 530     }
 531 }
 532
 533 // CFAllocatorRef allocator, CFDataRef xmlData, CFStringRef originalString, CFStringEncoding guessedEncoding, CFOptionFlags option, CFErrorRef *outError, Boolean allowNewTypes, CFPropertyListFormat *format, CFSetRef keyPaths
 534
 535 CF_PRIVATE CFTypeRef __CFCreateOldStylePropertyListOrStringsFile(CFAllocatorRef allocator, CFDataRef xmlData, CFStringRef originalString, CFStringEncoding guessedEncoding, CFOptionFlags option, CFErrorRef *outError,CFPropertyListFormat *format) {
 536
 537     // Convert the string to UTF16 for parsing old-style
 538     if (originalString) {
 539         // Ensure that originalString is not collected while we are using it
 540         CFRetain(originalString);
 541     } else {
 542         originalString = CFStringCreateWithBytes(kCFAllocatorSystemDefault, CFDataGetBytePtr(xmlData), CFDataGetLength(xmlData), guessedEncoding, NO);
 543         if (!originalString) {
 544             // Couldn't convert
 545             if (outError) *outError = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Conversion of string failed."));
 546             return NULL;
 547         }
 548     }
 549
 550     UInt32 length;
 551     Boolean createdBuffer = false;
 552     length = CFStringGetLength(originalString);
 553     if (!length) {
 554         if (outError) *outError = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Conversion of string failed. The string is empty."));
 555         return NULL;
 556     }
 557
 558     UniChar *buf = (UniChar *)CFStringGetCharactersPtr(originalString);
 559     if (!buf) {
 560         buf = (UniChar *)CFAllocatorAllocate(allocator, length * sizeof(UniChar), 0);
 561         if (!buf) {
 562             CRSetCrashLogMessage("CFPropertyList ran out of memory while attempting to allocate temporary storage.");
 563             return NULL;
 564         }
 565         CFStringGetCharacters(originalString, CFRangeMake(0, length), buf);
 566         createdBuffer = true;
 567     }
 568
 569     _CFStringsFileParseInfo stringsPInfo;
 570     stringsPInfo.begin = buf;
 571     stringsPInfo.end = buf+length;
 572     stringsPInfo.curr = buf;
 573     stringsPInfo.allocator = allocator;
 574     stringsPInfo.mutabilityOption = option;
 575     stringsPInfo.stringSet = CFSetCreateMutable(allocator, 0, &kCFTypeSetCallBacks);
 576     stringsPInfo.error = NULL;
 577
 578     const UniChar *begin = stringsPInfo.curr;
 579     CFTypeRef result = NULL;
 580     Boolean foundChar = advanceToNonSpace(&stringsPInfo);
 581     if (!foundChar) {
 582         // A file consisting only of whitespace (or empty) is now defined to be an empty dictionary
 583         result = CFDictionaryCreateMutable(allocator, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 584     } else {
 585         result = parsePlistObject(&stringsPInfo, true);
 586         if (result) {
 587             foundChar = advanceToNonSpace(&stringsPInfo);
 588             if (foundChar) {
 589                 if (CFGetTypeID(result) != CFStringGetTypeID()) {
 590                     __CFPListRelease(result, allocator);
 591                     result = NULL;
 592                     if (stringsPInfo.error) CFRelease(stringsPInfo.error);
 593                     stringsPInfo.error = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Junk after plist at line %d"), lineNumberStrings(&stringsPInfo));
 594                 } else {
 595                     // Reset info and keep parsing
 596                     __CFPListRelease(result, allocator);
 597                     if (stringsPInfo.error) CFRelease(stringsPInfo.error);
 598                     stringsPInfo.error = NULL;
 599
 600                     // Check for a strings file (looks like a dictionary without the opening/closing curly braces)
 601                     stringsPInfo.curr = begin;
 602                     result = parsePlistDictContent(&stringsPInfo);
 603                 }
 604             }
 605         }
 606     }
 607
 608     if (!result) {
 609         // Must return some kind of error if requested
 610         if (outError) {
 611             if (stringsPInfo.error) {
 612                 // Transfer ownership
 613                 *outError = stringsPInfo.error;
 614             } else {
 615                 *outError = __CFPropertyListCreateError(kCFPropertyListReadCorruptError, CFSTR("Unknown error parsing property list around line %d"), lineNumberStrings(&stringsPInfo));
 616             }
 617         } else if (stringsPInfo.error) {
 618             // Caller doesn't want it, so we need to free it
 619             CFRelease(stringsPInfo.error);
 620         }
 621     }
 622
 623     if (result && format) *format = kCFPropertyListOpenStepFormat;
 624
 625     if (createdBuffer && !(0)) CFAllocatorDeallocate(allocator, buf);
 626     CFRelease(stringsPInfo.stringSet);
 627     CFRelease(originalString);
 628     return result;
 629 }
 630
 631 #undef isValidUnquotedStringCharacter