1 // © 2016 and later: Unicode, Inc. and others.
2 // License & terms of use: http://www.unicode.org/copyright.html
4 ***************************************************************************
5 * Copyright (C) 2008-2015, International Business Machines Corporation
6 * and others. All Rights Reserved.
7 ***************************************************************************
8 * file name: uspoof.cpp
10 * tab size: 8 (not used)
13 * created on: 2008Feb13
14 * created by: Andy Heninger
16 * Unicode Spoof Detection
18 #include "unicode/utypes.h"
19 #include "unicode/normalizer2.h"
20 #include "unicode/uspoof.h"
21 #include "unicode/ustring.h"
22 #include "unicode/utf16.h"
26 #include "scriptset.h"
29 #include "uspoof_impl.h"
33 #if !UCONFIG_NO_NORMALIZATION
39 // Static Objects used by the spoof impl, their thread safe initialization and their cleanup.
41 static UnicodeSet
*gInclusionSet
= NULL
;
42 static UnicodeSet
*gRecommendedSet
= NULL
;
43 static const Normalizer2
*gNfdNormalizer
= NULL
;
44 static UInitOnce gSpoofInitStaticsOnce
= U_INITONCE_INITIALIZER
;
49 uspoof_cleanup(void) {
52 delete gRecommendedSet
;
53 gRecommendedSet
= NULL
;
54 gNfdNormalizer
= NULL
;
55 gSpoofInitStaticsOnce
.reset();
59 void U_CALLCONV
initializeStatics(UErrorCode
&status
) {
60 static const char16_t *inclusionPat
=
61 u
"['\\-.\\:\\u00B7\\u0375\\u058A\\u05F3\\u05F4\\u06FD\\u06FE\\u0F0B\\u200C"
62 u
"\\u200D\\u2010\\u2019\\u2027\\u30A0\\u30FB]";
63 gInclusionSet
= new UnicodeSet(UnicodeString(inclusionPat
), status
);
64 if (gInclusionSet
== NULL
) {
65 status
= U_MEMORY_ALLOCATION_ERROR
;
68 gInclusionSet
->freeze();
70 // Note: data from IdentifierStatus.txt & IdentifierType.txt
71 // There is tooling to generate this constant in the unicodetools project:
72 // org.unicode.text.tools.RecommendedSetGenerator
73 // It will print the Java and C++ code to the console for easy copy-paste into this file.
74 static const char16_t *recommendedPat
=
75 u
"[0-9A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u0131\\u0134-\\u013E"
76 u
"\\u0141-\\u0148\\u014A-\\u017E\\u018F\\u01A0\\u01A1\\u01AF\\u01B0\\u01CD-"
77 u
"\\u01DC\\u01DE-\\u01E3\\u01E6-\\u01F0\\u01F4\\u01F5\\u01F8-\\u021B\\u021E"
78 u
"\\u021F\\u0226-\\u0233\\u0259\\u02BB\\u02BC\\u02EC\\u0300-\\u0304\\u0306-"
79 u
"\\u030C\\u030F-\\u0311\\u0313\\u0314\\u031B\\u0323-\\u0328\\u032D\\u032E"
80 u
"\\u0330\\u0331\\u0335\\u0338\\u0339\\u0342\\u0345\\u037B-\\u037D\\u0386"
81 u
"\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03CE\\u03FC-\\u045F\\u048A-"
82 u
"\\u0529\\u052E\\u052F\\u0531-\\u0556\\u0559\\u0560-\\u0586\\u0588\\u05B4"
83 u
"\\u05D0-\\u05EA\\u05EF-\\u05F2\\u0620-\\u063F\\u0641-\\u0655\\u0660-\\u0669"
84 u
"\\u0670-\\u0672\\u0674\\u0679-\\u068D\\u068F-\\u06D3\\u06D5\\u06E5\\u06E6"
85 u
"\\u06EE-\\u06FC\\u06FF\\u0750-\\u07B1\\u08A0-\\u08AC\\u08B2\\u08B6-\\u08BD"
86 u
"\\u0901-\\u094D\\u094F\\u0950\\u0956\\u0957\\u0960-\\u0963\\u0966-\\u096F"
87 u
"\\u0971-\\u0977\\u0979-\\u097F\\u0981-\\u0983\\u0985-\\u098C\\u098F\\u0990"
88 u
"\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BC-\\u09C4\\u09C7"
89 u
"\\u09C8\\u09CB-\\u09CE\\u09D7\\u09E0-\\u09E3\\u09E6-\\u09F1\\u09FC\\u09FE"
90 u
"\\u0A01-\\u0A03\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30"
91 u
"\\u0A32\\u0A35\\u0A38\\u0A39\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-"
92 u
"\\u0A4D\\u0A5C\\u0A66-\\u0A74\\u0A81-\\u0A83\\u0A85-\\u0A8D\\u0A8F-\\u0A91"
93 u
"\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABC-\\u0AC5"
94 u
"\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0AD0\\u0AE0-\\u0AE3\\u0AE6-\\u0AEF\\u0AFA-"
95 u
"\\u0AFF\\u0B01-\\u0B03\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-"
96 u
"\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3C-\\u0B43\\u0B47\\u0B48\\u0B4B-"
97 u
"\\u0B4D\\u0B56\\u0B57\\u0B5F-\\u0B61\\u0B66-\\u0B6F\\u0B71\\u0B82\\u0B83"
98 u
"\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E"
99 u
"\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BBE-\\u0BC2\\u0BC6-"
100 u
"\\u0BC8\\u0BCA-\\u0BCD\\u0BD0\\u0BD7\\u0BE6-\\u0BEF\\u0C01-\\u0C0C\\u0C0E-"
101 u
"\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C33\\u0C35-\\u0C39\\u0C3D-\\u0C44\\u0C46-"
102 u
"\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C60\\u0C61\\u0C66-\\u0C6F\\u0C80"
103 u
"\\u0C82\\u0C83\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3"
104 u
"\\u0CB5-\\u0CB9\\u0CBC-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6"
105 u
"\\u0CE0-\\u0CE3\\u0CE6-\\u0CEF\\u0CF1\\u0CF2\\u0D00\\u0D02\\u0D03\\u0D05-"
106 u
"\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D43\\u0D46-\\u0D48\\u0D4A-\\u0D4E\\u0D54-"
107 u
"\\u0D57\\u0D60\\u0D61\\u0D66-\\u0D6F\\u0D7A-\\u0D7F\\u0D82\\u0D83\\u0D85-"
108 u
"\\u0D8E\\u0D91-\\u0D96\\u0D9A-\\u0DA5\\u0DA7-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD"
109 u
"\\u0DC0-\\u0DC6\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDE\\u0DF2\\u0E01-"
110 u
"\\u0E32\\u0E34-\\u0E3A\\u0E40-\\u0E4E\\u0E50-\\u0E59\\u0E81\\u0E82\\u0E84"
111 u
"\\u0E86-\\u0E8A\\u0E8C-\\u0EA3\\u0EA5\\u0EA7-\\u0EB2\\u0EB4-\\u0EBD\\u0EC0-"
112 u
"\\u0EC4\\u0EC6\\u0EC8-\\u0ECD\\u0ED0-\\u0ED9\\u0EDE\\u0EDF\\u0F00\\u0F20-"
113 u
"\\u0F29\\u0F35\\u0F37\\u0F3E-\\u0F42\\u0F44-\\u0F47\\u0F49-\\u0F4C\\u0F4E-"
114 u
"\\u0F51\\u0F53-\\u0F56\\u0F58-\\u0F5B\\u0F5D-\\u0F68\\u0F6A-\\u0F6C\\u0F71"
115 u
"\\u0F72\\u0F74\\u0F7A-\\u0F80\\u0F82-\\u0F84\\u0F86-\\u0F92\\u0F94-\\u0F97"
116 u
"\\u0F99-\\u0F9C\\u0F9E-\\u0FA1\\u0FA3-\\u0FA6\\u0FA8-\\u0FAB\\u0FAD-\\u0FB8"
117 u
"\\u0FBA-\\u0FBC\\u0FC6\\u1000-\\u1049\\u1050-\\u109D\\u10C7\\u10CD\\u10D0-"
118 u
"\\u10F0\\u10F7-\\u10FA\\u10FD-\\u10FF\\u1200-\\u1248\\u124A-\\u124D\\u1250-"
119 u
"\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0"
120 u
"\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-"
121 u
"\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u135D-\\u135F\\u1380-\\u138F\\u1780-"
122 u
"\\u17A2\\u17A5-\\u17A7\\u17A9-\\u17B3\\u17B6-\\u17CA\\u17D2\\u17D7\\u17DC"
123 u
"\\u17E0-\\u17E9\\u1C80-\\u1C88\\u1C90-\\u1CBA\\u1CBD-\\u1CBF\\u1E00-\\u1E99"
124 u
"\\u1E9E\\u1EA0-\\u1EF9\\u1F00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-"
125 u
"\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F70\\u1F72\\u1F74"
126 u
"\\u1F76\\u1F78\\u1F7A\\u1F7C\\u1F80-\\u1FB4\\u1FB6-\\u1FBA\\u1FBC\\u1FC2-"
127 u
"\\u1FC4\\u1FC6-\\u1FC8\\u1FCA\\u1FCC\\u1FD0-\\u1FD2\\u1FD6-\\u1FDA\\u1FE0-"
128 u
"\\u1FE2\\u1FE4-\\u1FEA\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FF8\\u1FFA\\u1FFC"
129 u
"\\u2D27\\u2D2D\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6"
130 u
"\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE"
131 u
"\\u3005-\\u3007\\u3041-\\u3096\\u3099\\u309A\\u309D\\u309E\\u30A1-\\u30FA"
132 u
"\\u30FC-\\u30FE\\u3105-\\u312F\\u31A0-\\u31BA\\u3400-\\u4DB5\\u4E00-\\u9FEF"
133 u
"\\uA660\\uA661\\uA674-\\uA67B\\uA67F\\uA69F\\uA717-\\uA71F\\uA788\\uA78D"
134 u
"\\uA78E\\uA790-\\uA793\\uA7A0-\\uA7AA\\uA7AE\\uA7AF\\uA7B8-\\uA7BF\\uA7C2-"
135 u
"\\uA7C6\\uA7FA\\uA9E7-\\uA9FE\\uAA60-\\uAA76\\uAA7A-\\uAA7F\\uAB01-\\uAB06"
136 u
"\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB66\\uAB67"
137 u
"\\uAC00-\\uD7A3\\uFA0E\\uFA0F\\uFA11\\uFA13\\uFA14\\uFA1F\\uFA21\\uFA23"
138 u
"\\uFA24\\uFA27-\\uFA29\\U0001133B\\U0001B150-\\U0001B152\\U0001B164-"
139 u
"\\U0001B167\\U00020000-\\U0002A6D6\\U0002A700-\\U0002B734\\U0002B740-"
140 u
"\\U0002B81D\\U0002B820-\\U0002CEA1\\U0002CEB0-\\U0002EBE0]";
142 gRecommendedSet
= new UnicodeSet(UnicodeString(recommendedPat
), status
);
143 if (gRecommendedSet
== NULL
) {
144 status
= U_MEMORY_ALLOCATION_ERROR
;
145 delete gInclusionSet
;
148 gRecommendedSet
->freeze();
149 gNfdNormalizer
= Normalizer2::getNFDInstance(status
);
150 ucln_i18n_registerCleanup(UCLN_I18N_SPOOF
, uspoof_cleanup
);
155 U_CFUNC
void uspoof_internalInitStatics(UErrorCode
*status
) {
156 umtx_initOnce(gSpoofInitStaticsOnce
, &initializeStatics
, *status
);
159 U_CAPI USpoofChecker
* U_EXPORT2
160 uspoof_open(UErrorCode
*status
) {
161 umtx_initOnce(gSpoofInitStaticsOnce
, &initializeStatics
, *status
);
162 if (U_FAILURE(*status
)) {
165 SpoofImpl
*si
= new SpoofImpl(*status
);
167 *status
= U_MEMORY_ALLOCATION_ERROR
;
170 if (U_FAILURE(*status
)) {
174 return si
->asUSpoofChecker();
178 U_CAPI USpoofChecker
* U_EXPORT2
179 uspoof_openFromSerialized(const void *data
, int32_t length
, int32_t *pActualLength
,
180 UErrorCode
*status
) {
181 if (U_FAILURE(*status
)) {
186 *status
= U_ILLEGAL_ARGUMENT_ERROR
;
190 umtx_initOnce(gSpoofInitStaticsOnce
, &initializeStatics
, *status
);
191 if (U_FAILURE(*status
))
196 SpoofData
*sd
= new SpoofData(data
, length
, *status
);
198 *status
= U_MEMORY_ALLOCATION_ERROR
;
202 if (U_FAILURE(*status
)) {
207 SpoofImpl
*si
= new SpoofImpl(sd
, *status
);
209 *status
= U_MEMORY_ALLOCATION_ERROR
;
210 delete sd
; // explicit delete as the destructor for si won't be called.
214 if (U_FAILURE(*status
)) {
215 delete si
; // no delete for sd, as the si destructor will delete it.
219 if (pActualLength
!= NULL
) {
220 *pActualLength
= sd
->size();
222 return si
->asUSpoofChecker();
226 U_CAPI USpoofChecker
* U_EXPORT2
227 uspoof_clone(const USpoofChecker
*sc
, UErrorCode
*status
) {
228 const SpoofImpl
*src
= SpoofImpl::validateThis(sc
, *status
);
232 SpoofImpl
*result
= new SpoofImpl(*src
, *status
); // copy constructor
233 if (result
== NULL
) {
234 *status
= U_MEMORY_ALLOCATION_ERROR
;
237 if (U_FAILURE(*status
)) {
241 return result
->asUSpoofChecker();
245 U_CAPI
void U_EXPORT2
246 uspoof_close(USpoofChecker
*sc
) {
247 UErrorCode status
= U_ZERO_ERROR
;
248 SpoofImpl
*This
= SpoofImpl::validateThis(sc
, status
);
253 U_CAPI
void U_EXPORT2
254 uspoof_setChecks(USpoofChecker
*sc
, int32_t checks
, UErrorCode
*status
) {
255 SpoofImpl
*This
= SpoofImpl::validateThis(sc
, *status
);
260 // Verify that the requested checks are all ones (bits) that
261 // are acceptable, known values.
262 if (checks
& ~(USPOOF_ALL_CHECKS
| USPOOF_AUX_INFO
)) {
263 *status
= U_ILLEGAL_ARGUMENT_ERROR
;
267 This
->fChecks
= checks
;
271 U_CAPI
int32_t U_EXPORT2
272 uspoof_getChecks(const USpoofChecker
*sc
, UErrorCode
*status
) {
273 const SpoofImpl
*This
= SpoofImpl::validateThis(sc
, *status
);
277 return This
->fChecks
;
280 U_CAPI
void U_EXPORT2
281 uspoof_setRestrictionLevel(USpoofChecker
*sc
, URestrictionLevel restrictionLevel
) {
282 UErrorCode status
= U_ZERO_ERROR
;
283 SpoofImpl
*This
= SpoofImpl::validateThis(sc
, status
);
285 This
->fRestrictionLevel
= restrictionLevel
;
286 This
->fChecks
|= USPOOF_RESTRICTION_LEVEL
;
290 U_CAPI URestrictionLevel U_EXPORT2
291 uspoof_getRestrictionLevel(const USpoofChecker
*sc
) {
292 UErrorCode status
= U_ZERO_ERROR
;
293 const SpoofImpl
*This
= SpoofImpl::validateThis(sc
, status
);
295 return USPOOF_UNRESTRICTIVE
;
297 return This
->fRestrictionLevel
;
300 U_CAPI
void U_EXPORT2
301 uspoof_setAllowedLocales(USpoofChecker
*sc
, const char *localesList
, UErrorCode
*status
) {
302 SpoofImpl
*This
= SpoofImpl::validateThis(sc
, *status
);
306 This
->setAllowedLocales(localesList
, *status
);
309 U_CAPI
const char * U_EXPORT2
310 uspoof_getAllowedLocales(USpoofChecker
*sc
, UErrorCode
*status
) {
311 SpoofImpl
*This
= SpoofImpl::validateThis(sc
, *status
);
315 return This
->getAllowedLocales(*status
);
319 U_CAPI
const USet
* U_EXPORT2
320 uspoof_getAllowedChars(const USpoofChecker
*sc
, UErrorCode
*status
) {
321 const UnicodeSet
*result
= uspoof_getAllowedUnicodeSet(sc
, status
);
322 return result
->toUSet();
325 U_CAPI
const UnicodeSet
* U_EXPORT2
326 uspoof_getAllowedUnicodeSet(const USpoofChecker
*sc
, UErrorCode
*status
) {
327 const SpoofImpl
*This
= SpoofImpl::validateThis(sc
, *status
);
331 return This
->fAllowedCharsSet
;
335 U_CAPI
void U_EXPORT2
336 uspoof_setAllowedChars(USpoofChecker
*sc
, const USet
*chars
, UErrorCode
*status
) {
337 const UnicodeSet
*set
= UnicodeSet::fromUSet(chars
);
338 uspoof_setAllowedUnicodeSet(sc
, set
, status
);
342 U_CAPI
void U_EXPORT2
343 uspoof_setAllowedUnicodeSet(USpoofChecker
*sc
, const UnicodeSet
*chars
, UErrorCode
*status
) {
344 SpoofImpl
*This
= SpoofImpl::validateThis(sc
, *status
);
348 if (chars
->isBogus()) {
349 *status
= U_ILLEGAL_ARGUMENT_ERROR
;
352 UnicodeSet
*clonedSet
= static_cast<UnicodeSet
*>(chars
->clone());
353 if (clonedSet
== NULL
|| clonedSet
->isBogus()) {
354 *status
= U_MEMORY_ALLOCATION_ERROR
;
358 delete This
->fAllowedCharsSet
;
359 This
->fAllowedCharsSet
= clonedSet
;
360 This
->fChecks
|= USPOOF_CHAR_LIMIT
;
364 U_CAPI
int32_t U_EXPORT2
365 uspoof_check(const USpoofChecker
*sc
,
366 const UChar
*id
, int32_t length
,
368 UErrorCode
*status
) {
370 // Backwards compatibility:
371 if (position
!= NULL
) {
375 // Delegate to uspoof_check2
376 return uspoof_check2(sc
, id
, length
, NULL
, status
);
380 U_CAPI
int32_t U_EXPORT2
381 uspoof_check2(const USpoofChecker
*sc
,
382 const UChar
* id
, int32_t length
,
383 USpoofCheckResult
* checkResult
,
384 UErrorCode
*status
) {
386 const SpoofImpl
*This
= SpoofImpl::validateThis(sc
, *status
);
391 *status
= U_ILLEGAL_ARGUMENT_ERROR
;
394 UnicodeString
idStr((length
== -1), id
, length
); // Aliasing constructor.
395 int32_t result
= uspoof_check2UnicodeString(sc
, idStr
, checkResult
, status
);
400 U_CAPI
int32_t U_EXPORT2
401 uspoof_checkUTF8(const USpoofChecker
*sc
,
402 const char *id
, int32_t length
,
404 UErrorCode
*status
) {
406 // Backwards compatibility:
407 if (position
!= NULL
) {
411 // Delegate to uspoof_check2
412 return uspoof_check2UTF8(sc
, id
, length
, NULL
, status
);
416 U_CAPI
int32_t U_EXPORT2
417 uspoof_check2UTF8(const USpoofChecker
*sc
,
418 const char *id
, int32_t length
,
419 USpoofCheckResult
* checkResult
,
420 UErrorCode
*status
) {
422 if (U_FAILURE(*status
)) {
425 UnicodeString idStr
= UnicodeString::fromUTF8(StringPiece(id
, length
>=0 ? length
: static_cast<int32_t>(uprv_strlen(id
))));
426 int32_t result
= uspoof_check2UnicodeString(sc
, idStr
, checkResult
, status
);
431 U_CAPI
int32_t U_EXPORT2
432 uspoof_areConfusable(const USpoofChecker
*sc
,
433 const UChar
*id1
, int32_t length1
,
434 const UChar
*id2
, int32_t length2
,
435 UErrorCode
*status
) {
436 SpoofImpl::validateThis(sc
, *status
);
437 if (U_FAILURE(*status
)) {
440 if (length1
< -1 || length2
< -1) {
441 *status
= U_ILLEGAL_ARGUMENT_ERROR
;
445 UnicodeString
id1Str((length1
==-1), id1
, length1
); // Aliasing constructor
446 UnicodeString
id2Str((length2
==-1), id2
, length2
); // Aliasing constructor
447 return uspoof_areConfusableUnicodeString(sc
, id1Str
, id2Str
, status
);
451 U_CAPI
int32_t U_EXPORT2
452 uspoof_areConfusableUTF8(const USpoofChecker
*sc
,
453 const char *id1
, int32_t length1
,
454 const char *id2
, int32_t length2
,
455 UErrorCode
*status
) {
456 SpoofImpl::validateThis(sc
, *status
);
457 if (U_FAILURE(*status
)) {
460 if (length1
< -1 || length2
< -1) {
461 *status
= U_ILLEGAL_ARGUMENT_ERROR
;
464 UnicodeString id1Str
= UnicodeString::fromUTF8(StringPiece(id1
, length1
>=0? length1
: static_cast<int32_t>(uprv_strlen(id1
))));
465 UnicodeString id2Str
= UnicodeString::fromUTF8(StringPiece(id2
, length2
>=0? length2
: static_cast<int32_t>(uprv_strlen(id2
))));
466 int32_t results
= uspoof_areConfusableUnicodeString(sc
, id1Str
, id2Str
, status
);
471 U_CAPI
int32_t U_EXPORT2
472 uspoof_areConfusableUnicodeString(const USpoofChecker
*sc
,
473 const icu::UnicodeString
&id1
,
474 const icu::UnicodeString
&id2
,
475 UErrorCode
*status
) {
476 const SpoofImpl
*This
= SpoofImpl::validateThis(sc
, *status
);
477 if (U_FAILURE(*status
)) {
481 // See section 4 of UAX 39 for the algorithm for checking whether two strings are confusable,
482 // and for definitions of the types (single, whole, mixed-script) of confusables.
484 // We only care about a few of the check flags. Ignore the others.
485 // If no tests relavant to this function have been specified, return an error.
486 // TODO: is this really the right thing to do? It's probably an error on the caller's part,
487 // but logically we would just return 0 (no error).
488 if ((This
->fChecks
& USPOOF_CONFUSABLE
) == 0) {
489 *status
= U_INVALID_STATE_ERROR
;
493 // Compute the skeletons and check for confusability.
494 UnicodeString id1Skeleton
;
495 uspoof_getSkeletonUnicodeString(sc
, 0 /* deprecated */, id1
, id1Skeleton
, status
);
496 UnicodeString id2Skeleton
;
497 uspoof_getSkeletonUnicodeString(sc
, 0 /* deprecated */, id2
, id2Skeleton
, status
);
498 if (U_FAILURE(*status
)) { return 0; }
499 if (id1Skeleton
!= id2Skeleton
) {
503 // If we get here, the strings are confusable. Now we just need to set the flags for the appropriate classes
504 // of confusables according to UTS 39 section 4.
505 // Start by computing the resolved script sets of id1 and id2.
507 This
->getResolvedScriptSet(id1
, id1RSS
, *status
);
509 This
->getResolvedScriptSet(id2
, id2RSS
, *status
);
511 // Turn on all applicable flags
513 if (id1RSS
.intersects(id2RSS
)) {
514 result
|= USPOOF_SINGLE_SCRIPT_CONFUSABLE
;
516 result
|= USPOOF_MIXED_SCRIPT_CONFUSABLE
;
517 if (!id1RSS
.isEmpty() && !id2RSS
.isEmpty()) {
518 result
|= USPOOF_WHOLE_SCRIPT_CONFUSABLE
;
522 // Turn off flags that the user doesn't want
523 if ((This
->fChecks
& USPOOF_SINGLE_SCRIPT_CONFUSABLE
) == 0) {
524 result
&= ~USPOOF_SINGLE_SCRIPT_CONFUSABLE
;
526 if ((This
->fChecks
& USPOOF_MIXED_SCRIPT_CONFUSABLE
) == 0) {
527 result
&= ~USPOOF_MIXED_SCRIPT_CONFUSABLE
;
529 if ((This
->fChecks
& USPOOF_WHOLE_SCRIPT_CONFUSABLE
) == 0) {
530 result
&= ~USPOOF_WHOLE_SCRIPT_CONFUSABLE
;
537 U_CAPI
int32_t U_EXPORT2
538 uspoof_checkUnicodeString(const USpoofChecker
*sc
,
539 const icu::UnicodeString
&id
,
541 UErrorCode
*status
) {
543 // Backwards compatibility:
544 if (position
!= NULL
) {
548 // Delegate to uspoof_check2
549 return uspoof_check2UnicodeString(sc
, id
, NULL
, status
);
554 int32_t checkImpl(const SpoofImpl
* This
, const UnicodeString
& id
, CheckResult
* checkResult
, UErrorCode
* status
) {
555 U_ASSERT(This
!= NULL
);
556 U_ASSERT(checkResult
!= NULL
);
557 checkResult
->clear();
560 if (0 != (This
->fChecks
& USPOOF_RESTRICTION_LEVEL
)) {
561 URestrictionLevel idRestrictionLevel
= This
->getRestrictionLevel(id
, *status
);
562 if (idRestrictionLevel
> This
->fRestrictionLevel
) {
563 result
|= USPOOF_RESTRICTION_LEVEL
;
565 checkResult
->fRestrictionLevel
= idRestrictionLevel
;
568 if (0 != (This
->fChecks
& USPOOF_MIXED_NUMBERS
)) {
570 This
->getNumerics(id
, numerics
, *status
);
571 if (numerics
.size() > 1) {
572 result
|= USPOOF_MIXED_NUMBERS
;
574 checkResult
->fNumerics
= numerics
; // UnicodeSet::operator=
577 if (0 != (This
->fChecks
& USPOOF_HIDDEN_OVERLAY
)) {
578 int32_t index
= This
->findHiddenOverlay(id
, *status
);
580 result
|= USPOOF_HIDDEN_OVERLAY
;
585 if (0 != (This
->fChecks
& USPOOF_CHAR_LIMIT
)) {
588 int32_t length
= id
.length();
589 for (i
=0; i
<length
;) {
592 if (!This
->fAllowedCharsSet
->contains(c
)) {
593 result
|= USPOOF_CHAR_LIMIT
;
599 if (0 != (This
->fChecks
& USPOOF_INVISIBLE
)) {
600 // This check needs to be done on NFD input
601 UnicodeString nfdText
;
602 gNfdNormalizer
->normalize(id
, nfdText
, *status
);
603 int32_t nfdLength
= nfdText
.length();
605 // scan for more than one occurence of the same non-spacing mark
606 // in a sequence of non-spacing marks.
609 UChar32 firstNonspacingMark
= 0;
610 UBool haveMultipleMarks
= FALSE
;
611 UnicodeSet marksSeenSoFar
; // Set of combining marks in a single combining sequence.
613 for (i
=0; i
<nfdLength
;) {
614 c
= nfdText
.char32At(i
);
616 if (u_charType(c
) != U_NON_SPACING_MARK
) {
617 firstNonspacingMark
= 0;
618 if (haveMultipleMarks
) {
619 marksSeenSoFar
.clear();
620 haveMultipleMarks
= FALSE
;
624 if (firstNonspacingMark
== 0) {
625 firstNonspacingMark
= c
;
628 if (!haveMultipleMarks
) {
629 marksSeenSoFar
.add(firstNonspacingMark
);
630 haveMultipleMarks
= TRUE
;
632 if (marksSeenSoFar
.contains(c
)) {
633 // report the error, and stop scanning.
634 // No need to find more than the first failure.
635 result
|= USPOOF_INVISIBLE
;
638 marksSeenSoFar
.add(c
);
642 checkResult
->fChecks
= result
;
643 return checkResult
->toCombinedBitmask(This
->fChecks
);
648 U_CAPI
int32_t U_EXPORT2
649 uspoof_check2UnicodeString(const USpoofChecker
*sc
,
650 const icu::UnicodeString
&id
,
651 USpoofCheckResult
* checkResult
,
652 UErrorCode
*status
) {
653 const SpoofImpl
*This
= SpoofImpl::validateThis(sc
, *status
);
658 if (checkResult
!= NULL
) {
659 CheckResult
* ThisCheckResult
= CheckResult::validateThis(checkResult
, *status
);
660 if (ThisCheckResult
== NULL
) {
663 return checkImpl(This
, id
, ThisCheckResult
, status
);
665 // Stack-allocate the checkResult since this method doesn't return it
666 CheckResult stackCheckResult
;
667 return checkImpl(This
, id
, &stackCheckResult
, status
);
672 U_CAPI
int32_t U_EXPORT2
673 uspoof_getSkeleton(const USpoofChecker
*sc
,
675 const UChar
*id
, int32_t length
,
676 UChar
*dest
, int32_t destCapacity
,
677 UErrorCode
*status
) {
679 SpoofImpl::validateThis(sc
, *status
);
680 if (U_FAILURE(*status
)) {
683 if (length
<-1 || destCapacity
<0 || (destCapacity
==0 && dest
!=NULL
)) {
684 *status
= U_ILLEGAL_ARGUMENT_ERROR
;
688 UnicodeString
idStr((length
==-1), id
, length
); // Aliasing constructor
689 UnicodeString destStr
;
690 uspoof_getSkeletonUnicodeString(sc
, type
, idStr
, destStr
, status
);
691 destStr
.extract(dest
, destCapacity
, *status
);
692 return destStr
.length();
697 U_I18N_API UnicodeString
& U_EXPORT2
698 uspoof_getSkeletonUnicodeString(const USpoofChecker
*sc
,
700 const UnicodeString
&id
,
702 UErrorCode
*status
) {
703 const SpoofImpl
*This
= SpoofImpl::validateThis(sc
, *status
);
704 if (U_FAILURE(*status
)) {
709 gNfdNormalizer
->normalize(id
, nfdId
, *status
);
711 // Apply the skeleton mapping to the NFD normalized input string
712 // Accumulate the skeleton, possibly unnormalized, in a UnicodeString.
713 int32_t inputIndex
= 0;
714 UnicodeString skelStr
;
715 int32_t normalizedLen
= nfdId
.length();
716 for (inputIndex
=0; inputIndex
< normalizedLen
; ) {
717 UChar32 c
= nfdId
.char32At(inputIndex
);
718 inputIndex
+= U16_LENGTH(c
);
719 This
->fSpoofData
->confusableLookup(c
, skelStr
);
722 gNfdNormalizer
->normalize(skelStr
, dest
, *status
);
727 U_CAPI
int32_t U_EXPORT2
728 uspoof_getSkeletonUTF8(const USpoofChecker
*sc
,
730 const char *id
, int32_t length
,
731 char *dest
, int32_t destCapacity
,
732 UErrorCode
*status
) {
733 SpoofImpl::validateThis(sc
, *status
);
734 if (U_FAILURE(*status
)) {
737 if (length
<-1 || destCapacity
<0 || (destCapacity
==0 && dest
!=NULL
)) {
738 *status
= U_ILLEGAL_ARGUMENT_ERROR
;
742 UnicodeString srcStr
= UnicodeString::fromUTF8(StringPiece(id
, length
>=0 ? length
: static_cast<int32_t>(uprv_strlen(id
))));
743 UnicodeString destStr
;
744 uspoof_getSkeletonUnicodeString(sc
, type
, srcStr
, destStr
, status
);
745 if (U_FAILURE(*status
)) {
749 int32_t lengthInUTF8
= 0;
750 u_strToUTF8(dest
, destCapacity
, &lengthInUTF8
,
751 destStr
.getBuffer(), destStr
.length(), status
);
756 U_CAPI
int32_t U_EXPORT2
757 uspoof_serialize(USpoofChecker
*sc
,void *buf
, int32_t capacity
, UErrorCode
*status
) {
758 SpoofImpl
*This
= SpoofImpl::validateThis(sc
, *status
);
760 U_ASSERT(U_FAILURE(*status
));
764 return This
->fSpoofData
->serialize(buf
, capacity
, *status
);
767 U_CAPI
const USet
* U_EXPORT2
768 uspoof_getInclusionSet(UErrorCode
*status
) {
769 umtx_initOnce(gSpoofInitStaticsOnce
, &initializeStatics
, *status
);
770 return gInclusionSet
->toUSet();
773 U_CAPI
const USet
* U_EXPORT2
774 uspoof_getRecommendedSet(UErrorCode
*status
) {
775 umtx_initOnce(gSpoofInitStaticsOnce
, &initializeStatics
, *status
);
776 return gRecommendedSet
->toUSet();
779 U_I18N_API
const UnicodeSet
* U_EXPORT2
780 uspoof_getInclusionUnicodeSet(UErrorCode
*status
) {
781 umtx_initOnce(gSpoofInitStaticsOnce
, &initializeStatics
, *status
);
782 return gInclusionSet
;
785 U_I18N_API
const UnicodeSet
* U_EXPORT2
786 uspoof_getRecommendedUnicodeSet(UErrorCode
*status
) {
787 umtx_initOnce(gSpoofInitStaticsOnce
, &initializeStatics
, *status
);
788 return gRecommendedSet
;
795 U_CAPI USpoofCheckResult
* U_EXPORT2
796 uspoof_openCheckResult(UErrorCode
*status
) {
797 CheckResult
* checkResult
= new CheckResult();
798 if (checkResult
== NULL
) {
799 *status
= U_MEMORY_ALLOCATION_ERROR
;
802 return checkResult
->asUSpoofCheckResult();
805 U_CAPI
void U_EXPORT2
806 uspoof_closeCheckResult(USpoofCheckResult
* checkResult
) {
807 UErrorCode status
= U_ZERO_ERROR
;
808 CheckResult
* This
= CheckResult::validateThis(checkResult
, status
);
812 U_CAPI
int32_t U_EXPORT2
813 uspoof_getCheckResultChecks(const USpoofCheckResult
*checkResult
, UErrorCode
*status
) {
814 const CheckResult
* This
= CheckResult::validateThis(checkResult
, *status
);
815 if (U_FAILURE(*status
)) { return 0; }
816 return This
->fChecks
;
819 U_CAPI URestrictionLevel U_EXPORT2
820 uspoof_getCheckResultRestrictionLevel(const USpoofCheckResult
*checkResult
, UErrorCode
*status
) {
821 const CheckResult
* This
= CheckResult::validateThis(checkResult
, *status
);
822 if (U_FAILURE(*status
)) { return USPOOF_UNRESTRICTIVE
; }
823 return This
->fRestrictionLevel
;
826 U_CAPI
const USet
* U_EXPORT2
827 uspoof_getCheckResultNumerics(const USpoofCheckResult
*checkResult
, UErrorCode
*status
) {
828 const CheckResult
* This
= CheckResult::validateThis(checkResult
, *status
);
829 if (U_FAILURE(*status
)) { return NULL
; }
830 return This
->fNumerics
.toUSet();
835 #endif // !UCONFIG_NO_NORMALIZATION