1 /* 2 *************************************************************************** 3 * Copyright (C) 2008-2013, International Business Machines Corporation 4 * and others. All Rights Reserved. 5 *************************************************************************** 6 * file name: uspoof.cpp 7 * encoding: US-ASCII 8 * tab size: 8 (not used) 9 * indentation:4 10 * 11 * created on: 2008Feb13 12 * created by: Andy Heninger 13 * 14 * Unicode Spoof Detection 15 */ 16 #include "unicode/utypes.h" 17 #include "unicode/normalizer2.h" 18 #include "unicode/uspoof.h" 19 #include "unicode/ustring.h" 20 #include "unicode/utf16.h" 21 #include "cmemory.h" 22 #include "cstring.h" 23 #include "identifier_info.h" 24 #include "mutex.h" 25 #include "scriptset.h" 26 #include "uassert.h" 27 #include "ucln_in.h" 28 #include "uspoof_impl.h" 29 #include "umutex.h" 30 31 32 #if !UCONFIG_NO_NORMALIZATION 33 34 U_NAMESPACE_USE 35 36 37 // 38 // Static Objects used by the spoof impl, their thread safe initialization and their cleanup. 39 // 40 static UnicodeSet *gInclusionSet = NULL; 41 static UnicodeSet *gRecommendedSet = NULL; 42 static const Normalizer2 *gNfdNormalizer = NULL; 43 static UMutex gInitMutex = U_MUTEX_INITIALIZER; 44 45 static UBool U_CALLCONV 46 uspoof_cleanup(void) { 47 delete gInclusionSet; 48 gInclusionSet = NULL; 49 delete gRecommendedSet; 50 gRecommendedSet = NULL; 51 gNfdNormalizer = NULL; 52 return TRUE; 53 } 54 55 static void initializeStatics() { 56 Mutex m(&gInitMutex); 57 UErrorCode status = U_ZERO_ERROR; 58 if (gInclusionSet == NULL) { 59 gInclusionSet = new UnicodeSet(UNICODE_STRING_SIMPLE("[\ 60 \\-.\\u00B7\\u05F3\\u05F4\\u0F0B\\u200C\\u200D\\u2019]"), status); 61 gRecommendedSet = new UnicodeSet(UNICODE_STRING_SIMPLE("[\ 62 [0-z\\u00C0-\\u017E\\u01A0\\u01A1\\u01AF\\u01B0\\u01CD-\ 63 \\u01DC\\u01DE-\\u01E3\\u01E6-\\u01F5\\u01F8-\\u021B\\u021E\ 64 \\u021F\\u0226-\\u0233\\u02BB\\u02BC\\u02EC\\u0300-\\u0304\ 65 \\u0306-\\u030C\\u030F-\\u0311\\u0313\\u0314\\u031B\\u0323-\ 66 \\u0328\\u032D\\u032E\\u0330\\u0331\\u0335\\u0338\\u0339\ 67 \\u0342-\\u0345\\u037B-\\u03CE\\u03FC-\\u045F\\u048A-\\u0525\ 68 \\u0531-\\u0586\\u05D0-\\u05F2\\u0621-\\u063F\\u0641-\\u0655\ 69 \\u0660-\\u0669\\u0670-\\u068D\\u068F-\\u06D5\\u06E5\\u06E6\ 70 \\u06EE-\\u06FF\\u0750-\\u07B1\\u0901-\\u0939\\u093C-\\u094D\ 71 \\u0950\\u0960-\\u0972\\u0979-\\u0A4D\\u0A5C-\\u0A74\\u0A81-\ 72 \\u0B43\\u0B47-\\u0B61\\u0B66-\\u0C56\\u0C60\\u0C61\\u0C66-\ 73 \\u0CD6\\u0CE0-\\u0CEF\\u0D02-\\u0D28\\u0D2A-\\u0D39\\u0D3D-\ 74 \\u0D43\\u0D46-\\u0D4D\\u0D57-\\u0D61\\u0D66-\\u0D8E\\u0D91-\ 75 \\u0DA5\\u0DA7-\\u0DDE\\u0DF2\\u0E01-\\u0ED9\\u0F00\\u0F20-\ 76 \\u0F8B\\u0F90-\\u109D\\u10D0-\\u10F0\\u10F7-\\u10FA\\u1200-\ 77 \\u135A\\u135F\\u1380-\\u138F\\u1401-\\u167F\\u1780-\\u17A2\ 78 \\u17A5-\\u17A7\\u17A9-\\u17B3\\u17B6-\\u17CA\\u17D2\\u17D7-\ 79 \\u17DC\\u17E0-\\u17E9\\u1810-\\u18A8\\u18AA-\\u18F5\\u1E00-\ 80 \\u1E99\\u1F00-\\u1FFC\\u2D30-\\u2D65\\u2D80-\\u2DDE\\u3005-\ 81 \\u3007\\u3041-\\u31B7\\u3400-\\u9FCB\\uA000-\\uA48C\\uA67F\ 82 \\uA717-\\uA71F\\uA788\\uAA60-\\uAA7B\\uAC00-\\uD7A3\\uFA0E-\ 83 \\uFA29\\U00020000-\ 84 \\U0002B734]-[[:Cn:][:nfkcqc=n:][:XIDC=n:]]]"), status); 85 gNfdNormalizer = Normalizer2::getNFDInstance(status); 86 } 87 ucln_i18n_registerCleanup(UCLN_I18N_SPOOF, uspoof_cleanup); 88 89 return; 90 } 91 92 93 U_CAPI USpoofChecker * U_EXPORT2 94 uspoof_open(UErrorCode *status) { 95 if (U_FAILURE(*status)) { 96 return NULL; 97 } 98 initializeStatics(); 99 SpoofImpl *si = new SpoofImpl(SpoofData::getDefault(*status), *status); 100 if (U_FAILURE(*status)) { 101 delete si; 102 si = NULL; 103 } 104 return reinterpret_cast<USpoofChecker *>(si); 105 } 106 107 108 U_CAPI USpoofChecker * U_EXPORT2 109 uspoof_openFromSerialized(const void *data, int32_t length, int32_t *pActualLength, 110 UErrorCode *status) { 111 if (U_FAILURE(*status)) { 112 return NULL; 113 } 114 initializeStatics(); 115 SpoofData *sd = new SpoofData(data, length, *status); 116 SpoofImpl *si = new SpoofImpl(sd, *status); 117 if (U_FAILURE(*status)) { 118 delete sd; 119 delete si; 120 return NULL; 121 } 122 if (sd == NULL || si == NULL) { 123 *status = U_MEMORY_ALLOCATION_ERROR; 124 delete sd; 125 delete si; 126 return NULL; 127 } 128 129 if (pActualLength != NULL) { 130 *pActualLength = sd->fRawData->fLength; 131 } 132 return reinterpret_cast<USpoofChecker *>(si); 133 } 134 135 136 U_CAPI USpoofChecker * U_EXPORT2 137 uspoof_clone(const USpoofChecker *sc, UErrorCode *status) { 138 const SpoofImpl *src = SpoofImpl::validateThis(sc, *status); 139 if (src == NULL) { 140 return NULL; 141 } 142 SpoofImpl *result = new SpoofImpl(*src, *status); // copy constructor 143 if (U_FAILURE(*status)) { 144 delete result; 145 result = NULL; 146 } 147 return reinterpret_cast<USpoofChecker *>(result); 148 } 149 150 151 U_CAPI void U_EXPORT2 152 uspoof_close(USpoofChecker *sc) { 153 UErrorCode status = U_ZERO_ERROR; 154 SpoofImpl *This = SpoofImpl::validateThis(sc, status); 155 delete This; 156 } 157 158 159 U_CAPI void U_EXPORT2 160 uspoof_setChecks(USpoofChecker *sc, int32_t checks, UErrorCode *status) { 161 SpoofImpl *This = SpoofImpl::validateThis(sc, *status); 162 if (This == NULL) { 163 return; 164 } 165 166 // Verify that the requested checks are all ones (bits) that 167 // are acceptable, known values. 168 if (checks & ~USPOOF_ALL_CHECKS) { 169 *status = U_ILLEGAL_ARGUMENT_ERROR; 170 return; 171 } 172 173 This->fChecks = checks; 174 } 175 176 177 U_CAPI int32_t U_EXPORT2 178 uspoof_getChecks(const USpoofChecker *sc, UErrorCode *status) { 179 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status); 180 if (This == NULL) { 181 return 0; 182 } 183 return This->fChecks; 184 } 185 186 U_CAPI void U_EXPORT2 187 uspoof_setRestrictionLevel(USpoofChecker *sc, URestrictionLevel restrictionLevel) { 188 UErrorCode status = U_ZERO_ERROR; 189 SpoofImpl *This = SpoofImpl::validateThis(sc, status); 190 if (This != NULL) { 191 This->fRestrictionLevel = restrictionLevel; 192 } 193 } 194 195 U_CAPI URestrictionLevel U_EXPORT2 196 uspoof_getRestrictionLevel(const USpoofChecker *sc) { 197 UErrorCode status = U_ZERO_ERROR; 198 const SpoofImpl *This = SpoofImpl::validateThis(sc, status); 199 if (This == NULL) { 200 return USPOOF_UNRESTRICTIVE; 201 } 202 return This->fRestrictionLevel; 203 } 204 205 U_CAPI void U_EXPORT2 206 uspoof_setAllowedLocales(USpoofChecker *sc, const char *localesList, UErrorCode *status) { 207 SpoofImpl *This = SpoofImpl::validateThis(sc, *status); 208 if (This == NULL) { 209 return; 210 } 211 This->setAllowedLocales(localesList, *status); 212 } 213 214 U_CAPI const char * U_EXPORT2 215 uspoof_getAllowedLocales(USpoofChecker *sc, UErrorCode *status) { 216 SpoofImpl *This = SpoofImpl::validateThis(sc, *status); 217 if (This == NULL) { 218 return NULL; 219 } 220 return This->getAllowedLocales(*status); 221 } 222 223 224 U_CAPI const USet * U_EXPORT2 225 uspoof_getAllowedChars(const USpoofChecker *sc, UErrorCode *status) { 226 const UnicodeSet *result = uspoof_getAllowedUnicodeSet(sc, status); 227 return result->toUSet(); 228 } 229 230 U_CAPI const UnicodeSet * U_EXPORT2 231 uspoof_getAllowedUnicodeSet(const USpoofChecker *sc, UErrorCode *status) { 232 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status); 233 if (This == NULL) { 234 return NULL; 235 } 236 return This->fAllowedCharsSet; 237 } 238 239 240 U_CAPI void U_EXPORT2 241 uspoof_setAllowedChars(USpoofChecker *sc, const USet *chars, UErrorCode *status) { 242 const UnicodeSet *set = UnicodeSet::fromUSet(chars); 243 uspoof_setAllowedUnicodeSet(sc, set, status); 244 } 245 246 247 U_CAPI void U_EXPORT2 248 uspoof_setAllowedUnicodeSet(USpoofChecker *sc, const UnicodeSet *chars, UErrorCode *status) { 249 SpoofImpl *This = SpoofImpl::validateThis(sc, *status); 250 if (This == NULL) { 251 return; 252 } 253 if (chars->isBogus()) { 254 *status = U_ILLEGAL_ARGUMENT_ERROR; 255 return; 256 } 257 UnicodeSet *clonedSet = static_cast<UnicodeSet *>(chars->clone()); 258 if (clonedSet == NULL || clonedSet->isBogus()) { 259 *status = U_MEMORY_ALLOCATION_ERROR; 260 return; 261 } 262 clonedSet->freeze(); 263 delete This->fAllowedCharsSet; 264 This->fAllowedCharsSet = clonedSet; 265 This->fChecks |= USPOOF_CHAR_LIMIT; 266 } 267 268 269 U_CAPI int32_t U_EXPORT2 270 uspoof_check(const USpoofChecker *sc, 271 const UChar *id, int32_t length, 272 int32_t *position, 273 UErrorCode *status) { 274 275 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status); 276 if (This == NULL) { 277 return 0; 278 } 279 if (length < -1) { 280 *status = U_ILLEGAL_ARGUMENT_ERROR; 281 return 0; 282 } 283 UnicodeString idStr((length == -1), id, length); // Aliasing constructor. 284 int32_t result = uspoof_checkUnicodeString(sc, idStr, position, status); 285 return result; 286 } 287 288 289 U_CAPI int32_t U_EXPORT2 290 uspoof_checkUTF8(const USpoofChecker *sc, 291 const char *id, int32_t length, 292 int32_t *position, 293 UErrorCode *status) { 294 295 if (U_FAILURE(*status)) { 296 return 0; 297 } 298 UnicodeString idStr = UnicodeString::fromUTF8(StringPiece(id, length>=0 ? length : uprv_strlen(id))); 299 int32_t result = uspoof_checkUnicodeString(sc, idStr, position, status); 300 return result; 301 } 302 303 304 U_CAPI int32_t U_EXPORT2 305 uspoof_areConfusable(const USpoofChecker *sc, 306 const UChar *id1, int32_t length1, 307 const UChar *id2, int32_t length2, 308 UErrorCode *status) { 309 SpoofImpl::validateThis(sc, *status); 310 if (U_FAILURE(*status)) { 311 return 0; 312 } 313 if (length1 < -1 || length2 < -1) { 314 *status = U_ILLEGAL_ARGUMENT_ERROR; 315 return 0; 316 } 317 318 UnicodeString id1Str((length1==-1), id1, length1); // Aliasing constructor 319 UnicodeString id2Str((length2==-1), id2, length2); // Aliasing constructor 320 return uspoof_areConfusableUnicodeString(sc, id1Str, id2Str, status); 321 } 322 323 324 U_CAPI int32_t U_EXPORT2 325 uspoof_areConfusableUTF8(const USpoofChecker *sc, 326 const char *id1, int32_t length1, 327 const char *id2, int32_t length2, 328 UErrorCode *status) { 329 SpoofImpl::validateThis(sc, *status); 330 if (U_FAILURE(*status)) { 331 return 0; 332 } 333 if (length1 < -1 || length2 < -1) { 334 *status = U_ILLEGAL_ARGUMENT_ERROR; 335 return 0; 336 } 337 UnicodeString id1Str = UnicodeString::fromUTF8(StringPiece(id1, length1>=0? length1 : uprv_strlen(id1))); 338 UnicodeString id2Str = UnicodeString::fromUTF8(StringPiece(id2, length2>=0? length2 : uprv_strlen(id2))); 339 int32_t results = uspoof_areConfusableUnicodeString(sc, id1Str, id2Str, status); 340 return results; 341 } 342 343 344 U_CAPI int32_t U_EXPORT2 345 uspoof_areConfusableUnicodeString(const USpoofChecker *sc, 346 const icu::UnicodeString &id1, 347 const icu::UnicodeString &id2, 348 UErrorCode *status) { 349 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status); 350 if (U_FAILURE(*status)) { 351 return 0; 352 } 353 // 354 // See section 4 of UAX 39 for the algorithm for checking whether two strings are confusable, 355 // and for definitions of the types (single, whole, mixed-script) of confusables. 356 357 // We only care about a few of the check flags. Ignore the others. 358 // If no tests relavant to this function have been specified, return an error. 359 // TODO: is this really the right thing to do? It's probably an error on the caller's part, 360 // but logically we would just return 0 (no error). 361 if ((This->fChecks & (USPOOF_SINGLE_SCRIPT_CONFUSABLE | USPOOF_MIXED_SCRIPT_CONFUSABLE | 362 USPOOF_WHOLE_SCRIPT_CONFUSABLE)) == 0) { 363 *status = U_INVALID_STATE_ERROR; 364 return 0; 365 } 366 int32_t flagsForSkeleton = This->fChecks & USPOOF_ANY_CASE; 367 368 int32_t result = 0; 369 IdentifierInfo *identifierInfo = This->getIdentifierInfo(*status); 370 if (U_FAILURE(*status)) { 371 return 0; 372 } 373 identifierInfo->setIdentifier(id1, *status); 374 int32_t id1ScriptCount = identifierInfo->getScriptCount(); 375 identifierInfo->setIdentifier(id2, *status); 376 int32_t id2ScriptCount = identifierInfo->getScriptCount(); 377 This->releaseIdentifierInfo(identifierInfo); 378 identifierInfo = NULL; 379 380 if (This->fChecks & USPOOF_SINGLE_SCRIPT_CONFUSABLE) { 381 UnicodeString id1Skeleton; 382 UnicodeString id2Skeleton; 383 if (id1ScriptCount <= 1 && id2ScriptCount <= 1) { 384 flagsForSkeleton |= USPOOF_SINGLE_SCRIPT_CONFUSABLE; 385 uspoof_getSkeletonUnicodeString(sc, flagsForSkeleton, id1, id1Skeleton, status); 386 uspoof_getSkeletonUnicodeString(sc, flagsForSkeleton, id2, id2Skeleton, status); 387 if (id1Skeleton == id2Skeleton) { 388 result |= USPOOF_SINGLE_SCRIPT_CONFUSABLE; 389 } 390 } 391 } 392 393 if (result & USPOOF_SINGLE_SCRIPT_CONFUSABLE) { 394 // If the two inputs are single script confusable they cannot also be 395 // mixed or whole script confusable, according to the UAX39 definitions. 396 // So we can skip those tests. 397 return result; 398 } 399 400 // Two identifiers are whole script confusable if each is of a single script 401 // and they are mixed script confusable. 402 UBool possiblyWholeScriptConfusables = 403 id1ScriptCount <= 1 && id2ScriptCount <= 1 && (This->fChecks & USPOOF_WHOLE_SCRIPT_CONFUSABLE); 404 405 // 406 // Mixed Script Check 407 // 408 if ((This->fChecks & USPOOF_MIXED_SCRIPT_CONFUSABLE) || possiblyWholeScriptConfusables ) { 409 // For getSkeleton(), resetting the USPOOF_SINGLE_SCRIPT_CONFUSABLE flag will get us 410 // the mixed script table skeleton, which is what we want. 411 // The Any Case / Lower Case bit in the skelton flags was set at the top of the function. 412 UnicodeString id1Skeleton; 413 UnicodeString id2Skeleton; 414 flagsForSkeleton &= ~USPOOF_SINGLE_SCRIPT_CONFUSABLE; 415 uspoof_getSkeletonUnicodeString(sc, flagsForSkeleton, id1, id1Skeleton, status); 416 uspoof_getSkeletonUnicodeString(sc, flagsForSkeleton, id2, id2Skeleton, status); 417 if (id1Skeleton == id2Skeleton) { 418 result |= USPOOF_MIXED_SCRIPT_CONFUSABLE; 419 if (possiblyWholeScriptConfusables) { 420 result |= USPOOF_WHOLE_SCRIPT_CONFUSABLE; 421 } 422 } 423 } 424 425 return result; 426 } 427 428 429 430 431 U_CAPI int32_t U_EXPORT2 432 uspoof_checkUnicodeString(const USpoofChecker *sc, 433 const icu::UnicodeString &id, 434 int32_t *position, 435 UErrorCode *status) { 436 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status); 437 if (This == NULL) { 438 return 0; 439 } 440 int32_t result = 0; 441 442 IdentifierInfo *identifierInfo = NULL; 443 if ((This->fChecks) & (USPOOF_RESTRICTION_LEVEL | USPOOF_MIXED_NUMBERS)) { 444 identifierInfo = This->getIdentifierInfo(*status); 445 if (U_FAILURE(*status)) { 446 goto cleanupAndReturn; 447 } 448 identifierInfo->setIdentifier(id, *status); 449 identifierInfo->setIdentifierProfile(*This->fAllowedCharsSet); 450 } 451 452 453 if ((This->fChecks) & USPOOF_RESTRICTION_LEVEL) { 454 URestrictionLevel idRestrictionLevel = identifierInfo->getRestrictionLevel(*status); 455 if (idRestrictionLevel > This->fRestrictionLevel) { 456 result |= USPOOF_RESTRICTION_LEVEL; 457 } 458 if (This->fChecks & USPOOF_AUX_INFO) { 459 result |= idRestrictionLevel; 460 } 461 } 462 463 if ((This->fChecks) & USPOOF_MIXED_NUMBERS) { 464 const UnicodeSet *numerics = identifierInfo->getNumerics(); 465 if (numerics->size() > 1) { 466 result |= USPOOF_MIXED_NUMBERS; 467 } 468 469 // TODO: ICU4J returns the UnicodeSet of the numerics found in the identifier. 470 // We have no easy way to do the same in C. 471 // if (checkResult != null) { 472 // checkResult.numerics = numerics; 473 // } 474 } 475 476 477 if (This->fChecks & (USPOOF_CHAR_LIMIT)) { 478 int32_t i; 479 UChar32 c; 480 int32_t length = id.length(); 481 for (i=0; i<length ;) { 482 c = id.char32At(i); 483 i += U16_LENGTH(c); 484 if (!This->fAllowedCharsSet->contains(c)) { 485 result |= USPOOF_CHAR_LIMIT; 486 break; 487 } 488 } 489 } 490 491 if (This->fChecks & 492 (USPOOF_WHOLE_SCRIPT_CONFUSABLE | USPOOF_MIXED_SCRIPT_CONFUSABLE | USPOOF_INVISIBLE)) { 493 // These are the checks that need to be done on NFD input 494 UnicodeString nfdText; 495 gNfdNormalizer->normalize(id, nfdText, *status); 496 int32_t nfdLength = nfdText.length(); 497 498 if (This->fChecks & USPOOF_INVISIBLE) { 499 500 // scan for more than one occurence of the same non-spacing mark 501 // in a sequence of non-spacing marks. 502 int32_t i; 503 UChar32 c; 504 UChar32 firstNonspacingMark = 0; 505 UBool haveMultipleMarks = FALSE; 506 UnicodeSet marksSeenSoFar; // Set of combining marks in a single combining sequence. 507 508 for (i=0; i<nfdLength ;) { 509 c = nfdText.char32At(i); 510 i += U16_LENGTH(c); 511 if (u_charType(c) != U_NON_SPACING_MARK) { 512 firstNonspacingMark = 0; 513 if (haveMultipleMarks) { 514 marksSeenSoFar.clear(); 515 haveMultipleMarks = FALSE; 516 } 517 continue; 518 } 519 if (firstNonspacingMark == 0) { 520 firstNonspacingMark = c; 521 continue; 522 } 523 if (!haveMultipleMarks) { 524 marksSeenSoFar.add(firstNonspacingMark); 525 haveMultipleMarks = TRUE; 526 } 527 if (marksSeenSoFar.contains(c)) { 528 // report the error, and stop scanning. 529 // No need to find more than the first failure. 530 result |= USPOOF_INVISIBLE; 531 break; 532 } 533 marksSeenSoFar.add(c); 534 } 535 } 536 537 538 if (This->fChecks & (USPOOF_WHOLE_SCRIPT_CONFUSABLE | USPOOF_MIXED_SCRIPT_CONFUSABLE)) { 539 // The basic test is the same for both whole and mixed script confusables. 540 // Compute the set of scripts that every input character has a confusable in. 541 // For this computation an input character is always considered to be 542 // confusable with itself in its own script. 543 // 544 // If the number of such scripts is two or more, and the input consisted of 545 // characters all from a single script, we have a whole script confusable. 546 // (The two scripts will be the original script and the one that is confusable) 547 // 548 // If the number of such scripts >= one, and the original input contained characters from 549 // more than one script, we have a mixed script confusable. (We can transform 550 // some of the characters, and end up with a visually similar string all in 551 // one script.) 552 553 if (identifierInfo == NULL) { 554 identifierInfo = This->getIdentifierInfo(*status); 555 if (U_FAILURE(*status)) { 556 goto cleanupAndReturn; 557 } 558 identifierInfo->setIdentifier(id, *status); 559 } 560 561 int32_t scriptCount = identifierInfo->getScriptCount(); 562 563 ScriptSet scripts; 564 This->wholeScriptCheck(nfdText, &scripts, *status); 565 int32_t confusableScriptCount = scripts.countMembers(); 566 //printf("confusableScriptCount = %d\n", confusableScriptCount); 567 568 if ((This->fChecks & USPOOF_WHOLE_SCRIPT_CONFUSABLE) && 569 confusableScriptCount >= 2 && 570 scriptCount == 1) { 571 result |= USPOOF_WHOLE_SCRIPT_CONFUSABLE; 572 } 573 574 if ((This->fChecks & USPOOF_MIXED_SCRIPT_CONFUSABLE) && 575 confusableScriptCount >= 1 && 576 scriptCount > 1) { 577 result |= USPOOF_MIXED_SCRIPT_CONFUSABLE; 578 } 579 } 580 } 581 582 cleanupAndReturn: 583 This->releaseIdentifierInfo(identifierInfo); 584 if (position != NULL) { 585 *position = 0; 586 } 587 return result; 588 } 589 590 591 U_CAPI int32_t U_EXPORT2 592 uspoof_getSkeleton(const USpoofChecker *sc, 593 uint32_t type, 594 const UChar *id, int32_t length, 595 UChar *dest, int32_t destCapacity, 596 UErrorCode *status) { 597 598 SpoofImpl::validateThis(sc, *status); 599 if (U_FAILURE(*status)) { 600 return 0; 601 } 602 if (length<-1 || destCapacity<0 || (destCapacity==0 && dest!=NULL)) { 603 *status = U_ILLEGAL_ARGUMENT_ERROR; 604 return 0; 605 } 606 607 UnicodeString idStr((length==-1), id, length); // Aliasing constructor 608 UnicodeString destStr; 609 uspoof_getSkeletonUnicodeString(sc, type, idStr, destStr, status); 610 destStr.extract(dest, destCapacity, *status); 611 return destStr.length(); 612 } 613 614 615 616 U_I18N_API UnicodeString & U_EXPORT2 617 uspoof_getSkeletonUnicodeString(const USpoofChecker *sc, 618 uint32_t type, 619 const UnicodeString &id, 620 UnicodeString &dest, 621 UErrorCode *status) { 622 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status); 623 if (U_FAILURE(*status)) { 624 return dest; 625 } 626 627 int32_t tableMask = 0; 628 switch (type) { 629 case 0: 630 tableMask = USPOOF_ML_TABLE_FLAG; 631 break; 632 case USPOOF_SINGLE_SCRIPT_CONFUSABLE: 633 tableMask = USPOOF_SL_TABLE_FLAG; 634 break; 635 case USPOOF_ANY_CASE: 636 tableMask = USPOOF_MA_TABLE_FLAG; 637 break; 638 case USPOOF_SINGLE_SCRIPT_CONFUSABLE | USPOOF_ANY_CASE: 639 tableMask = USPOOF_SA_TABLE_FLAG; 640 break; 641 default: 642 *status = U_ILLEGAL_ARGUMENT_ERROR; 643 return dest; 644 } 645 646 UnicodeString nfdId; 647 gNfdNormalizer->normalize(id, nfdId, *status); 648 649 // Apply the skeleton mapping to the NFD normalized input string 650 // Accumulate the skeleton, possibly unnormalized, in a UnicodeString. 651 int32_t inputIndex = 0; 652 UnicodeString skelStr; 653 int32_t normalizedLen = nfdId.length(); 654 for (inputIndex=0; inputIndex < normalizedLen; ) { 655 UChar32 c = nfdId.char32At(inputIndex); 656 inputIndex += U16_LENGTH(c); 657 This->confusableLookup(c, tableMask, skelStr); 658 } 659 660 gNfdNormalizer->normalize(skelStr, dest, *status); 661 return dest; 662 } 663 664 665 U_CAPI int32_t U_EXPORT2 666 uspoof_getSkeletonUTF8(const USpoofChecker *sc, 667 uint32_t type, 668 const char *id, int32_t length, 669 char *dest, int32_t destCapacity, 670 UErrorCode *status) { 671 SpoofImpl::validateThis(sc, *status); 672 if (U_FAILURE(*status)) { 673 return 0; 674 } 675 if (length<-1 || destCapacity<0 || (destCapacity==0 && dest!=NULL)) { 676 *status = U_ILLEGAL_ARGUMENT_ERROR; 677 return 0; 678 } 679 680 UnicodeString srcStr = UnicodeString::fromUTF8(StringPiece(id, length>=0 ? length : uprv_strlen(id))); 681 UnicodeString destStr; 682 uspoof_getSkeletonUnicodeString(sc, type, srcStr, destStr, status); 683 if (U_FAILURE(*status)) { 684 return 0; 685 } 686 687 int32_t lengthInUTF8 = 0; 688 u_strToUTF8(dest, destCapacity, &lengthInUTF8, 689 destStr.getBuffer(), destStr.length(), status); 690 return lengthInUTF8; 691 } 692 693 694 U_CAPI int32_t U_EXPORT2 695 uspoof_serialize(USpoofChecker *sc,void *buf, int32_t capacity, UErrorCode *status) { 696 SpoofImpl *This = SpoofImpl::validateThis(sc, *status); 697 if (This == NULL) { 698 U_ASSERT(U_FAILURE(*status)); 699 return 0; 700 } 701 int32_t dataSize = This->fSpoofData->fRawData->fLength; 702 if (capacity < dataSize) { 703 *status = U_BUFFER_OVERFLOW_ERROR; 704 return dataSize; 705 } 706 uprv_memcpy(buf, This->fSpoofData->fRawData, dataSize); 707 return dataSize; 708 } 709 710 U_CAPI const USet * U_EXPORT2 711 uspoof_getInclusionSet(UErrorCode *) { 712 initializeStatics(); 713 return gInclusionSet->toUSet(); 714 } 715 716 U_CAPI const USet * U_EXPORT2 717 uspoof_getRecommendedSet(UErrorCode *) { 718 initializeStatics(); 719 return gRecommendedSet->toUSet(); 720 } 721 722 U_I18N_API const UnicodeSet * U_EXPORT2 723 uspoof_getInclusionUnicodeSet(UErrorCode *) { 724 initializeStatics(); 725 return gInclusionSet; 726 } 727 728 U_I18N_API const UnicodeSet * U_EXPORT2 729 uspoof_getRecommendedUnicodeSet(UErrorCode *) { 730 initializeStatics(); 731 return gRecommendedSet; 732 } 733 734 735 736 #endif // !UCONFIG_NO_NORMALIZATION 737
