Bug Summary

File:out/../deps/icu-small/source/i18n/uspoof.cpp
Warning:line 245, column 12
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name uspoof.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D U_COMMON_IMPLEMENTATION=1 -D U_I18N_IMPLEMENTATION=1 -D U_IO_IMPLEMENTATION=1 -D U_TOOLUTIL_IMPLEMENTATION=1 -D U_ATTRIBUTE_DEPRECATED= -D _CRT_SECURE_NO_DEPRECATE= -D U_STATIC_IMPLEMENTATION=1 -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/icu-small/source/common -I ../deps/icu-small/source/i18n -I ../deps/icu-small/source/tools/toolutil -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-deprecated-declarations -Wno-strict-aliasing -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/icu-small/source/i18n/uspoof.cpp
1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4***************************************************************************
5* Copyright (C) 2008-2015, International Business Machines Corporation
6* and others. All Rights Reserved.
7***************************************************************************
8* file name: uspoof.cpp
9* encoding: UTF-8
10* tab size: 8 (not used)
11* indentation:4
12*
13* created on: 2008Feb13
14* created by: Andy Heninger
15*
16* Unicode Spoof Detection
17*/
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"
23#include "cmemory.h"
24#include "cstring.h"
25#include "mutex.h"
26#include "scriptset.h"
27#include "uassert.h"
28#include "ucln_in.h"
29#include "uspoof_impl.h"
30#include "umutex.h"
31
32
33#if !UCONFIG_NO_NORMALIZATION0
34
35U_NAMESPACE_USEusing namespace icu_71;
36
37
38//
39// Static Objects used by the spoof impl, their thread safe initialization and their cleanup.
40//
41static UnicodeSet *gInclusionSet = NULL__null;
42static UnicodeSet *gRecommendedSet = NULL__null;
43static const Normalizer2 *gNfdNormalizer = NULL__null;
44static UInitOnce gSpoofInitStaticsOnce = U_INITONCE_INITIALIZER{{ 0 }, U_ZERO_ERROR};
45
46namespace {
47
48UBool U_CALLCONV
49uspoof_cleanup(void) {
50 delete gInclusionSet;
51 gInclusionSet = NULL__null;
52 delete gRecommendedSet;
53 gRecommendedSet = NULL__null;
54 gNfdNormalizer = NULL__null;
55 gSpoofInitStaticsOnce.reset();
56 return TRUE1;
57}
58
59void 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__null) {
65 status = U_MEMORY_ALLOCATION_ERROR;
66 return;
67 }
68 gInclusionSet->freeze();
69
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"\\u04FF\\u0510-\\u0529\\u052E\\u052F\\u0531-\\u0556\\u0559\\u0561-\\u0586"
83 u"\\u05B4\\u05D0-\\u05EA\\u05EF-\\u05F2\\u0620-\\u063F\\u0641-\\u0655\\u0660-"
84 u"\\u0669\\u0670-\\u0672\\u0674\\u0679-\\u068D\\u068F-\\u06A0\\u06A2-\\u06D3"
85 u"\\u06D5\\u06E5\\u06E6\\u06EE-\\u06FC\\u06FF\\u0750-\\u07B1\\u0870-\\u0887"
86 u"\\u0889-\\u088E\\u08A0-\\u08AC\\u08B2\\u08B5-\\u08C9\\u0901-\\u094D\\u094F"
87 u"\\u0950\\u0956\\u0957\\u0960-\\u0963\\u0966-\\u096F\\u0971-\\u0977\\u0979-"
88 u"\\u097F\\u0981-\\u0983\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-"
89 u"\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BC-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CE"
90 u"\\u09D7\\u09E0-\\u09E3\\u09E6-\\u09F1\\u09FE\\u0A01-\\u0A03\\u0A05-\\u0A0A"
91 u"\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A35\\u0A38\\u0A39"
92 u"\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A5C\\u0A66-\\u0A74"
93 u"\\u0A81-\\u0A83\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0"
94 u"\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABC-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD"
95 u"\\u0AD0\\u0AE0-\\u0AE3\\u0AE6-\\u0AEF\\u0AFA-\\u0AFF\\u0B01-\\u0B03\\u0B05-"
96 u"\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-"
97 u"\\u0B39\\u0B3C-\\u0B43\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B55-\\u0B57\\u0B5F-"
98 u"\\u0B61\\u0B66-\\u0B6F\\u0B71\\u0B82\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90"
99 u"\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-"
100 u"\\u0BAA\\u0BAE-\\u0BB9\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD0"
101 u"\\u0BD7\\u0BE6-\\u0BEF\\u0C01-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-"
102 u"\\u0C33\\u0C35-\\u0C39\\u0C3C-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55"
103 u"\\u0C56\\u0C5D\\u0C60\\u0C61\\u0C66-\\u0C6F\\u0C80\\u0C82\\u0C83\\u0C85-"
104 u"\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBC-"
105 u"\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0CDD\\u0CE0-\\u0CE3"
106 u"\\u0CE6-\\u0CEF\\u0CF1\\u0CF2\\u0D00\\u0D02\\u0D03\\u0D05-\\u0D0C\\u0D0E-"
107 u"\\u0D10\\u0D12-\\u0D3A\\u0D3D-\\u0D43\\u0D46-\\u0D48\\u0D4A-\\u0D4E\\u0D54-"
108 u"\\u0D57\\u0D60\\u0D61\\u0D66-\\u0D6F\\u0D7A-\\u0D7F\\u0D82\\u0D83\\u0D85-"
109 u"\\u0D8E\\u0D91-\\u0D96\\u0D9A-\\u0DA5\\u0DA7-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD"
110 u"\\u0DC0-\\u0DC6\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDE\\u0DF2\\u0E01-"
111 u"\\u0E32\\u0E34-\\u0E3A\\u0E40-\\u0E4E\\u0E50-\\u0E59\\u0E81\\u0E82\\u0E84"
112 u"\\u0E86-\\u0E8A\\u0E8C-\\u0EA3\\u0EA5\\u0EA7-\\u0EB2\\u0EB4-\\u0EBD\\u0EC0-"
113 u"\\u0EC4\\u0EC6\\u0EC8-\\u0ECD\\u0ED0-\\u0ED9\\u0EDE\\u0EDF\\u0F00\\u0F20-"
114 u"\\u0F29\\u0F35\\u0F37\\u0F3E-\\u0F42\\u0F44-\\u0F47\\u0F49-\\u0F4C\\u0F4E-"
115 u"\\u0F51\\u0F53-\\u0F56\\u0F58-\\u0F5B\\u0F5D-\\u0F68\\u0F6A-\\u0F6C\\u0F71"
116 u"\\u0F72\\u0F74\\u0F7A-\\u0F80\\u0F82-\\u0F84\\u0F86-\\u0F92\\u0F94-\\u0F97"
117 u"\\u0F99-\\u0F9C\\u0F9E-\\u0FA1\\u0FA3-\\u0FA6\\u0FA8-\\u0FAB\\u0FAD-\\u0FB8"
118 u"\\u0FBA-\\u0FBC\\u0FC6\\u1000-\\u1049\\u1050-\\u109D\\u10C7\\u10CD\\u10D0-"
119 u"\\u10F0\\u10F7-\\u10FA\\u10FD-\\u10FF\\u1200-\\u1248\\u124A-\\u124D\\u1250-"
120 u"\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0"
121 u"\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-"
122 u"\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u135D-\\u135F\\u1380-\\u138F\\u1780-"
123 u"\\u17A2\\u17A5-\\u17A7\\u17A9-\\u17B3\\u17B6-\\u17CD\\u17D0\\u17D2\\u17D7"
124 u"\\u17DC\\u17E0-\\u17E9\\u1C90-\\u1CBA\\u1CBD-\\u1CBF\\u1E00-\\u1E99\\u1E9E"
125 u"\\u1EA0-\\u1EF9\\u1F00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D"
126 u"\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F70\\u1F72\\u1F74\\u1F76"
127 u"\\u1F78\\u1F7A\\u1F7C\\u1F80-\\u1FB4\\u1FB6-\\u1FBA\\u1FBC\\u1FC2-\\u1FC4"
128 u"\\u1FC6-\\u1FC8\\u1FCA\\u1FCC\\u1FD0-\\u1FD2\\u1FD6-\\u1FDA\\u1FE0-\\u1FE2"
129 u"\\u1FE4-\\u1FEA\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FF8\\u1FFA\\u1FFC\\u2D27"
130 u"\\u2D2D\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-"
131 u"\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u3005-"
132 u"\\u3007\\u3041-\\u3096\\u3099\\u309A\\u309D\\u309E\\u30A1-\\u30FA\\u30FC-"
133 u"\\u30FE\\u3105-\\u312D\\u312F\\u31A0-\\u31BF\\u3400-\\u4DBF\\u4E00-\\u9FFF"
134 u"\\uA67F\\uA717-\\uA71F\\uA788\\uA78D\\uA792\\uA793\\uA7AA\\uA7AE\\uA7B8"
135 u"\\uA7B9\\uA7C0-\\uA7CA\\uA7D0\\uA7D1\\uA7D3\\uA7D5-\\uA7D9\\uA9E7-\\uA9FE"
136 u"\\uAA60-\\uAA76\\uAA7A-\\uAA7F\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16"
137 u"\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB66\\uAB67\\uAC00-\\uD7A3\\uFA0E\\uFA0F"
138 u"\\uFA11\\uFA13\\uFA14\\uFA1F\\uFA21\\uFA23\\uFA24\\uFA27-\\uFA29\\U00011301"
139 u"\\U00011303\\U0001133B\\U0001133C\\U00016FF0\\U00016FF1\\U0001B11F-"
140 u"\\U0001B122\\U0001B150-\\U0001B152\\U0001B164-\\U0001B167\\U0001DF00-"
141 u"\\U0001DF1E\\U0001E7E0-\\U0001E7E6\\U0001E7E8-\\U0001E7EB\\U0001E7ED"
142 u"\\U0001E7EE\\U0001E7F0-\\U0001E7FE\\U00020000-\\U0002A6DF\\U0002A700-"
143 u"\\U0002B738\\U0002B740-\\U0002B81D\\U0002B820-\\U0002CEA1\\U0002CEB0-"
144 u"\\U0002EBE0\\U00030000-\\U0003134A]";
145
146 gRecommendedSet = new UnicodeSet(UnicodeString(recommendedPat), status);
147 if (gRecommendedSet == NULL__null) {
148 status = U_MEMORY_ALLOCATION_ERROR;
149 delete gInclusionSet;
150 return;
151 }
152 gRecommendedSet->freeze();
153 gNfdNormalizer = Normalizer2::getNFDInstance(status);
154 ucln_i18n_registerCleanupucln_i18n_registerCleanup_71(UCLN_I18N_SPOOF, uspoof_cleanup);
155}
156
157} // namespace
158
159U_CFUNCextern "C" void uspoof_internalInitStaticsuspoof_internalInitStatics_71(UErrorCode *status) {
160 umtx_initOnce(gSpoofInitStaticsOnce, &initializeStatics, *status);
161}
162
163U_CAPIextern "C" USpoofChecker * U_EXPORT2
164uspoof_openuspoof_open_71(UErrorCode *status) {
165 umtx_initOnce(gSpoofInitStaticsOnce, &initializeStatics, *status);
166 if (U_FAILURE(*status)) {
167 return NULL__null;
168 }
169 SpoofImpl *si = new SpoofImpl(*status);
170 if (si == NULL__null) {
171 *status = U_MEMORY_ALLOCATION_ERROR;
172 return NULL__null;
173 }
174 if (U_FAILURE(*status)) {
175 delete si;
176 return NULL__null;
177 }
178 return si->asUSpoofChecker();
179}
180
181
182U_CAPIextern "C" USpoofChecker * U_EXPORT2
183uspoof_openFromSerializeduspoof_openFromSerialized_71(const void *data, int32_t length, int32_t *pActualLength,
184 UErrorCode *status) {
185 if (U_FAILURE(*status)) {
186 return NULL__null;
187 }
188
189 if (data == NULL__null) {
190 *status = U_ILLEGAL_ARGUMENT_ERROR;
191 return NULL__null;
192 }
193
194 umtx_initOnce(gSpoofInitStaticsOnce, &initializeStatics, *status);
195 if (U_FAILURE(*status))
196 {
197 return NULL__null;
198 }
199
200 SpoofData *sd = new SpoofData(data, length, *status);
201 if (sd == NULL__null) {
202 *status = U_MEMORY_ALLOCATION_ERROR;
203 return NULL__null;
204 }
205
206 if (U_FAILURE(*status)) {
207 delete sd;
208 return NULL__null;
209 }
210
211 SpoofImpl *si = new SpoofImpl(sd, *status);
212 if (si == NULL__null) {
213 *status = U_MEMORY_ALLOCATION_ERROR;
214 delete sd; // explicit delete as the destructor for si won't be called.
215 return NULL__null;
216 }
217
218 if (U_FAILURE(*status)) {
219 delete si; // no delete for sd, as the si destructor will delete it.
220 return NULL__null;
221 }
222
223 if (pActualLength != NULL__null) {
224 *pActualLength = sd->size();
225 }
226 return si->asUSpoofChecker();
227}
228
229
230U_CAPIextern "C" USpoofChecker * U_EXPORT2
231uspoof_cloneuspoof_clone_71(const USpoofChecker *sc, UErrorCode *status) {
232 const SpoofImpl *src = SpoofImpl::validateThis(sc, *status);
233 if (src == NULL__null) {
1
Assuming 'src' is not equal to NULL
→
2
←
Taking false branch
→
234 return NULL__null;
235 }
236 SpoofImpl *result = new SpoofImpl(*src, *status); // copy constructor
237 if (result == NULL__null) {
3
←
Assuming 'result' is not equal to NULL
→
4
←
Taking false branch
→
238 *status = U_MEMORY_ALLOCATION_ERROR;
239 return NULL__null;
240 }
241 if (U_FAILURE(*status)) {
5
←
Taking true branch
→
242 delete result;
243 result = NULL__null;
6
←
Null pointer value stored to 'result'
→
244 }
245 return result->asUSpoofChecker();
7
←
Called C++ object pointer is null
246}
247
248
249U_CAPIextern "C" void U_EXPORT2
250uspoof_closeuspoof_close_71(USpoofChecker *sc) {
251 UErrorCode status = U_ZERO_ERROR;
252 SpoofImpl *This = SpoofImpl::validateThis(sc, status);
253 delete This;
254}
255
256
257U_CAPIextern "C" void U_EXPORT2
258uspoof_setChecksuspoof_setChecks_71(USpoofChecker *sc, int32_t checks, UErrorCode *status) {
259 SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
260 if (This == NULL__null) {
261 return;
262 }
263
264 // Verify that the requested checks are all ones (bits) that
265 // are acceptable, known values.
266 if (checks & ~(USPOOF_ALL_CHECKS | USPOOF_AUX_INFO)) {
267 *status = U_ILLEGAL_ARGUMENT_ERROR;
268 return;
269 }
270
271 This->fChecks = checks;
272}
273
274
275U_CAPIextern "C" int32_t U_EXPORT2
276uspoof_getChecksuspoof_getChecks_71(const USpoofChecker *sc, UErrorCode *status) {
277 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
278 if (This == NULL__null) {
279 return 0;
280 }
281 return This->fChecks;
282}
283
284U_CAPIextern "C" void U_EXPORT2
285uspoof_setRestrictionLeveluspoof_setRestrictionLevel_71(USpoofChecker *sc, URestrictionLevel restrictionLevel) {
286 UErrorCode status = U_ZERO_ERROR;
287 SpoofImpl *This = SpoofImpl::validateThis(sc, status);
288 if (This != NULL__null) {
289 This->fRestrictionLevel = restrictionLevel;
290 This->fChecks |= USPOOF_RESTRICTION_LEVEL;
291 }
292}
293
294U_CAPIextern "C" URestrictionLevel U_EXPORT2
295uspoof_getRestrictionLeveluspoof_getRestrictionLevel_71(const USpoofChecker *sc) {
296 UErrorCode status = U_ZERO_ERROR;
297 const SpoofImpl *This = SpoofImpl::validateThis(sc, status);
298 if (This == NULL__null) {
299 return USPOOF_UNRESTRICTIVE;
300 }
301 return This->fRestrictionLevel;
302}
303
304U_CAPIextern "C" void U_EXPORT2
305uspoof_setAllowedLocalesuspoof_setAllowedLocales_71(USpoofChecker *sc, const char *localesList, UErrorCode *status) {
306 SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
307 if (This == NULL__null) {
308 return;
309 }
310 This->setAllowedLocales(localesList, *status);
311}
312
313U_CAPIextern "C" const char * U_EXPORT2
314uspoof_getAllowedLocalesuspoof_getAllowedLocales_71(USpoofChecker *sc, UErrorCode *status) {
315 SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
316 if (This == NULL__null) {
317 return NULL__null;
318 }
319 return This->getAllowedLocales(*status);
320}
321
322
323U_CAPIextern "C" const USet * U_EXPORT2
324uspoof_getAllowedCharsuspoof_getAllowedChars_71(const USpoofChecker *sc, UErrorCode *status) {
325 const UnicodeSet *result = uspoof_getAllowedUnicodeSetuspoof_getAllowedUnicodeSet_71(sc, status);
326 return result->toUSet();
327}
328
329U_CAPIextern "C" const UnicodeSet * U_EXPORT2
330uspoof_getAllowedUnicodeSetuspoof_getAllowedUnicodeSet_71(const USpoofChecker *sc, UErrorCode *status) {
331 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
332 if (This == NULL__null) {
333 return NULL__null;
334 }
335 return This->fAllowedCharsSet;
336}
337
338
339U_CAPIextern "C" void U_EXPORT2
340uspoof_setAllowedCharsuspoof_setAllowedChars_71(USpoofChecker *sc, const USet *chars, UErrorCode *status) {
341 const UnicodeSet *set = UnicodeSet::fromUSet(chars);
342 uspoof_setAllowedUnicodeSetuspoof_setAllowedUnicodeSet_71(sc, set, status);
343}
344
345
346U_CAPIextern "C" void U_EXPORT2
347uspoof_setAllowedUnicodeSetuspoof_setAllowedUnicodeSet_71(USpoofChecker *sc, const UnicodeSet *chars, UErrorCode *status) {
348 SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
349 if (This == NULL__null) {
350 return;
351 }
352 if (chars->isBogus()) {
353 *status = U_ILLEGAL_ARGUMENT_ERROR;
354 return;
355 }
356 UnicodeSet *clonedSet = chars->clone();
357 if (clonedSet == NULL__null || clonedSet->isBogus()) {
358 *status = U_MEMORY_ALLOCATION_ERROR;
359 return;
360 }
361 clonedSet->freeze();
362 delete This->fAllowedCharsSet;
363 This->fAllowedCharsSet = clonedSet;
364 This->fChecks |= USPOOF_CHAR_LIMIT;
365}
366
367
368U_CAPIextern "C" int32_t U_EXPORT2
369uspoof_checkuspoof_check_71(const USpoofChecker *sc,
370 const UChar *id, int32_t length,
371 int32_t *position,
372 UErrorCode *status) {
373
374 // Backwards compatibility:
375 if (position != NULL__null) {
376 *position = 0;
377 }
378
379 // Delegate to uspoof_check2
380 return uspoof_check2uspoof_check2_71(sc, id, length, NULL__null, status);
381}
382
383
384U_CAPIextern "C" int32_t U_EXPORT2
385uspoof_check2uspoof_check2_71(const USpoofChecker *sc,
386 const UChar* id, int32_t length,
387 USpoofCheckResult* checkResult,
388 UErrorCode *status) {
389
390 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
391 if (This == NULL__null) {
392 return 0;
393 }
394 if (length < -1) {
395 *status = U_ILLEGAL_ARGUMENT_ERROR;
396 return 0;
397 }
398 UnicodeString idStr((length == -1), id, length); // Aliasing constructor.
399 int32_t result = uspoof_check2UnicodeStringuspoof_check2UnicodeString_71(sc, idStr, checkResult, status);
400 return result;
401}
402
403
404U_CAPIextern "C" int32_t U_EXPORT2
405uspoof_checkUTF8uspoof_checkUTF8_71(const USpoofChecker *sc,
406 const char *id, int32_t length,
407 int32_t *position,
408 UErrorCode *status) {
409
410 // Backwards compatibility:
411 if (position != NULL__null) {
412 *position = 0;
413 }
414
415 // Delegate to uspoof_check2
416 return uspoof_check2UTF8uspoof_check2UTF8_71(sc, id, length, NULL__null, status);
417}
418
419
420U_CAPIextern "C" int32_t U_EXPORT2
421uspoof_check2UTF8uspoof_check2UTF8_71(const USpoofChecker *sc,
422 const char *id, int32_t length,
423 USpoofCheckResult* checkResult,
424 UErrorCode *status) {
425
426 if (U_FAILURE(*status)) {
427 return 0;
428 }
429 UnicodeString idStr = UnicodeString::fromUTF8(StringPiece(id, length>=0 ? length : static_cast<int32_t>(uprv_strlen(id):: strlen(id))));
430 int32_t result = uspoof_check2UnicodeStringuspoof_check2UnicodeString_71(sc, idStr, checkResult, status);
431 return result;
432}
433
434
435U_CAPIextern "C" int32_t U_EXPORT2
436uspoof_areConfusableuspoof_areConfusable_71(const USpoofChecker *sc,
437 const UChar *id1, int32_t length1,
438 const UChar *id2, int32_t length2,
439 UErrorCode *status) {
440 SpoofImpl::validateThis(sc, *status);
441 if (U_FAILURE(*status)) {
442 return 0;
443 }
444 if (length1 < -1 || length2 < -1) {
445 *status = U_ILLEGAL_ARGUMENT_ERROR;
446 return 0;
447 }
448
449 UnicodeString id1Str((length1==-1), id1, length1); // Aliasing constructor
450 UnicodeString id2Str((length2==-1), id2, length2); // Aliasing constructor
451 return uspoof_areConfusableUnicodeStringuspoof_areConfusableUnicodeString_71(sc, id1Str, id2Str, status);
452}
453
454
455U_CAPIextern "C" int32_t U_EXPORT2
456uspoof_areConfusableUTF8uspoof_areConfusableUTF8_71(const USpoofChecker *sc,
457 const char *id1, int32_t length1,
458 const char *id2, int32_t length2,
459 UErrorCode *status) {
460 SpoofImpl::validateThis(sc, *status);
461 if (U_FAILURE(*status)) {
462 return 0;
463 }
464 if (length1 < -1 || length2 < -1) {
465 *status = U_ILLEGAL_ARGUMENT_ERROR;
466 return 0;
467 }
468 UnicodeString id1Str = UnicodeString::fromUTF8(StringPiece(id1, length1>=0? length1 : static_cast<int32_t>(uprv_strlen(id1):: strlen(id1))));
469 UnicodeString id2Str = UnicodeString::fromUTF8(StringPiece(id2, length2>=0? length2 : static_cast<int32_t>(uprv_strlen(id2):: strlen(id2))));
470 int32_t results = uspoof_areConfusableUnicodeStringuspoof_areConfusableUnicodeString_71(sc, id1Str, id2Str, status);
471 return results;
472}
473
474
475U_CAPIextern "C" int32_t U_EXPORT2
476uspoof_areConfusableUnicodeStringuspoof_areConfusableUnicodeString_71(const USpoofChecker *sc,
477 const icu::UnicodeString &id1,
478 const icu::UnicodeString &id2,
479 UErrorCode *status) {
480 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
481 if (U_FAILURE(*status)) {
482 return 0;
483 }
484 //
485 // See section 4 of UAX 39 for the algorithm for checking whether two strings are confusable,
486 // and for definitions of the types (single, whole, mixed-script) of confusables.
487
488 // We only care about a few of the check flags. Ignore the others.
489 // If no tests relevant to this function have been specified, return an error.
490 // TODO: is this really the right thing to do? It's probably an error on the caller's part,
491 // but logically we would just return 0 (no error).
492 if ((This->fChecks & USPOOF_CONFUSABLE) == 0) {
493 *status = U_INVALID_STATE_ERROR;
494 return 0;
495 }
496
497 // Compute the skeletons and check for confusability.
498 UnicodeString id1Skeleton;
499 uspoof_getSkeletonUnicodeStringuspoof_getSkeletonUnicodeString_71(sc, 0 /* deprecated */, id1, id1Skeleton, status);
500 UnicodeString id2Skeleton;
501 uspoof_getSkeletonUnicodeStringuspoof_getSkeletonUnicodeString_71(sc, 0 /* deprecated */, id2, id2Skeleton, status);
502 if (U_FAILURE(*status)) { return 0; }
503 if (id1Skeleton != id2Skeleton) {
504 return 0;
505 }
506
507 // If we get here, the strings are confusable. Now we just need to set the flags for the appropriate classes
508 // of confusables according to UTS 39 section 4.
509 // Start by computing the resolved script sets of id1 and id2.
510 ScriptSet id1RSS;
511 This->getResolvedScriptSet(id1, id1RSS, *status);
512 ScriptSet id2RSS;
513 This->getResolvedScriptSet(id2, id2RSS, *status);
514
515 // Turn on all applicable flags
516 int32_t result = 0;
517 if (id1RSS.intersects(id2RSS)) {
518 result |= USPOOF_SINGLE_SCRIPT_CONFUSABLE;
519 } else {
520 result |= USPOOF_MIXED_SCRIPT_CONFUSABLE;
521 if (!id1RSS.isEmpty() && !id2RSS.isEmpty()) {
522 result |= USPOOF_WHOLE_SCRIPT_CONFUSABLE;
523 }
524 }
525
526 // Turn off flags that the user doesn't want
527 if ((This->fChecks & USPOOF_SINGLE_SCRIPT_CONFUSABLE) == 0) {
528 result &= ~USPOOF_SINGLE_SCRIPT_CONFUSABLE;
529 }
530 if ((This->fChecks & USPOOF_MIXED_SCRIPT_CONFUSABLE) == 0) {
531 result &= ~USPOOF_MIXED_SCRIPT_CONFUSABLE;
532 }
533 if ((This->fChecks & USPOOF_WHOLE_SCRIPT_CONFUSABLE) == 0) {
534 result &= ~USPOOF_WHOLE_SCRIPT_CONFUSABLE;
535 }
536
537 return result;
538}
539
540
541U_CAPIextern "C" int32_t U_EXPORT2
542uspoof_checkUnicodeStringuspoof_checkUnicodeString_71(const USpoofChecker *sc,
543 const icu::UnicodeString &id,
544 int32_t *position,
545 UErrorCode *status) {
546
547 // Backwards compatibility:
548 if (position != NULL__null) {
549 *position = 0;
550 }
551
552 // Delegate to uspoof_check2
553 return uspoof_check2UnicodeStringuspoof_check2UnicodeString_71(sc, id, NULL__null, status);
554}
555
556namespace {
557
558int32_t checkImpl(const SpoofImpl* This, const UnicodeString& id, CheckResult* checkResult, UErrorCode* status) {
559 U_ASSERT(This != NULL)(void)0;
560 U_ASSERT(checkResult != NULL)(void)0;
561 checkResult->clear();
562 int32_t result = 0;
563
564 if (0 != (This->fChecks & USPOOF_RESTRICTION_LEVEL)) {
565 URestrictionLevel idRestrictionLevel = This->getRestrictionLevel(id, *status);
566 if (idRestrictionLevel > This->fRestrictionLevel) {
567 result |= USPOOF_RESTRICTION_LEVEL;
568 }
569 checkResult->fRestrictionLevel = idRestrictionLevel;
570 }
571
572 if (0 != (This->fChecks & USPOOF_MIXED_NUMBERS)) {
573 UnicodeSet numerics;
574 This->getNumerics(id, numerics, *status);
575 if (numerics.size() > 1) {
576 result |= USPOOF_MIXED_NUMBERS;
577 }
578 checkResult->fNumerics = numerics; // UnicodeSet::operator=
579 }
580
581 if (0 != (This->fChecks & USPOOF_HIDDEN_OVERLAY)) {
582 int32_t index = This->findHiddenOverlay(id, *status);
583 if (index != -1) {
584 result |= USPOOF_HIDDEN_OVERLAY;
585 }
586 }
587
588
589 if (0 != (This->fChecks & USPOOF_CHAR_LIMIT)) {
590 int32_t i;
591 UChar32 c;
592 int32_t length = id.length();
593 for (i=0; i<length ;) {
594 c = id.char32At(i);
595 i += U16_LENGTH(c)((uint32_t)(c)<=0xffff ? 1 : 2);
596 if (!This->fAllowedCharsSet->contains(c)) {
597 result |= USPOOF_CHAR_LIMIT;
598 break;
599 }
600 }
601 }
602
603 if (0 != (This->fChecks & USPOOF_INVISIBLE)) {
604 // This check needs to be done on NFD input
605 UnicodeString nfdText;
606 gNfdNormalizer->normalize(id, nfdText, *status);
607 int32_t nfdLength = nfdText.length();
608
609 // scan for more than one occurrence of the same non-spacing mark
610 // in a sequence of non-spacing marks.
611 int32_t i;
612 UChar32 c;
613 UChar32 firstNonspacingMark = 0;
614 UBool haveMultipleMarks = FALSE0;
615 UnicodeSet marksSeenSoFar; // Set of combining marks in a single combining sequence.
616
617 for (i=0; i<nfdLength ;) {
618 c = nfdText.char32At(i);
619 i += U16_LENGTH(c)((uint32_t)(c)<=0xffff ? 1 : 2);
620 if (u_charTypeu_charType_71(c) != U_NON_SPACING_MARK) {
621 firstNonspacingMark = 0;
622 if (haveMultipleMarks) {
623 marksSeenSoFar.clear();
624 haveMultipleMarks = FALSE0;
625 }
626 continue;
627 }
628 if (firstNonspacingMark == 0) {
629 firstNonspacingMark = c;
630 continue;
631 }
632 if (!haveMultipleMarks) {
633 marksSeenSoFar.add(firstNonspacingMark);
634 haveMultipleMarks = TRUE1;
635 }
636 if (marksSeenSoFar.contains(c)) {
637 // report the error, and stop scanning.
638 // No need to find more than the first failure.
639 result |= USPOOF_INVISIBLE;
640 break;
641 }
642 marksSeenSoFar.add(c);
643 }
644 }
645
646 checkResult->fChecks = result;
647 return checkResult->toCombinedBitmask(This->fChecks);
648}
649
650} // namespace
651
652U_CAPIextern "C" int32_t U_EXPORT2
653uspoof_check2UnicodeStringuspoof_check2UnicodeString_71(const USpoofChecker *sc,
654 const icu::UnicodeString &id,
655 USpoofCheckResult* checkResult,
656 UErrorCode *status) {
657 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
658 if (This == NULL__null) {
659 return FALSE0;
660 }
661
662 if (checkResult != NULL__null) {
663 CheckResult* ThisCheckResult = CheckResult::validateThis(checkResult, *status);
664 if (ThisCheckResult == NULL__null) {
665 return FALSE0;
666 }
667 return checkImpl(This, id, ThisCheckResult, status);
668 } else {
669 // Stack-allocate the checkResult since this method doesn't return it
670 CheckResult stackCheckResult;
671 return checkImpl(This, id, &stackCheckResult, status);
672 }
673}
674
675
676U_CAPIextern "C" int32_t U_EXPORT2
677uspoof_getSkeletonuspoof_getSkeleton_71(const USpoofChecker *sc,
678 uint32_t type,
679 const UChar *id, int32_t length,
680 UChar *dest, int32_t destCapacity,
681 UErrorCode *status) {
682
683 SpoofImpl::validateThis(sc, *status);
684 if (U_FAILURE(*status)) {
685 return 0;
686 }
687 if (length<-1 || destCapacity<0 || (destCapacity==0 && dest!=NULL__null)) {
688 *status = U_ILLEGAL_ARGUMENT_ERROR;
689 return 0;
690 }
691
692 UnicodeString idStr((length==-1), id, length); // Aliasing constructor
693 UnicodeString destStr;
694 uspoof_getSkeletonUnicodeStringuspoof_getSkeletonUnicodeString_71(sc, type, idStr, destStr, status);
695 destStr.extract(dest, destCapacity, *status);
696 return destStr.length();
697}
698
699
700
701U_I18N_API UnicodeString & U_EXPORT2
702uspoof_getSkeletonUnicodeStringuspoof_getSkeletonUnicodeString_71(const USpoofChecker *sc,
703 uint32_t /*type*/,
704 const UnicodeString &id,
705 UnicodeString &dest,
706 UErrorCode *status) {
707 const SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
708 if (U_FAILURE(*status)) {
709 return dest;
710 }
711
712 UnicodeString nfdId;
713 gNfdNormalizer->normalize(id, nfdId, *status);
714
715 // Apply the skeleton mapping to the NFD normalized input string
716 // Accumulate the skeleton, possibly unnormalized, in a UnicodeString.
717 int32_t inputIndex = 0;
718 UnicodeString skelStr;
719 int32_t normalizedLen = nfdId.length();
720 for (inputIndex=0; inputIndex < normalizedLen; ) {
721 UChar32 c = nfdId.char32At(inputIndex);
722 inputIndex += U16_LENGTH(c)((uint32_t)(c)<=0xffff ? 1 : 2);
723 This->fSpoofData->confusableLookup(c, skelStr);
724 }
725
726 gNfdNormalizer->normalize(skelStr, dest, *status);
727 return dest;
728}
729
730
731U_CAPIextern "C" int32_t U_EXPORT2
732uspoof_getSkeletonUTF8uspoof_getSkeletonUTF8_71(const USpoofChecker *sc,
733 uint32_t type,
734 const char *id, int32_t length,
735 char *dest, int32_t destCapacity,
736 UErrorCode *status) {
737 SpoofImpl::validateThis(sc, *status);
738 if (U_FAILURE(*status)) {
739 return 0;
740 }
741 if (length<-1 || destCapacity<0 || (destCapacity==0 && dest!=NULL__null)) {
742 *status = U_ILLEGAL_ARGUMENT_ERROR;
743 return 0;
744 }
745
746 UnicodeString srcStr = UnicodeString::fromUTF8(StringPiece(id, length>=0 ? length : static_cast<int32_t>(uprv_strlen(id):: strlen(id))));
747 UnicodeString destStr;
748 uspoof_getSkeletonUnicodeStringuspoof_getSkeletonUnicodeString_71(sc, type, srcStr, destStr, status);
749 if (U_FAILURE(*status)) {
750 return 0;
751 }
752
753 int32_t lengthInUTF8 = 0;
754 u_strToUTF8u_strToUTF8_71(dest, destCapacity, &lengthInUTF8,
755 destStr.getBuffer(), destStr.length(), status);
756 return lengthInUTF8;
757}
758
759
760U_CAPIextern "C" int32_t U_EXPORT2
761uspoof_serializeuspoof_serialize_71(USpoofChecker *sc,void *buf, int32_t capacity, UErrorCode *status) {
762 SpoofImpl *This = SpoofImpl::validateThis(sc, *status);
763 if (This == NULL__null) {
764 U_ASSERT(U_FAILURE(*status))(void)0;
765 return 0;
766 }
767
768 return This->fSpoofData->serialize(buf, capacity, *status);
769}
770
771U_CAPIextern "C" const USet * U_EXPORT2
772uspoof_getInclusionSetuspoof_getInclusionSet_71(UErrorCode *status) {
773 umtx_initOnce(gSpoofInitStaticsOnce, &initializeStatics, *status);
774 return gInclusionSet->toUSet();
775}
776
777U_CAPIextern "C" const USet * U_EXPORT2
778uspoof_getRecommendedSetuspoof_getRecommendedSet_71(UErrorCode *status) {
779 umtx_initOnce(gSpoofInitStaticsOnce, &initializeStatics, *status);
780 return gRecommendedSet->toUSet();
781}
782
783U_I18N_API const UnicodeSet * U_EXPORT2
784uspoof_getInclusionUnicodeSetuspoof_getInclusionUnicodeSet_71(UErrorCode *status) {
785 umtx_initOnce(gSpoofInitStaticsOnce, &initializeStatics, *status);
786 return gInclusionSet;
787}
788
789U_I18N_API const UnicodeSet * U_EXPORT2
790uspoof_getRecommendedUnicodeSetuspoof_getRecommendedUnicodeSet_71(UErrorCode *status) {
791 umtx_initOnce(gSpoofInitStaticsOnce, &initializeStatics, *status);
792 return gRecommendedSet;
793}
794
795//------------------
796// CheckResult APIs
797//------------------
798
799U_CAPIextern "C" USpoofCheckResult* U_EXPORT2
800uspoof_openCheckResultuspoof_openCheckResult_71(UErrorCode *status) {
801 CheckResult* checkResult = new CheckResult();
802 if (checkResult == NULL__null) {
803 *status = U_MEMORY_ALLOCATION_ERROR;
804 return NULL__null;
805 }
806 return checkResult->asUSpoofCheckResult();
807}
808
809U_CAPIextern "C" void U_EXPORT2
810uspoof_closeCheckResultuspoof_closeCheckResult_71(USpoofCheckResult* checkResult) {
811 UErrorCode status = U_ZERO_ERROR;
812 CheckResult* This = CheckResult::validateThis(checkResult, status);
813 delete This;
814}
815
816U_CAPIextern "C" int32_t U_EXPORT2
817uspoof_getCheckResultChecksuspoof_getCheckResultChecks_71(const USpoofCheckResult *checkResult, UErrorCode *status) {
818 const CheckResult* This = CheckResult::validateThis(checkResult, *status);
819 if (U_FAILURE(*status)) { return 0; }
820 return This->fChecks;
821}
822
823U_CAPIextern "C" URestrictionLevel U_EXPORT2
824uspoof_getCheckResultRestrictionLeveluspoof_getCheckResultRestrictionLevel_71(const USpoofCheckResult *checkResult, UErrorCode *status) {
825 const CheckResult* This = CheckResult::validateThis(checkResult, *status);
826 if (U_FAILURE(*status)) { return USPOOF_UNRESTRICTIVE; }
827 return This->fRestrictionLevel;
828}
829
830U_CAPIextern "C" const USet* U_EXPORT2
831uspoof_getCheckResultNumericsuspoof_getCheckResultNumerics_71(const USpoofCheckResult *checkResult, UErrorCode *status) {
832 const CheckResult* This = CheckResult::validateThis(checkResult, *status);
833 if (U_FAILURE(*status)) { return NULL__null; }
834 return This->fNumerics.toUSet();
835}
836
837
838
839#endif // !UCONFIG_NO_NORMALIZATION