1 /* 2 ******************************************************************************* 3 * 4 * Copyright (C) 2003-2010, International Business Machines 5 * Corporation and others. All Rights Reserved. 6 * 7 ******************************************************************************* 8 * file name: usprep.cpp 9 * encoding: US-ASCII 10 * tab size: 8 (not used) 11 * indentation:4 12 * 13 * created on: 2003jul2 14 * created by: Ram Viswanadha 15 */ 16 17 #include "unicode/utypes.h" 18 19 #if !UCONFIG_NO_IDNA 20 21 #include "unicode/usprep.h" 22 23 #include "unicode/unorm.h" 24 #include "unicode/ustring.h" 25 #include "unicode/uchar.h" 26 #include "unicode/uversion.h" 27 #include "umutex.h" 28 #include "cmemory.h" 29 #include "sprpimpl.h" 30 #include "ustr_imp.h" 31 #include "uhash.h" 32 #include "cstring.h" 33 #include "udataswp.h" 34 #include "ucln_cmn.h" 35 #include "ubidi_props.h" 36 37 U_NAMESPACE_USE 38 39 U_CDECL_BEGIN 40 41 /* 42 Static cache for already opened StringPrep profiles 43 */ 44 static UHashtable *SHARED_DATA_HASHTABLE = NULL; 45 46 static UMTX usprepMutex = NULL; 47 48 /* format version of spp file */ 49 static uint8_t formatVersion[4]={ 0, 0, 0, 0 }; 50 51 /* the Unicode version of the sprep data */ 52 static UVersionInfo dataVersion={ 0, 0, 0, 0 }; 53 54 /* Profile names must be aligned to UStringPrepProfileType */ 55 static const char *PROFILE_NAMES[] = { 56 "rfc3491", /* USPREP_RFC3491_NAMEPREP */ 57 "rfc3530cs", /* USPREP_RFC3530_NFS4_CS_PREP */ 58 "rfc3530csci", /* USPREP_RFC3530_NFS4_CS_PREP_CI */ 59 "rfc3491", /* USPREP_RFC3530_NSF4_CIS_PREP */ 60 "rfc3530mixp", /* USPREP_RFC3530_NSF4_MIXED_PREP_PREFIX */ 61 "rfc3491", /* USPREP_RFC3530_NSF4_MIXED_PREP_SUFFIX */ 62 "rfc3722", /* USPREP_RFC3722_ISCSI */ 63 "rfc3920node", /* USPREP_RFC3920_NODEPREP */ 64 "rfc3920res", /* USPREP_RFC3920_RESOURCEPREP */ 65 "rfc4011", /* USPREP_RFC4011_MIB */ 66 "rfc4013", /* USPREP_RFC4013_SASLPREP */ 67 "rfc4505", /* USPREP_RFC4505_TRACE */ 68 "rfc4518", /* USPREP_RFC4518_LDAP */ 69 "rfc4518ci", /* USPREP_RFC4518_LDAP_CI */ 70 }; 71 72 static UBool U_CALLCONV 73 isSPrepAcceptable(void * /* context */, 74 const char * /* type */, 75 const char * /* name */, 76 const UDataInfo *pInfo) { 77 if( 78 pInfo->size>=20 && 79 pInfo->isBigEndian==U_IS_BIG_ENDIAN && 80 pInfo->charsetFamily==U_CHARSET_FAMILY && 81 pInfo->dataFormat[0]==0x53 && /* dataFormat="SPRP" */ 82 pInfo->dataFormat[1]==0x50 && 83 pInfo->dataFormat[2]==0x52 && 84 pInfo->dataFormat[3]==0x50 && 85 pInfo->formatVersion[0]==3 && 86 pInfo->formatVersion[2]==UTRIE_SHIFT && 87 pInfo->formatVersion[3]==UTRIE_INDEX_SHIFT 88 ) { 89 uprv_memcpy(formatVersion, pInfo->formatVersion, 4); 90 uprv_memcpy(dataVersion, pInfo->dataVersion, 4); 91 return TRUE; 92 } else { 93 return FALSE; 94 } 95 } 96 97 static int32_t U_CALLCONV 98 getSPrepFoldingOffset(uint32_t data) { 99 100 return (int32_t)data; 101 102 } 103 104 /* hashes an entry */ 105 static int32_t U_CALLCONV 106 hashEntry(const UHashTok parm) { 107 UStringPrepKey *b = (UStringPrepKey *)parm.pointer; 108 UHashTok namekey, pathkey; 109 namekey.pointer = b->name; 110 pathkey.pointer = b->path; 111 return uhash_hashChars(namekey)+37*uhash_hashChars(pathkey); 112 } 113 114 /* compares two entries */ 115 static UBool U_CALLCONV 116 compareEntries(const UHashTok p1, const UHashTok p2) { 117 UStringPrepKey *b1 = (UStringPrepKey *)p1.pointer; 118 UStringPrepKey *b2 = (UStringPrepKey *)p2.pointer; 119 UHashTok name1, name2, path1, path2; 120 name1.pointer = b1->name; 121 name2.pointer = b2->name; 122 path1.pointer = b1->path; 123 path2.pointer = b2->path; 124 return ((UBool)(uhash_compareChars(name1, name2) & 125 uhash_compareChars(path1, path2))); 126 } 127 128 static void 129 usprep_unload(UStringPrepProfile* data){ 130 udata_close(data->sprepData); 131 } 132 133 static int32_t 134 usprep_internal_flushCache(UBool noRefCount){ 135 UStringPrepProfile *profile = NULL; 136 UStringPrepKey *key = NULL; 137 int32_t pos = -1; 138 int32_t deletedNum = 0; 139 const UHashElement *e; 140 141 /* 142 * if shared data hasn't even been lazy evaluated yet 143 * return 0 144 */ 145 umtx_lock(&usprepMutex); 146 if (SHARED_DATA_HASHTABLE == NULL) { 147 umtx_unlock(&usprepMutex); 148 return 0; 149 } 150 151 /*creates an enumeration to iterate through every element in the table */ 152 while ((e = uhash_nextElement(SHARED_DATA_HASHTABLE, &pos)) != NULL) 153 { 154 profile = (UStringPrepProfile *) e->value.pointer; 155 key = (UStringPrepKey *) e->key.pointer; 156 157 if ((noRefCount== FALSE && profile->refCount == 0) || 158 noRefCount== TRUE) { 159 deletedNum++; 160 uhash_removeElement(SHARED_DATA_HASHTABLE, e); 161 162 /* unload the data */ 163 usprep_unload(profile); 164 165 if(key->name != NULL) { 166 uprv_free(key->name); 167 key->name=NULL; 168 } 169 if(key->path != NULL) { 170 uprv_free(key->path); 171 key->path=NULL; 172 } 173 uprv_free(profile); 174 uprv_free(key); 175 } 176 177 } 178 umtx_unlock(&usprepMutex); 179 180 return deletedNum; 181 } 182 183 /* Works just like ucnv_flushCache() 184 static int32_t 185 usprep_flushCache(){ 186 return usprep_internal_flushCache(FALSE); 187 } 188 */ 189 190 static UBool U_CALLCONV usprep_cleanup(void){ 191 if (SHARED_DATA_HASHTABLE != NULL) { 192 usprep_internal_flushCache(TRUE); 193 if (SHARED_DATA_HASHTABLE != NULL && uhash_count(SHARED_DATA_HASHTABLE) == 0) { 194 uhash_close(SHARED_DATA_HASHTABLE); 195 SHARED_DATA_HASHTABLE = NULL; 196 } 197 } 198 199 umtx_destroy(&usprepMutex); /* Don't worry about destroying the mutex even */ 200 /* if the hash table still exists. The mutex */ 201 /* will lazily re-init itself if needed. */ 202 return (SHARED_DATA_HASHTABLE == NULL); 203 } 204 U_CDECL_END 205 206 207 /** Initializes the cache for resources */ 208 static void 209 initCache(UErrorCode *status) { 210 UBool makeCache; 211 UMTX_CHECK(&usprepMutex, (SHARED_DATA_HASHTABLE == NULL), makeCache); 212 if(makeCache) { 213 UHashtable *newCache = uhash_open(hashEntry, compareEntries, NULL, status); 214 if (U_SUCCESS(*status)) { 215 umtx_lock(&usprepMutex); 216 if(SHARED_DATA_HASHTABLE == NULL) { 217 SHARED_DATA_HASHTABLE = newCache; 218 ucln_common_registerCleanup(UCLN_COMMON_USPREP, usprep_cleanup); 219 newCache = NULL; 220 } 221 umtx_unlock(&usprepMutex); 222 } 223 if(newCache != NULL) { 224 uhash_close(newCache); 225 } 226 } 227 } 228 229 static UBool U_CALLCONV 230 loadData(UStringPrepProfile* profile, 231 const char* path, 232 const char* name, 233 const char* type, 234 UErrorCode* errorCode) { 235 /* load Unicode SPREP data from file */ 236 UTrie _sprepTrie={ 0,0,0,0,0,0,0 }; 237 UDataMemory *dataMemory; 238 const int32_t *p=NULL; 239 const uint8_t *pb; 240 UVersionInfo normUnicodeVersion; 241 int32_t normUniVer, sprepUniVer, normCorrVer; 242 243 if(errorCode==NULL || U_FAILURE(*errorCode)) { 244 return 0; 245 } 246 247 /* open the data outside the mutex block */ 248 //TODO: change the path 249 dataMemory=udata_openChoice(path, type, name, isSPrepAcceptable, NULL, errorCode); 250 if(U_FAILURE(*errorCode)) { 251 return FALSE; 252 } 253 254 p=(const int32_t *)udata_getMemory(dataMemory); 255 pb=(const uint8_t *)(p+_SPREP_INDEX_TOP); 256 utrie_unserialize(&_sprepTrie, pb, p[_SPREP_INDEX_TRIE_SIZE], errorCode); 257 _sprepTrie.getFoldingOffset=getSPrepFoldingOffset; 258 259 260 if(U_FAILURE(*errorCode)) { 261 udata_close(dataMemory); 262 return FALSE; 263 } 264 265 /* in the mutex block, set the data for this process */ 266 umtx_lock(&usprepMutex); 267 if(profile->sprepData==NULL) { 268 profile->sprepData=dataMemory; 269 dataMemory=NULL; 270 uprv_memcpy(&profile->indexes, p, sizeof(profile->indexes)); 271 uprv_memcpy(&profile->sprepTrie, &_sprepTrie, sizeof(UTrie)); 272 } else { 273 p=(const int32_t *)udata_getMemory(profile->sprepData); 274 } 275 umtx_unlock(&usprepMutex); 276 /* initialize some variables */ 277 profile->mappingData=(uint16_t *)((uint8_t *)(p+_SPREP_INDEX_TOP)+profile->indexes[_SPREP_INDEX_TRIE_SIZE]); 278 279 u_getUnicodeVersion(normUnicodeVersion); 280 normUniVer = (normUnicodeVersion[0] << 24) + (normUnicodeVersion[1] << 16) + 281 (normUnicodeVersion[2] << 8 ) + (normUnicodeVersion[3]); 282 sprepUniVer = (dataVersion[0] << 24) + (dataVersion[1] << 16) + 283 (dataVersion[2] << 8 ) + (dataVersion[3]); 284 normCorrVer = profile->indexes[_SPREP_NORM_CORRECTNS_LAST_UNI_VERSION]; 285 286 if(U_FAILURE(*errorCode)){ 287 udata_close(dataMemory); 288 return FALSE; 289 } 290 if( normUniVer < sprepUniVer && /* the Unicode version of SPREP file must be less than the Unicode Vesion of the normalization data */ 291 normUniVer < normCorrVer && /* the Unicode version of the NormalizationCorrections.txt file should be less than the Unicode Vesion of the normalization data */ 292 ((profile->indexes[_SPREP_OPTIONS] & _SPREP_NORMALIZATION_ON) > 0) /* normalization turned on*/ 293 ){ 294 *errorCode = U_INVALID_FORMAT_ERROR; 295 udata_close(dataMemory); 296 return FALSE; 297 } 298 profile->isDataLoaded = TRUE; 299 300 /* if a different thread set it first, then close the extra data */ 301 if(dataMemory!=NULL) { 302 udata_close(dataMemory); /* NULL if it was set correctly */ 303 } 304 305 306 return profile->isDataLoaded; 307 } 308 309 static UStringPrepProfile* 310 usprep_getProfile(const char* path, 311 const char* name, 312 UErrorCode *status){ 313 314 UStringPrepProfile* profile = NULL; 315 316 initCache(status); 317 318 if(U_FAILURE(*status)){ 319 return NULL; 320 } 321 322 UStringPrepKey stackKey; 323 /* 324 * const is cast way to save malloc, strcpy and free calls 325 * we use the passed in pointers for fetching the data from the 326 * hash table which is safe 327 */ 328 stackKey.name = (char*) name; 329 stackKey.path = (char*) path; 330 331 /* fetch the data from the cache */ 332 umtx_lock(&usprepMutex); 333 profile = (UStringPrepProfile*) (uhash_get(SHARED_DATA_HASHTABLE,&stackKey)); 334 if(profile != NULL) { 335 profile->refCount++; 336 } 337 umtx_unlock(&usprepMutex); 338 339 if(profile == NULL) { 340 /* else load the data and put the data in the cache */ 341 LocalMemory<UStringPrepProfile> newProfile; 342 if(newProfile.allocateInsteadAndReset() == NULL) { 343 *status = U_MEMORY_ALLOCATION_ERROR; 344 return NULL; 345 } 346 347 /* load the data */ 348 if(!loadData(newProfile.getAlias(), path, name, _SPREP_DATA_TYPE, status) || U_FAILURE(*status) ){ 349 return NULL; 350 } 351 352 /* get the options */ 353 newProfile->doNFKC = (UBool)((newProfile->indexes[_SPREP_OPTIONS] & _SPREP_NORMALIZATION_ON) > 0); 354 newProfile->checkBiDi = (UBool)((newProfile->indexes[_SPREP_OPTIONS] & _SPREP_CHECK_BIDI_ON) > 0); 355 356 if(newProfile->checkBiDi) { 357 newProfile->bdp = ubidi_getSingleton(); 358 } 359 360 LocalMemory<UStringPrepKey> key; 361 LocalMemory<char> keyName; 362 LocalMemory<char> keyPath; 363 if( key.allocateInsteadAndReset() == NULL || 364 keyName.allocateInsteadAndCopy(uprv_strlen(name)+1) == NULL || 365 (path != NULL && 366 keyPath.allocateInsteadAndCopy(uprv_strlen(path)+1) == NULL) 367 ) { 368 *status = U_MEMORY_ALLOCATION_ERROR; 369 usprep_unload(newProfile.getAlias()); 370 return NULL; 371 } 372 373 umtx_lock(&usprepMutex); 374 // If another thread already inserted the same key/value, refcount and cleanup our thread data 375 profile = (UStringPrepProfile*) (uhash_get(SHARED_DATA_HASHTABLE,&stackKey)); 376 if(profile != NULL) { 377 profile->refCount++; 378 usprep_unload(newProfile.getAlias()); 379 } 380 else { 381 /* initialize the key members */ 382 key->name = keyName.orphan(); 383 uprv_strcpy(key->name, name); 384 if(path != NULL){ 385 key->path = keyPath.orphan(); 386 uprv_strcpy(key->path, path); 387 } 388 profile = newProfile.orphan(); 389 390 /* add the data object to the cache */ 391 profile->refCount = 1; 392 uhash_put(SHARED_DATA_HASHTABLE, key.orphan(), profile, status); 393 } 394 umtx_unlock(&usprepMutex); 395 } 396 397 return profile; 398 } 399 400 U_CAPI UStringPrepProfile* U_EXPORT2 401 usprep_open(const char* path, 402 const char* name, 403 UErrorCode* status){ 404 405 if(status == NULL || U_FAILURE(*status)){ 406 return NULL; 407 } 408 409 /* initialize the profile struct members */ 410 return usprep_getProfile(path,name,status); 411 } 412 413 U_CAPI UStringPrepProfile* U_EXPORT2 414 usprep_openByType(UStringPrepProfileType type, 415 UErrorCode* status) { 416 if(status == NULL || U_FAILURE(*status)){ 417 return NULL; 418 } 419 int32_t index = (int32_t)type; 420 if (index < 0 || index >= (int32_t)(sizeof(PROFILE_NAMES)/sizeof(PROFILE_NAMES[0]))) { 421 *status = U_ILLEGAL_ARGUMENT_ERROR; 422 return NULL; 423 } 424 return usprep_open(NULL, PROFILE_NAMES[index], status); 425 } 426 427 U_CAPI void U_EXPORT2 428 usprep_close(UStringPrepProfile* profile){ 429 if(profile==NULL){ 430 return; 431 } 432 433 umtx_lock(&usprepMutex); 434 /* decrement the ref count*/ 435 if(profile->refCount > 0){ 436 profile->refCount--; 437 } 438 umtx_unlock(&usprepMutex); 439 440 } 441 442 U_CFUNC void 443 uprv_syntaxError(const UChar* rules, 444 int32_t pos, 445 int32_t rulesLen, 446 UParseError* parseError){ 447 if(parseError == NULL){ 448 return; 449 } 450 parseError->offset = pos; 451 parseError->line = 0 ; // we are not using line numbers 452 453 // for pre-context 454 int32_t start = (pos < U_PARSE_CONTEXT_LEN)? 0 : (pos - (U_PARSE_CONTEXT_LEN-1)); 455 int32_t limit = pos; 456 457 u_memcpy(parseError->preContext,rules+start,limit-start); 458 //null terminate the buffer 459 parseError->preContext[limit-start] = 0; 460 461 // for post-context; include error rules[pos] 462 start = pos; 463 limit = start + (U_PARSE_CONTEXT_LEN-1); 464 if (limit > rulesLen) { 465 limit = rulesLen; 466 } 467 if (start < rulesLen) { 468 u_memcpy(parseError->postContext,rules+start,limit-start); 469 } 470 //null terminate the buffer 471 parseError->postContext[limit-start]= 0; 472 } 473 474 475 static inline UStringPrepType 476 getValues(uint16_t trieWord, int16_t& value, UBool& isIndex){ 477 478 UStringPrepType type; 479 if(trieWord == 0){ 480 /* 481 * Initial value stored in the mapping table 482 * just return USPREP_TYPE_LIMIT .. so that 483 * the source codepoint is copied to the destination 484 */ 485 type = USPREP_TYPE_LIMIT; 486 isIndex =FALSE; 487 value = 0; 488 }else if(trieWord >= _SPREP_TYPE_THRESHOLD){ 489 type = (UStringPrepType) (trieWord - _SPREP_TYPE_THRESHOLD); 490 isIndex =FALSE; 491 value = 0; 492 }else{ 493 /* get the type */ 494 type = USPREP_MAP; 495 /* ascertain if the value is index or delta */ 496 if(trieWord & 0x02){ 497 isIndex = TRUE; 498 value = trieWord >> 2; //mask off the lower 2 bits and shift 499 }else{ 500 isIndex = FALSE; 501 value = (int16_t)trieWord; 502 value = (value >> 2); 503 } 504 505 if((trieWord>>2) == _SPREP_MAX_INDEX_VALUE){ 506 type = USPREP_DELETE; 507 isIndex =FALSE; 508 value = 0; 509 } 510 } 511 return type; 512 } 513 514 515 516 static int32_t 517 usprep_map( const UStringPrepProfile* profile, 518 const UChar* src, int32_t srcLength, 519 UChar* dest, int32_t destCapacity, 520 int32_t options, 521 UParseError* parseError, 522 UErrorCode* status ){ 523 524 uint16_t result; 525 int32_t destIndex=0; 526 int32_t srcIndex; 527 UBool allowUnassigned = (UBool) ((options & USPREP_ALLOW_UNASSIGNED)>0); 528 UStringPrepType type; 529 int16_t value; 530 UBool isIndex; 531 const int32_t* indexes = profile->indexes; 532 533 // no error checking the caller check for error and arguments 534 // no string length check the caller finds out the string length 535 536 for(srcIndex=0;srcIndex<srcLength;){ 537 UChar32 ch; 538 539 U16_NEXT(src,srcIndex,srcLength,ch); 540 541 result=0; 542 543 UTRIE_GET16(&profile->sprepTrie,ch,result); 544 545 type = getValues(result, value, isIndex); 546 547 // check if the source codepoint is unassigned 548 if(type == USPREP_UNASSIGNED && allowUnassigned == FALSE){ 549 550 uprv_syntaxError(src,srcIndex-U16_LENGTH(ch), srcLength,parseError); 551 *status = U_STRINGPREP_UNASSIGNED_ERROR; 552 return 0; 553 554 }else if(type == USPREP_MAP){ 555 556 int32_t index, length; 557 558 if(isIndex){ 559 index = value; 560 if(index >= indexes[_SPREP_ONE_UCHAR_MAPPING_INDEX_START] && 561 index < indexes[_SPREP_TWO_UCHARS_MAPPING_INDEX_START]){ 562 length = 1; 563 }else if(index >= indexes[_SPREP_TWO_UCHARS_MAPPING_INDEX_START] && 564 index < indexes[_SPREP_THREE_UCHARS_MAPPING_INDEX_START]){ 565 length = 2; 566 }else if(index >= indexes[_SPREP_THREE_UCHARS_MAPPING_INDEX_START] && 567 index < indexes[_SPREP_FOUR_UCHARS_MAPPING_INDEX_START]){ 568 length = 3; 569 }else{ 570 length = profile->mappingData[index++]; 571 572 } 573 574 /* copy mapping to destination */ 575 for(int32_t i=0; i< length; i++){ 576 if(destIndex < destCapacity ){ 577 dest[destIndex] = profile->mappingData[index+i]; 578 } 579 destIndex++; /* for pre-flighting */ 580 } 581 continue; 582 }else{ 583 // subtract the delta to arrive at the code point 584 ch -= value; 585 } 586 587 }else if(type==USPREP_DELETE){ 588 // just consume the codepoint and contine 589 continue; 590 } 591 //copy the code point into destination 592 if(ch <= 0xFFFF){ 593 if(destIndex < destCapacity ){ 594 dest[destIndex] = (UChar)ch; 595 } 596 destIndex++; 597 }else{ 598 if(destIndex+1 < destCapacity ){ 599 dest[destIndex] = U16_LEAD(ch); 600 dest[destIndex+1] = U16_TRAIL(ch); 601 } 602 destIndex +=2; 603 } 604 605 } 606 607 return u_terminateUChars(dest, destCapacity, destIndex, status); 608 } 609 610 611 static int32_t 612 usprep_normalize( const UChar* src, int32_t srcLength, 613 UChar* dest, int32_t destCapacity, 614 UErrorCode* status ){ 615 return unorm_normalize( 616 src, srcLength, 617 UNORM_NFKC, UNORM_UNICODE_3_2, 618 dest, destCapacity, 619 status); 620 } 621 622 623 /* 624 1) Map -- For each character in the input, check if it has a mapping 625 and, if so, replace it with its mapping. 626 627 2) Normalize -- Possibly normalize the result of step 1 using Unicode 628 normalization. 629 630 3) Prohibit -- Check for any characters that are not allowed in the 631 output. If any are found, return an error. 632 633 4) Check bidi -- Possibly check for right-to-left characters, and if 634 any are found, make sure that the whole string satisfies the 635 requirements for bidirectional strings. If the string does not 636 satisfy the requirements for bidirectional strings, return an 637 error. 638 [Unicode3.2] defines several bidirectional categories; each character 639 has one bidirectional category assigned to it. For the purposes of 640 the requirements below, an "RandALCat character" is a character that 641 has Unicode bidirectional categories "R" or "AL"; an "LCat character" 642 is a character that has Unicode bidirectional category "L". Note 643 644 645 that there are many characters which fall in neither of the above 646 definitions; Latin digits (<U+0030> through <U+0039>) are examples of 647 this because they have bidirectional category "EN". 648 649 In any profile that specifies bidirectional character handling, all 650 three of the following requirements MUST be met: 651 652 1) The characters in section 5.8 MUST be prohibited. 653 654 2) If a string contains any RandALCat character, the string MUST NOT 655 contain any LCat character. 656 657 3) If a string contains any RandALCat character, a RandALCat 658 character MUST be the first character of the string, and a 659 RandALCat character MUST be the last character of the string. 660 */ 661 662 #define MAX_STACK_BUFFER_SIZE 300 663 664 665 U_CAPI int32_t U_EXPORT2 666 usprep_prepare( const UStringPrepProfile* profile, 667 const UChar* src, int32_t srcLength, 668 UChar* dest, int32_t destCapacity, 669 int32_t options, 670 UParseError* parseError, 671 UErrorCode* status ){ 672 673 // check error status 674 if(status == NULL || U_FAILURE(*status)){ 675 return 0; 676 } 677 678 //check arguments 679 if(profile==NULL || src==NULL || srcLength<-1 || (dest==NULL && destCapacity!=0)) { 680 *status=U_ILLEGAL_ARGUMENT_ERROR; 681 return 0; 682 } 683 684 UChar b1Stack[MAX_STACK_BUFFER_SIZE], b2Stack[MAX_STACK_BUFFER_SIZE]; 685 UChar *b1 = b1Stack, *b2 = b2Stack; 686 int32_t b1Len, b2Len=0, 687 b1Capacity = MAX_STACK_BUFFER_SIZE , 688 b2Capacity = MAX_STACK_BUFFER_SIZE; 689 uint16_t result; 690 int32_t b2Index = 0; 691 UCharDirection direction=U_CHAR_DIRECTION_COUNT, firstCharDir=U_CHAR_DIRECTION_COUNT; 692 UBool leftToRight=FALSE, rightToLeft=FALSE; 693 int32_t rtlPos =-1, ltrPos =-1; 694 695 //get the string length 696 if(srcLength == -1){ 697 srcLength = u_strlen(src); 698 } 699 // map 700 b1Len = usprep_map(profile, src, srcLength, b1, b1Capacity, options, parseError, status); 701 702 if(*status == U_BUFFER_OVERFLOW_ERROR){ 703 // redo processing of string 704 /* we do not have enough room so grow the buffer*/ 705 b1 = (UChar*) uprv_malloc(b1Len * U_SIZEOF_UCHAR); 706 if(b1==NULL){ 707 *status = U_MEMORY_ALLOCATION_ERROR; 708 goto CLEANUP; 709 } 710 711 *status = U_ZERO_ERROR; // reset error 712 713 b1Len = usprep_map(profile, src, srcLength, b1, b1Len, options, parseError, status); 714 715 } 716 717 // normalize 718 if(profile->doNFKC == TRUE){ 719 b2Len = usprep_normalize(b1,b1Len, b2,b2Capacity,status); 720 721 if(*status == U_BUFFER_OVERFLOW_ERROR){ 722 // redo processing of string 723 /* we do not have enough room so grow the buffer*/ 724 b2 = (UChar*) uprv_malloc(b2Len * U_SIZEOF_UCHAR); 725 if(b2==NULL){ 726 *status = U_MEMORY_ALLOCATION_ERROR; 727 goto CLEANUP; 728 } 729 730 *status = U_ZERO_ERROR; // reset error 731 732 b2Len = usprep_normalize(b1,b1Len, b2,b2Len,status); 733 734 } 735 736 }else{ 737 b2 = b1; 738 b2Len = b1Len; 739 } 740 741 742 if(U_FAILURE(*status)){ 743 goto CLEANUP; 744 } 745 746 UChar32 ch; 747 UStringPrepType type; 748 int16_t value; 749 UBool isIndex; 750 751 // Prohibit and checkBiDi in one pass 752 for(b2Index=0; b2Index<b2Len;){ 753 754 ch = 0; 755 756 U16_NEXT(b2, b2Index, b2Len, ch); 757 758 UTRIE_GET16(&profile->sprepTrie,ch,result); 759 760 type = getValues(result, value, isIndex); 761 762 if( type == USPREP_PROHIBITED || 763 ((result < _SPREP_TYPE_THRESHOLD) && (result & 0x01) /* first bit says it the code point is prohibited*/) 764 ){ 765 *status = U_STRINGPREP_PROHIBITED_ERROR; 766 uprv_syntaxError(b1, b2Index-U16_LENGTH(ch), b2Len, parseError); 767 goto CLEANUP; 768 } 769 770 if(profile->checkBiDi) { 771 direction = ubidi_getClass(profile->bdp, ch); 772 if(firstCharDir == U_CHAR_DIRECTION_COUNT){ 773 firstCharDir = direction; 774 } 775 if(direction == U_LEFT_TO_RIGHT){ 776 leftToRight = TRUE; 777 ltrPos = b2Index-1; 778 } 779 if(direction == U_RIGHT_TO_LEFT || direction == U_RIGHT_TO_LEFT_ARABIC){ 780 rightToLeft = TRUE; 781 rtlPos = b2Index-1; 782 } 783 } 784 } 785 if(profile->checkBiDi == TRUE){ 786 // satisfy 2 787 if( leftToRight == TRUE && rightToLeft == TRUE){ 788 *status = U_STRINGPREP_CHECK_BIDI_ERROR; 789 uprv_syntaxError(b2,(rtlPos>ltrPos) ? rtlPos : ltrPos, b2Len, parseError); 790 goto CLEANUP; 791 } 792 793 //satisfy 3 794 if( rightToLeft == TRUE && 795 !((firstCharDir == U_RIGHT_TO_LEFT || firstCharDir == U_RIGHT_TO_LEFT_ARABIC) && 796 (direction == U_RIGHT_TO_LEFT || direction == U_RIGHT_TO_LEFT_ARABIC)) 797 ){ 798 *status = U_STRINGPREP_CHECK_BIDI_ERROR; 799 uprv_syntaxError(b2, rtlPos, b2Len, parseError); 800 return FALSE; 801 } 802 } 803 if(b2Len>0 && b2Len <= destCapacity){ 804 uprv_memmove(dest,b2, b2Len*U_SIZEOF_UCHAR); 805 } 806 807 CLEANUP: 808 if(b1!=b1Stack){ 809 uprv_free(b1); 810 b1=NULL; 811 } 812 813 if(b2!=b1Stack && b2!=b2Stack && b2!=b1 /* b1 should not be freed twice */){ 814 uprv_free(b2); 815 b2=NULL; 816 } 817 return u_terminateUChars(dest, destCapacity, b2Len, status); 818 } 819 820 821 /* data swapping ------------------------------------------------------------ */ 822 823 U_CAPI int32_t U_EXPORT2 824 usprep_swap(const UDataSwapper *ds, 825 const void *inData, int32_t length, void *outData, 826 UErrorCode *pErrorCode) { 827 const UDataInfo *pInfo; 828 int32_t headerSize; 829 830 const uint8_t *inBytes; 831 uint8_t *outBytes; 832 833 const int32_t *inIndexes; 834 int32_t indexes[16]; 835 836 int32_t i, offset, count, size; 837 838 /* udata_swapDataHeader checks the arguments */ 839 headerSize=udata_swapDataHeader(ds, inData, length, outData, pErrorCode); 840 if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { 841 return 0; 842 } 843 844 /* check data format and format version */ 845 pInfo=(const UDataInfo *)((const char *)inData+4); 846 if(!( 847 pInfo->dataFormat[0]==0x53 && /* dataFormat="SPRP" */ 848 pInfo->dataFormat[1]==0x50 && 849 pInfo->dataFormat[2]==0x52 && 850 pInfo->dataFormat[3]==0x50 && 851 pInfo->formatVersion[0]==3 852 )) { 853 udata_printError(ds, "usprep_swap(): data format %02x.%02x.%02x.%02x (format version %02x) is not recognized as StringPrep .spp data\n", 854 pInfo->dataFormat[0], pInfo->dataFormat[1], 855 pInfo->dataFormat[2], pInfo->dataFormat[3], 856 pInfo->formatVersion[0]); 857 *pErrorCode=U_UNSUPPORTED_ERROR; 858 return 0; 859 } 860 861 inBytes=(const uint8_t *)inData+headerSize; 862 outBytes=(uint8_t *)outData+headerSize; 863 864 inIndexes=(const int32_t *)inBytes; 865 866 if(length>=0) { 867 length-=headerSize; 868 if(length<16*4) { 869 udata_printError(ds, "usprep_swap(): too few bytes (%d after header) for StringPrep .spp data\n", 870 length); 871 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; 872 return 0; 873 } 874 } 875 876 /* read the first 16 indexes (ICU 2.8/format version 3: _SPREP_INDEX_TOP==16, might grow) */ 877 for(i=0; i<16; ++i) { 878 indexes[i]=udata_readInt32(ds, inIndexes[i]); 879 } 880 881 /* calculate the total length of the data */ 882 size= 883 16*4+ /* size of indexes[] */ 884 indexes[_SPREP_INDEX_TRIE_SIZE]+ 885 indexes[_SPREP_INDEX_MAPPING_DATA_SIZE]; 886 887 if(length>=0) { 888 if(length<size) { 889 udata_printError(ds, "usprep_swap(): too few bytes (%d after header) for all of StringPrep .spp data\n", 890 length); 891 *pErrorCode=U_INDEX_OUTOFBOUNDS_ERROR; 892 return 0; 893 } 894 895 /* copy the data for inaccessible bytes */ 896 if(inBytes!=outBytes) { 897 uprv_memcpy(outBytes, inBytes, size); 898 } 899 900 offset=0; 901 902 /* swap the int32_t indexes[] */ 903 count=16*4; 904 ds->swapArray32(ds, inBytes, count, outBytes, pErrorCode); 905 offset+=count; 906 907 /* swap the UTrie */ 908 count=indexes[_SPREP_INDEX_TRIE_SIZE]; 909 utrie_swap(ds, inBytes+offset, count, outBytes+offset, pErrorCode); 910 offset+=count; 911 912 /* swap the uint16_t mappingTable[] */ 913 count=indexes[_SPREP_INDEX_MAPPING_DATA_SIZE]; 914 ds->swapArray16(ds, inBytes+offset, count, outBytes+offset, pErrorCode); 915 offset+=count; 916 } 917 918 return headerSize+size; 919 } 920 921 #endif /* #if !UCONFIG_NO_IDNA */ 922
