The Tor Browser / file comparison

comparison: intl/icu/source/common/usprep.cpp

intl/icu/source/common/usprep.cpp

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial