]> git.proxmox.com Git - mirror_zfs.git/blob - module/unicode/u8_textprep.c
projects / mirror_zfs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
cstyle: Resolve C style issues
[mirror_zfs.git] / module / unicode / u8_textprep.c
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26
27
28
29 /*
30 * UTF-8 text preparation functions (PSARC/2007/149, PSARC/2007/458).
31 *
32 * Man pages: u8_textprep_open(9F), u8_textprep_buf(9F), u8_textprep_close(9F),
33 * u8_textprep_str(9F), u8_strcmp(9F), and u8_validate(9F). See also
34 * the section 3C man pages.
35 * Interface stability: Committed.
36 */
37
38 #include <sys/types.h>
39 #ifdef _KERNEL
40 #include <sys/param.h>
41 #include <sys/sysmacros.h>
42 #include <sys/systm.h>
43 #include <sys/debug.h>
44 #include <sys/kmem.h>
45 #include <sys/ddi.h>
46 #include <sys/sunddi.h>
47 #else
48 #include <sys/u8_textprep.h>
49 #include <strings.h>
50 #endif /* _KERNEL */
51 #include <sys/byteorder.h>
52 #include <sys/errno.h>
53 #include <sys/u8_textprep_data.h>
54
55
56 /* The maximum possible number of bytes in a UTF-8 character. */
57 #define U8_MB_CUR_MAX (4)
58
59 /*
60 * The maximum number of bytes needed for a UTF-8 character to cover
61 * U+0000 - U+FFFF, i.e., the coding space of now deprecated UCS-2.
62 */
63 #define U8_MAX_BYTES_UCS2 (3)
64
65 /* The maximum possible number of bytes in a Stream-Safe Text. */
66 #define U8_STREAM_SAFE_TEXT_MAX (128)
67
68 /*
69 * The maximum number of characters in a combining/conjoining sequence and
70 * the actual upperbound limit of a combining/conjoining sequence.
71 */
72 #define U8_MAX_CHARS_A_SEQ (32)
73 #define U8_UPPER_LIMIT_IN_A_SEQ (31)
74
75 /* The combining class value for Starter. */
76 #define U8_COMBINING_CLASS_STARTER (0)
77
78 /*
79 * Some Hangul related macros at below.
80 *
81 * The first and the last of Hangul syllables, Hangul Jamo Leading consonants,
82 * Vowels, and optional Trailing consonants in Unicode scalar values.
83 *
84 * Please be noted that the U8_HANGUL_JAMO_T_FIRST is 0x11A7 at below not
85 * the actual U+11A8. This is due to that the trailing consonant is optional
86 * and thus we are doing a pre-calculation of subtracting one.
87 *
88 * Each of 19 modern leading consonants has total 588 possible syllables since
89 * Hangul has 21 modern vowels and 27 modern trailing consonants plus 1 for
90 * no trailing consonant case, i.e., 21 x 28 = 588.
91 *
92 * We also have bunch of Hangul related macros at below. Please bear in mind
93 * that the U8_HANGUL_JAMO_1ST_BYTE can be used to check whether it is
94 * a Hangul Jamo or not but the value does not guarantee that it is a Hangul
95 * Jamo; it just guarantee that it will be most likely.
96 */
97 #define U8_HANGUL_SYL_FIRST (0xAC00U)
98 #define U8_HANGUL_SYL_LAST (0xD7A3U)
99
100 #define U8_HANGUL_JAMO_L_FIRST (0x1100U)
101 #define U8_HANGUL_JAMO_L_LAST (0x1112U)
102 #define U8_HANGUL_JAMO_V_FIRST (0x1161U)
103 #define U8_HANGUL_JAMO_V_LAST (0x1175U)
104 #define U8_HANGUL_JAMO_T_FIRST (0x11A7U)
105 #define U8_HANGUL_JAMO_T_LAST (0x11C2U)
106
107 #define U8_HANGUL_V_COUNT (21)
108 #define U8_HANGUL_VT_COUNT (588)
109 #define U8_HANGUL_T_COUNT (28)
110
111 #define U8_HANGUL_JAMO_1ST_BYTE (0xE1U)
112
113 #define U8_SAVE_HANGUL_AS_UTF8(s, i, j, k, b) \
114 (s)[(i)] = (uchar_t)(0xE0U | ((uint32_t)(b) & 0xF000U) >> 12); \
115 (s)[(j)] = (uchar_t)(0x80U | ((uint32_t)(b) & 0x0FC0U) >> 6); \
116 (s)[(k)] = (uchar_t)(0x80U | ((uint32_t)(b) & 0x003FU));
117
118 #define U8_HANGUL_JAMO_L(u) \
119 ((u) >= U8_HANGUL_JAMO_L_FIRST && (u) <= U8_HANGUL_JAMO_L_LAST)
120
121 #define U8_HANGUL_JAMO_V(u) \
122 ((u) >= U8_HANGUL_JAMO_V_FIRST && (u) <= U8_HANGUL_JAMO_V_LAST)
123
124 #define U8_HANGUL_JAMO_T(u) \
125 ((u) > U8_HANGUL_JAMO_T_FIRST && (u) <= U8_HANGUL_JAMO_T_LAST)
126
127 #define U8_HANGUL_JAMO(u) \
128 ((u) >= U8_HANGUL_JAMO_L_FIRST && (u) <= U8_HANGUL_JAMO_T_LAST)
129
130 #define U8_HANGUL_SYLLABLE(u) \
131 ((u) >= U8_HANGUL_SYL_FIRST && (u) <= U8_HANGUL_SYL_LAST)
132
133 #define U8_HANGUL_COMPOSABLE_L_V(s, u) \
134 ((s) == U8_STATE_HANGUL_L && U8_HANGUL_JAMO_V((u)))
135
136 #define U8_HANGUL_COMPOSABLE_LV_T(s, u) \
137 ((s) == U8_STATE_HANGUL_LV && U8_HANGUL_JAMO_T((u)))
138
139 /* The types of decomposition mappings. */
140 #define U8_DECOMP_BOTH (0xF5U)
141 #define U8_DECOMP_CANONICAL (0xF6U)
142
143 /* The indicator for 16-bit table. */
144 #define U8_16BIT_TABLE_INDICATOR (0x8000U)
145
146 /* The following are some convenience macros. */
147 #define U8_PUT_3BYTES_INTO_UTF32(u, b1, b2, b3) \
148 (u) = ((((uint32_t)(b1) & 0x0F) << 12) | \
149 (((uint32_t)(b2) & 0x3F) << 6) | \
150 ((uint32_t)(b3) & 0x3F));
151
152 #define U8_SIMPLE_SWAP(a, b, t) \
153 (t) = (a); \
154 (a) = (b); \
155 (b) = (t);
156
157 #define U8_ASCII_TOUPPER(c) \
158 (((c) >= 'a' && (c) <= 'z') ? (c) - 'a' + 'A' : (c))
159
160 #define U8_ASCII_TOLOWER(c) \
161 (((c) >= 'A' && (c) <= 'Z') ? (c) - 'A' + 'a' : (c))
162
163 #define U8_ISASCII(c) (((uchar_t)(c)) < 0x80U)
164 /*
165 * The following macro assumes that the two characters that are to be
166 * swapped are adjacent to each other and 'a' comes before 'b'.
167 *
168 * If the assumptions are not met, then, the macro will fail.
169 */
170 #define U8_SWAP_COMB_MARKS(a, b) \
171 for (k = 0; k < disp[(a)]; k++) \
172 u8t[k] = u8s[start[(a)] + k]; \
173 for (k = 0; k < disp[(b)]; k++) \
174 u8s[start[(a)] + k] = u8s[start[(b)] + k]; \
175 start[(b)] = start[(a)] + disp[(b)]; \
176 for (k = 0; k < disp[(a)]; k++) \
177 u8s[start[(b)] + k] = u8t[k]; \
178 U8_SIMPLE_SWAP(comb_class[(a)], comb_class[(b)], tc); \
179 U8_SIMPLE_SWAP(disp[(a)], disp[(b)], tc);
180
181 /* The possible states during normalization. */
182 typedef enum {
183 U8_STATE_START = 0,
184 U8_STATE_HANGUL_L = 1,
185 U8_STATE_HANGUL_LV = 2,
186 U8_STATE_HANGUL_LVT = 3,
187 U8_STATE_HANGUL_V = 4,
188 U8_STATE_HANGUL_T = 5,
189 U8_STATE_COMBINING_MARK = 6
190 } u8_normalization_states_t;
191
192 /*
193 * The three vectors at below are used to check bytes of a given UTF-8
194 * character are valid and not containing any malformed byte values.
195 *
196 * We used to have a quite relaxed UTF-8 binary representation but then there
197 * was some security related issues and so the Unicode Consortium defined
198 * and announced the UTF-8 Corrigendum at Unicode 3.1 and then refined it
199 * one more time at the Unicode 3.2. The following three tables are based on
200 * that.
201 */
202
203 #define U8_ILLEGAL_NEXT_BYTE_COMMON(c) ((c) < 0x80 || (c) > 0xBF)
204
205 #define I_ U8_ILLEGAL_CHAR
206 #define O_ U8_OUT_OF_RANGE_CHAR
207
208 const int8_t u8_number_of_bytes[0x100] = {
209 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
210 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
211 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
212 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
213 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
214 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
215 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
216 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
217
218 /* 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F */
219 I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_,
220
221 /* 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F */
222 I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_,
223
224 /* A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF */
225 I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_,
226
227 /* B0 B1 B2 B3 B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF */
228 I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_,
229
230 /* C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF */
231 I_, I_, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
232
233 /* D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB DC DD DE DF */
234 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
235
236 /* E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF */
237 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
238
239 /* F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF */
240 4, 4, 4, 4, 4, O_, O_, O_, O_, O_, O_, O_, O_, O_, O_, O_,
241 };
242
243 #undef I_
244 #undef O_
245
246 const uint8_t u8_valid_min_2nd_byte[0x100] = {
247 0, 0, 0, 0, 0, 0, 0, 0,
248 0, 0, 0, 0, 0, 0, 0, 0,
249 0, 0, 0, 0, 0, 0, 0, 0,
250 0, 0, 0, 0, 0, 0, 0, 0,
251 0, 0, 0, 0, 0, 0, 0, 0,
252 0, 0, 0, 0, 0, 0, 0, 0,
253 0, 0, 0, 0, 0, 0, 0, 0,
254 0, 0, 0, 0, 0, 0, 0, 0,
255 0, 0, 0, 0, 0, 0, 0, 0,
256 0, 0, 0, 0, 0, 0, 0, 0,
257 0, 0, 0, 0, 0, 0, 0, 0,
258 0, 0, 0, 0, 0, 0, 0, 0,
259 0, 0, 0, 0, 0, 0, 0, 0,
260 0, 0, 0, 0, 0, 0, 0, 0,
261 0, 0, 0, 0, 0, 0, 0, 0,
262 0, 0, 0, 0, 0, 0, 0, 0,
263 0, 0, 0, 0, 0, 0, 0, 0,
264 0, 0, 0, 0, 0, 0, 0, 0,
265 0, 0, 0, 0, 0, 0, 0, 0,
266 0, 0, 0, 0, 0, 0, 0, 0,
267 0, 0, 0, 0, 0, 0, 0, 0,
268 0, 0, 0, 0, 0, 0, 0, 0,
269 0, 0, 0, 0, 0, 0, 0, 0,
270 0, 0, 0, 0, 0, 0, 0, 0,
271 /* C0 C1 C2 C3 C4 C5 C6 C7 */
272 0, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
273 /* C8 C9 CA CB CC CD CE CF */
274 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
275 /* D0 D1 D2 D3 D4 D5 D6 D7 */
276 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
277 /* D8 D9 DA DB DC DD DE DF */
278 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
279 /* E0 E1 E2 E3 E4 E5 E6 E7 */
280 0xa0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
281 /* E8 E9 EA EB EC ED EE EF */
282 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
283 /* F0 F1 F2 F3 F4 F5 F6 F7 */
284 0x90, 0x80, 0x80, 0x80, 0x80, 0, 0, 0,
285 0, 0, 0, 0, 0, 0, 0, 0,
286 };
287
288 const uint8_t u8_valid_max_2nd_byte[0x100] = {
289 0, 0, 0, 0, 0, 0, 0, 0,
290 0, 0, 0, 0, 0, 0, 0, 0,
291 0, 0, 0, 0, 0, 0, 0, 0,
292 0, 0, 0, 0, 0, 0, 0, 0,
293 0, 0, 0, 0, 0, 0, 0, 0,
294 0, 0, 0, 0, 0, 0, 0, 0,
295 0, 0, 0, 0, 0, 0, 0, 0,
296 0, 0, 0, 0, 0, 0, 0, 0,
297 0, 0, 0, 0, 0, 0, 0, 0,
298 0, 0, 0, 0, 0, 0, 0, 0,
299 0, 0, 0, 0, 0, 0, 0, 0,
300 0, 0, 0, 0, 0, 0, 0, 0,
301 0, 0, 0, 0, 0, 0, 0, 0,
302 0, 0, 0, 0, 0, 0, 0, 0,
303 0, 0, 0, 0, 0, 0, 0, 0,
304 0, 0, 0, 0, 0, 0, 0, 0,
305 0, 0, 0, 0, 0, 0, 0, 0,
306 0, 0, 0, 0, 0, 0, 0, 0,
307 0, 0, 0, 0, 0, 0, 0, 0,
308 0, 0, 0, 0, 0, 0, 0, 0,
309 0, 0, 0, 0, 0, 0, 0, 0,
310 0, 0, 0, 0, 0, 0, 0, 0,
311 0, 0, 0, 0, 0, 0, 0, 0,
312 0, 0, 0, 0, 0, 0, 0, 0,
313 /* C0 C1 C2 C3 C4 C5 C6 C7 */
314 0, 0, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
315 /* C8 C9 CA CB CC CD CE CF */
316 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
317 /* D0 D1 D2 D3 D4 D5 D6 D7 */
318 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
319 /* D8 D9 DA DB DC DD DE DF */
320 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
321 /* E0 E1 E2 E3 E4 E5 E6 E7 */
322 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
323 /* E8 E9 EA EB EC ED EE EF */
324 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0x9f, 0xbf, 0xbf,
325 /* F0 F1 F2 F3 F4 F5 F6 F7 */
326 0xbf, 0xbf, 0xbf, 0xbf, 0x8f, 0, 0, 0,
327 0, 0, 0, 0, 0, 0, 0, 0,
328 };
329
330
331 /*
332 * The u8_validate() validates on the given UTF-8 character string and
333 * calculate the byte length. It is quite similar to mblen(3C) except that
334 * this will validate against the list of characters if required and
335 * specific to UTF-8 and Unicode.
336 */
337 int
338 u8_validate(char *u8str, size_t n, char **list, int flag, int *errnum)
339 {
340 uchar_t *ib;
341 uchar_t *ibtail;
342 uchar_t **p;
343 uchar_t *s1;
344 uchar_t *s2;
345 uchar_t f;
346 int sz;
347 size_t i;
348 int ret_val;
349 boolean_t second;
350 boolean_t no_need_to_validate_entire;
351 boolean_t check_additional;
352 boolean_t validate_ucs2_range_only;
353
354 if (! u8str)
355 return (0);
356
357 ib = (uchar_t *)u8str;
358 ibtail = ib + n;
359
360 ret_val = 0;
361
362 no_need_to_validate_entire = ! (flag & U8_VALIDATE_ENTIRE);
363 check_additional = flag & U8_VALIDATE_CHECK_ADDITIONAL;
364 validate_ucs2_range_only = flag & U8_VALIDATE_UCS2_RANGE;
365
366 while (ib < ibtail) {
367 /*
368 * The first byte of a UTF-8 character tells how many
369 * bytes will follow for the character. If the first byte
370 * is an illegal byte value or out of range value, we just
371 * return -1 with an appropriate error number.
372 */
373 sz = u8_number_of_bytes[*ib];
374 if (sz == U8_ILLEGAL_CHAR) {
375 *errnum = EILSEQ;
376 return (-1);
377 }
378
379 if (sz == U8_OUT_OF_RANGE_CHAR ||
380 (validate_ucs2_range_only && sz > U8_MAX_BYTES_UCS2)) {
381 *errnum = ERANGE;
382 return (-1);
383 }
384
385 /*
386 * If we don't have enough bytes to check on, that's also
387 * an error. As you can see, we give illegal byte sequence
388 * checking higher priority then EINVAL cases.
389 */
390 if ((ibtail - ib) < sz) {
391 *errnum = EINVAL;
392 return (-1);
393 }
394
395 if (sz == 1) {
396 ib++;
397 ret_val++;
398 } else {
399 /*
400 * Check on the multi-byte UTF-8 character. For more
401 * details on this, see comment added for the used
402 * data structures at the beginning of the file.
403 */
404 f = *ib++;
405 ret_val++;
406 second = B_TRUE;
407 for (i = 1; i < sz; i++) {
408 if (second) {
409 if (*ib < u8_valid_min_2nd_byte[f] ||
410 *ib > u8_valid_max_2nd_byte[f]) {
411 *errnum = EILSEQ;
412 return (-1);
413 }
414 second = B_FALSE;
415 } else if (U8_ILLEGAL_NEXT_BYTE_COMMON(*ib)) {
416 *errnum = EILSEQ;
417 return (-1);
418 }
419 ib++;
420 ret_val++;
421 }
422 }
423
424 if (check_additional) {
425 for (p = (uchar_t **)list, i = 0; p[i]; i++) {
426 s1 = ib - sz;
427 s2 = p[i];
428 while (s1 < ib) {
429 if (*s1 != *s2 || *s2 == '\0')
430 break;
431 s1++;
432 s2++;
433 }
434
435 if (s1 >= ib && *s2 == '\0') {
436 *errnum = EBADF;
437 return (-1);
438 }
439 }
440 }
441
442 if (no_need_to_validate_entire)
443 break;
444 }
445
446 return (ret_val);
447 }
448
449 /*
450 * The do_case_conv() looks at the mapping tables and returns found
451 * bytes if any. If not found, the input bytes are returned. The function
452 * always terminate the return bytes with a null character assuming that
453 * there are plenty of room to do so.
454 *
455 * The case conversions are simple case conversions mapping a character to
456 * another character as specified in the Unicode data. The byte size of
457 * the mapped character could be different from that of the input character.
458 *
459 * The return value is the byte length of the returned character excluding
460 * the terminating null byte.
461 */
462 static size_t
463 do_case_conv(int uv, uchar_t *u8s, uchar_t *s, int sz, boolean_t is_it_toupper)
464 {
465 size_t i;
466 uint16_t b1 = 0;
467 uint16_t b2 = 0;
468 uint16_t b3 = 0;
469 uint16_t b3_tbl;
470 uint16_t b3_base;
471 uint16_t b4 = 0;
472 size_t start_id;
473 size_t end_id;
474
475 /*
476 * At this point, the only possible values for sz are 2, 3, and 4.
477 * The u8s should point to a vector that is well beyond the size of
478 * 5 bytes.
479 */
480 if (sz == 2) {
481 b3 = u8s[0] = s[0];
482 b4 = u8s[1] = s[1];
483 } else if (sz == 3) {
484 b2 = u8s[0] = s[0];
485 b3 = u8s[1] = s[1];
486 b4 = u8s[2] = s[2];
487 } else if (sz == 4) {
488 b1 = u8s[0] = s[0];
489 b2 = u8s[1] = s[1];
490 b3 = u8s[2] = s[2];
491 b4 = u8s[3] = s[3];
492 } else {
493 /* This is not possible but just in case as a fallback. */
494 if (is_it_toupper)
495 *u8s = U8_ASCII_TOUPPER(*s);
496 else
497 *u8s = U8_ASCII_TOLOWER(*s);
498 u8s[1] = '\0';
499
500 return (1);
501 }
502 u8s[sz] = '\0';
503
504 /*
505 * Let's find out if we have a corresponding character.
506 */
507 b1 = u8_common_b1_tbl[uv][b1];
508 if (b1 == U8_TBL_ELEMENT_NOT_DEF)
509 return ((size_t)sz);
510
511 b2 = u8_case_common_b2_tbl[uv][b1][b2];
512 if (b2 == U8_TBL_ELEMENT_NOT_DEF)
513 return ((size_t)sz);
514
515 if (is_it_toupper) {
516 b3_tbl = u8_toupper_b3_tbl[uv][b2][b3].tbl_id;
517 if (b3_tbl == U8_TBL_ELEMENT_NOT_DEF)
518 return ((size_t)sz);
519
520 start_id = u8_toupper_b4_tbl[uv][b3_tbl][b4];
521 end_id = u8_toupper_b4_tbl[uv][b3_tbl][b4 + 1];
522
523 /* Either there is no match or an error at the table. */
524 if (start_id >= end_id || (end_id - start_id) > U8_MB_CUR_MAX)
525 return ((size_t)sz);
526
527 b3_base = u8_toupper_b3_tbl[uv][b2][b3].base;
528
529 for (i = 0; start_id < end_id; start_id++)
530 u8s[i++] = u8_toupper_final_tbl[uv][b3_base + start_id];
531 } else {
532 b3_tbl = u8_tolower_b3_tbl[uv][b2][b3].tbl_id;
533 if (b3_tbl == U8_TBL_ELEMENT_NOT_DEF)
534 return ((size_t)sz);
535
536 start_id = u8_tolower_b4_tbl[uv][b3_tbl][b4];
537 end_id = u8_tolower_b4_tbl[uv][b3_tbl][b4 + 1];
538
539 if (start_id >= end_id || (end_id - start_id) > U8_MB_CUR_MAX)
540 return ((size_t)sz);
541
542 b3_base = u8_tolower_b3_tbl[uv][b2][b3].base;
543
544 for (i = 0; start_id < end_id; start_id++)
545 u8s[i++] = u8_tolower_final_tbl[uv][b3_base + start_id];
546 }
547
548 /*
549 * If i is still zero, that means there is no corresponding character.
550 */
551 if (i == 0)
552 return ((size_t)sz);
553
554 u8s[i] = '\0';
555
556 return (i);
557 }
558
559 /*
560 * The do_case_compare() function compares the two input strings, s1 and s2,
561 * one character at a time doing case conversions if applicable and return
562 * the comparison result as like strcmp().
563 *
564 * Since, in empirical sense, most of text data are 7-bit ASCII characters,
565 * we treat the 7-bit ASCII characters as a special case trying to yield
566 * faster processing time.
567 */
568 static int
569 do_case_compare(size_t uv, uchar_t *s1, uchar_t *s2, size_t n1,
570 size_t n2, boolean_t is_it_toupper, int *errnum)
571 {
572 int f;
573 int sz1;
574 int sz2;
575 size_t j;
576 size_t i1;
577 size_t i2;
578 uchar_t u8s1[U8_MB_CUR_MAX + 1];
579 uchar_t u8s2[U8_MB_CUR_MAX + 1];
580
581 i1 = i2 = 0;
582 while (i1 < n1 && i2 < n2) {
583 /*
584 * Find out what would be the byte length for this UTF-8
585 * character at string s1 and also find out if this is
586 * an illegal start byte or not and if so, issue a proper
587 * error number and yet treat this byte as a character.
588 */
589 sz1 = u8_number_of_bytes[*s1];
590 if (sz1 < 0) {
591 *errnum = EILSEQ;
592 sz1 = 1;
593 }
594
595 /*
596 * For 7-bit ASCII characters mainly, we do a quick case
597 * conversion right at here.
598 *
599 * If we don't have enough bytes for this character, issue
600 * an EINVAL error and use what are available.
601 *
602 * If we have enough bytes, find out if there is
603 * a corresponding uppercase character and if so, copy over
604 * the bytes for a comparison later. If there is no
605 * corresponding uppercase character, then, use what we have
606 * for the comparison.
607 */
608 if (sz1 == 1) {
609 if (is_it_toupper)
610 u8s1[0] = U8_ASCII_TOUPPER(*s1);
611 else
612 u8s1[0] = U8_ASCII_TOLOWER(*s1);
613 s1++;
614 u8s1[1] = '\0';
615 } else if ((i1 + sz1) > n1) {
616 *errnum = EINVAL;
617 for (j = 0; (i1 + j) < n1; )
618 u8s1[j++] = *s1++;
619 u8s1[j] = '\0';
620 } else {
621 (void) do_case_conv(uv, u8s1, s1, sz1, is_it_toupper);
622 s1 += sz1;
623 }
624
625 /* Do the same for the string s2. */
626 sz2 = u8_number_of_bytes[*s2];
627 if (sz2 < 0) {
628 *errnum = EILSEQ;
629 sz2 = 1;
630 }
631
632 if (sz2 == 1) {
633 if (is_it_toupper)
634 u8s2[0] = U8_ASCII_TOUPPER(*s2);
635 else
636 u8s2[0] = U8_ASCII_TOLOWER(*s2);
637 s2++;
638 u8s2[1] = '\0';
639 } else if ((i2 + sz2) > n2) {
640 *errnum = EINVAL;
641 for (j = 0; (i2 + j) < n2; )
642 u8s2[j++] = *s2++;
643 u8s2[j] = '\0';
644 } else {
645 (void) do_case_conv(uv, u8s2, s2, sz2, is_it_toupper);
646 s2 += sz2;
647 }
648
649 /* Now compare the two characters. */
650 if (sz1 == 1 && sz2 == 1) {
651 if (*u8s1 > *u8s2)
652 return (1);
653 if (*u8s1 < *u8s2)
654 return (-1);
655 } else {
656 f = strcmp((const char *)u8s1, (const char *)u8s2);
657 if (f != 0)
658 return (f);
659 }
660
661 /*
662 * They were the same. Let's move on to the next
663 * characters then.
664 */
665 i1 += sz1;
666 i2 += sz2;
667 }
668
669 /*
670 * We compared until the end of either or both strings.
671 *
672 * If we reached to or went over the ends for the both, that means
673 * they are the same.
674 *
675 * If we reached only one of the two ends, that means the other string
676 * has something which then the fact can be used to determine
677 * the return value.
678 */
679 if (i1 >= n1) {
680 if (i2 >= n2)
681 return (0);
682 return (-1);
683 }
684 return (1);
685 }
686
687 /*
688 * The combining_class() function checks on the given bytes and find out
689 * the corresponding Unicode combining class value. The return value 0 means
690 * it is a Starter. Any illegal UTF-8 character will also be treated as
691 * a Starter.
692 */
693 static uchar_t
694 combining_class(size_t uv, uchar_t *s, size_t sz)
695 {
696 uint16_t b1 = 0;
697 uint16_t b2 = 0;
698 uint16_t b3 = 0;
699 uint16_t b4 = 0;
700
701 if (sz == 1 || sz > 4)
702 return (0);
703
704 if (sz == 2) {
705 b3 = s[0];
706 b4 = s[1];
707 } else if (sz == 3) {
708 b2 = s[0];
709 b3 = s[1];
710 b4 = s[2];
711 } else if (sz == 4) {
712 b1 = s[0];
713 b2 = s[1];
714 b3 = s[2];
715 b4 = s[3];
716 }
717
718 b1 = u8_common_b1_tbl[uv][b1];
719 if (b1 == U8_TBL_ELEMENT_NOT_DEF)
720 return (0);
721
722 b2 = u8_combining_class_b2_tbl[uv][b1][b2];
723 if (b2 == U8_TBL_ELEMENT_NOT_DEF)
724 return (0);
725
726 b3 = u8_combining_class_b3_tbl[uv][b2][b3];
727 if (b3 == U8_TBL_ELEMENT_NOT_DEF)
728 return (0);
729
730 return (u8_combining_class_b4_tbl[uv][b3][b4]);
731 }
732
733 /*
734 * The do_decomp() function finds out a matching decomposition if any
735 * and return. If there is no match, the input bytes are copied and returned.
736 * The function also checks if there is a Hangul, decomposes it if necessary
737 * and returns.
738 *
739 * To save time, a single byte 7-bit ASCII character should be handled by
740 * the caller.
741 *
742 * The function returns the number of bytes returned sans always terminating
743 * the null byte. It will also return a state that will tell if there was
744 * a Hangul character decomposed which then will be used by the caller.
745 */
746 static size_t
747 do_decomp(size_t uv, uchar_t *u8s, uchar_t *s, int sz,
748 boolean_t canonical_decomposition, u8_normalization_states_t *state)
749 {
750 uint16_t b1 = 0;
751 uint16_t b2 = 0;
752 uint16_t b3 = 0;
753 uint16_t b3_tbl;
754 uint16_t b3_base;
755 uint16_t b4 = 0;
756 size_t start_id;
757 size_t end_id;
758 size_t i;
759 uint32_t u1;
760
761 if (sz == 2) {
762 b3 = u8s[0] = s[0];
763 b4 = u8s[1] = s[1];
764 u8s[2] = '\0';
765 } else if (sz == 3) {
766 /* Convert it to a Unicode scalar value. */
767 U8_PUT_3BYTES_INTO_UTF32(u1, s[0], s[1], s[2]);
768
769 /*
770 * If this is a Hangul syllable, we decompose it into
771 * a leading consonant, a vowel, and an optional trailing
772 * consonant and then return.
773 */
774 if (U8_HANGUL_SYLLABLE(u1)) {
775 u1 -= U8_HANGUL_SYL_FIRST;
776
777 b1 = U8_HANGUL_JAMO_L_FIRST + u1 / U8_HANGUL_VT_COUNT;
778 b2 = U8_HANGUL_JAMO_V_FIRST + (u1 % U8_HANGUL_VT_COUNT)
779 / U8_HANGUL_T_COUNT;
780 b3 = u1 % U8_HANGUL_T_COUNT;
781
782 U8_SAVE_HANGUL_AS_UTF8(u8s, 0, 1, 2, b1);
783 U8_SAVE_HANGUL_AS_UTF8(u8s, 3, 4, 5, b2);
784 if (b3) {
785 b3 += U8_HANGUL_JAMO_T_FIRST;
786 U8_SAVE_HANGUL_AS_UTF8(u8s, 6, 7, 8, b3);
787
788 u8s[9] = '\0';
789 *state = U8_STATE_HANGUL_LVT;
790 return (9);
791 }
792
793 u8s[6] = '\0';
794 *state = U8_STATE_HANGUL_LV;
795 return (6);
796 }
797
798 b2 = u8s[0] = s[0];
799 b3 = u8s[1] = s[1];
800 b4 = u8s[2] = s[2];
801 u8s[3] = '\0';
802
803 /*
804 * If this is a Hangul Jamo, we know there is nothing
805 * further that we can decompose.
806 */
807 if (U8_HANGUL_JAMO_L(u1)) {
808 *state = U8_STATE_HANGUL_L;
809 return (3);
810 }
811
812 if (U8_HANGUL_JAMO_V(u1)) {
813 if (*state == U8_STATE_HANGUL_L)
814 *state = U8_STATE_HANGUL_LV;
815 else
816 *state = U8_STATE_HANGUL_V;
817 return (3);
818 }
819
820 if (U8_HANGUL_JAMO_T(u1)) {
821 if (*state == U8_STATE_HANGUL_LV)
822 *state = U8_STATE_HANGUL_LVT;
823 else
824 *state = U8_STATE_HANGUL_T;
825 return (3);
826 }
827 } else if (sz == 4) {
828 b1 = u8s[0] = s[0];
829 b2 = u8s[1] = s[1];
830 b3 = u8s[2] = s[2];
831 b4 = u8s[3] = s[3];
832 u8s[4] = '\0';
833 } else {
834 /*
835 * This is a fallback and should not happen if the function
836 * was called properly.
837 */
838 u8s[0] = s[0];
839 u8s[1] = '\0';
840 *state = U8_STATE_START;
841 return (1);
842 }
843
844 /*
845 * At this point, this rountine does not know what it would get.
846 * The caller should sort it out if the state isn't a Hangul one.
847 */
848 *state = U8_STATE_START;
849
850 /* Try to find matching decomposition mapping byte sequence. */
851 b1 = u8_common_b1_tbl[uv][b1];
852 if (b1 == U8_TBL_ELEMENT_NOT_DEF)
853 return ((size_t)sz);
854
855 b2 = u8_decomp_b2_tbl[uv][b1][b2];
856 if (b2 == U8_TBL_ELEMENT_NOT_DEF)
857 return ((size_t)sz);
858
859 b3_tbl = u8_decomp_b3_tbl[uv][b2][b3].tbl_id;
860 if (b3_tbl == U8_TBL_ELEMENT_NOT_DEF)
861 return ((size_t)sz);
862
863 /*
864 * If b3_tbl is bigger than or equal to U8_16BIT_TABLE_INDICATOR
865 * which is 0x8000, this means we couldn't fit the mappings into
866 * the cardinality of a unsigned byte.
867 */
868 if (b3_tbl >= U8_16BIT_TABLE_INDICATOR) {
869 b3_tbl -= U8_16BIT_TABLE_INDICATOR;
870 start_id = u8_decomp_b4_16bit_tbl[uv][b3_tbl][b4];
871 end_id = u8_decomp_b4_16bit_tbl[uv][b3_tbl][b4 + 1];
872 } else {
873 start_id = u8_decomp_b4_tbl[uv][b3_tbl][b4];
874 end_id = u8_decomp_b4_tbl[uv][b3_tbl][b4 + 1];
875 }
876
877 /* This also means there wasn't any matching decomposition. */
878 if (start_id >= end_id)
879 return ((size_t)sz);
880
881 /*
882 * The final table for decomposition mappings has three types of
883 * byte sequences depending on whether a mapping is for compatibility
884 * decomposition, canonical decomposition, or both like the following:
885 *
886 * (1) Compatibility decomposition mappings:
887 *
888 * +---+---+-...-+---+
889 * | B0| B1| ... | Bm|
890 * +---+---+-...-+---+
891 *
892 * The first byte, B0, is always less then 0xF5 (U8_DECOMP_BOTH).
893 *
894 * (2) Canonical decomposition mappings:
895 *
896 * +---+---+---+-...-+---+
897 * | T | b0| b1| ... | bn|
898 * +---+---+---+-...-+---+
899 *
900 * where the first byte, T, is 0xF6 (U8_DECOMP_CANONICAL).
901 *
902 * (3) Both mappings:
903 *
904 * +---+---+---+---+-...-+---+---+---+-...-+---+
905 * | T | D | b0| b1| ... | bn| B0| B1| ... | Bm|
906 * +---+---+---+---+-...-+---+---+---+-...-+---+
907 *
908 * where T is 0xF5 (U8_DECOMP_BOTH) and D is a displacement
909 * byte, b0 to bn are canonical mapping bytes and B0 to Bm are
910 * compatibility mapping bytes.
911 *
912 * Note that compatibility decomposition means doing recursive
913 * decompositions using both compatibility decomposition mappings and
914 * canonical decomposition mappings. On the other hand, canonical
915 * decomposition means doing recursive decompositions using only
916 * canonical decomposition mappings. Since the table we have has gone
917 * through the recursions already, we do not need to do so during
918 * runtime, i.e., the table has been completely flattened out
919 * already.
920 */
921
922 b3_base = u8_decomp_b3_tbl[uv][b2][b3].base;
923
924 /* Get the type, T, of the byte sequence. */
925 b1 = u8_decomp_final_tbl[uv][b3_base + start_id];
926
927 /*
928 * If necessary, adjust start_id, end_id, or both. Note that if
929 * this is compatibility decomposition mapping, there is no
930 * adjustment.
931 */
932 if (canonical_decomposition) {
933 /* Is the mapping only for compatibility decomposition? */
934 if (b1 < U8_DECOMP_BOTH)
935 return ((size_t)sz);
936
937 start_id++;
938
939 if (b1 == U8_DECOMP_BOTH) {
940 end_id = start_id +
941 u8_decomp_final_tbl[uv][b3_base + start_id];
942 start_id++;
943 }
944 } else {
945 /*
946 * Unless this is a compatibility decomposition mapping,
947 * we adjust the start_id.
948 */
949 if (b1 == U8_DECOMP_BOTH) {
950 start_id++;
951 start_id += u8_decomp_final_tbl[uv][b3_base + start_id];
952 } else if (b1 == U8_DECOMP_CANONICAL) {
953 start_id++;
954 }
955 }
956
957 for (i = 0; start_id < end_id; start_id++)
958 u8s[i++] = u8_decomp_final_tbl[uv][b3_base + start_id];
959 u8s[i] = '\0';
960
961 return (i);
962 }
963
964 /*
965 * The find_composition_start() function uses the character bytes given and
966 * find out the matching composition mappings if any and return the address
967 * to the composition mappings as explained in the do_composition().
968 */
969 static uchar_t *
970 find_composition_start(size_t uv, uchar_t *s, size_t sz)
971 {
972 uint16_t b1 = 0;
973 uint16_t b2 = 0;
974 uint16_t b3 = 0;
975 uint16_t b3_tbl;
976 uint16_t b3_base;
977 uint16_t b4 = 0;
978 size_t start_id;
979 size_t end_id;
980
981 if (sz == 1) {
982 b4 = s[0];
983 } else if (sz == 2) {
984 b3 = s[0];
985 b4 = s[1];
986 } else if (sz == 3) {
987 b2 = s[0];
988 b3 = s[1];
989 b4 = s[2];
990 } else if (sz == 4) {
991 b1 = s[0];
992 b2 = s[1];
993 b3 = s[2];
994 b4 = s[3];
995 } else {
996 /*
997 * This is a fallback and should not happen if the function
998 * was called properly.
999 */
1000 return (NULL);
1001 }
1002
1003 b1 = u8_composition_b1_tbl[uv][b1];
1004 if (b1 == U8_TBL_ELEMENT_NOT_DEF)
1005 return (NULL);
1006
1007 b2 = u8_composition_b2_tbl[uv][b1][b2];
1008 if (b2 == U8_TBL_ELEMENT_NOT_DEF)
1009 return (NULL);
1010
1011 b3_tbl = u8_composition_b3_tbl[uv][b2][b3].tbl_id;
1012 if (b3_tbl == U8_TBL_ELEMENT_NOT_DEF)
1013 return (NULL);
1014
1015 if (b3_tbl >= U8_16BIT_TABLE_INDICATOR) {
1016 b3_tbl -= U8_16BIT_TABLE_INDICATOR;
1017 start_id = u8_composition_b4_16bit_tbl[uv][b3_tbl][b4];
1018 end_id = u8_composition_b4_16bit_tbl[uv][b3_tbl][b4 + 1];
1019 } else {
1020 start_id = u8_composition_b4_tbl[uv][b3_tbl][b4];
1021 end_id = u8_composition_b4_tbl[uv][b3_tbl][b4 + 1];
1022 }
1023
1024 if (start_id >= end_id)
1025 return (NULL);
1026
1027 b3_base = u8_composition_b3_tbl[uv][b2][b3].base;
1028
1029 return ((uchar_t *)&(u8_composition_final_tbl[uv][b3_base + start_id]));
1030 }
1031
1032 /*
1033 * The blocked() function checks on the combining class values of previous
1034 * characters in this sequence and return whether it is blocked or not.
1035 */
1036 static boolean_t
1037 blocked(uchar_t *comb_class, size_t last)
1038 {
1039 uchar_t my_comb_class;
1040 size_t i;
1041
1042 my_comb_class = comb_class[last];
1043 for (i = 1; i < last; i++)
1044 if (comb_class[i] >= my_comb_class ||
1045 comb_class[i] == U8_COMBINING_CLASS_STARTER)
1046 return (B_TRUE);
1047
1048 return (B_FALSE);
1049 }
1050
1051 /*
1052 * The do_composition() reads the character string pointed by 's' and
1053 * do necessary canonical composition and then copy over the result back to
1054 * the 's'.
1055 *
1056 * The input argument 's' cannot contain more than 32 characters.
1057 */
1058 static size_t
1059 do_composition(size_t uv, uchar_t *s, uchar_t *comb_class, uchar_t *start,
1060 uchar_t *disp, size_t last, uchar_t **os, uchar_t *oslast)
1061 {
1062 uchar_t t[U8_STREAM_SAFE_TEXT_MAX + 1];
1063 uchar_t tc[U8_MB_CUR_MAX];
1064 uint8_t saved_marks[U8_MAX_CHARS_A_SEQ];
1065 size_t saved_marks_count;
1066 uchar_t *p;
1067 uchar_t *saved_p;
1068 uchar_t *q;
1069 size_t i;
1070 size_t saved_i;
1071 size_t j;
1072 size_t k;
1073 size_t l;
1074 size_t C;
1075 size_t saved_l;
1076 size_t size;
1077 uint32_t u1;
1078 uint32_t u2;
1079 boolean_t match_not_found = B_TRUE;
1080
1081 /*
1082 * This should never happen unless the callers are doing some strange
1083 * and unexpected things.
1084 *
1085 * The "last" is the index pointing to the last character not last + 1.
1086 */
1087 if (last >= U8_MAX_CHARS_A_SEQ)
1088 last = U8_UPPER_LIMIT_IN_A_SEQ;
1089
1090 for (i = l = 0; i <= last; i++) {
1091 /*
1092 * The last or any non-Starters at the beginning, we don't
1093 * have any chance to do composition and so we just copy them
1094 * to the temporary buffer.
1095 */
1096 if (i >= last || comb_class[i] != U8_COMBINING_CLASS_STARTER) {
1097 SAVE_THE_CHAR:
1098 p = s + start[i];
1099 size = disp[i];
1100 for (k = 0; k < size; k++)
1101 t[l++] = *p++;
1102 continue;
1103 }
1104
1105 /*
1106 * If this could be a start of Hangul Jamos, then, we try to
1107 * conjoin them.
1108 */
1109 if (s[start[i]] == U8_HANGUL_JAMO_1ST_BYTE) {
1110 U8_PUT_3BYTES_INTO_UTF32(u1, s[start[i]],
1111 s[start[i] + 1], s[start[i] + 2]);
1112 U8_PUT_3BYTES_INTO_UTF32(u2, s[start[i] + 3],
1113 s[start[i] + 4], s[start[i] + 5]);
1114
1115 if (U8_HANGUL_JAMO_L(u1) && U8_HANGUL_JAMO_V(u2)) {
1116 u1 -= U8_HANGUL_JAMO_L_FIRST;
1117 u2 -= U8_HANGUL_JAMO_V_FIRST;
1118 u1 = U8_HANGUL_SYL_FIRST +
1119 (u1 * U8_HANGUL_V_COUNT + u2) *
1120 U8_HANGUL_T_COUNT;
1121
1122 i += 2;
1123 if (i <= last) {
1124 U8_PUT_3BYTES_INTO_UTF32(u2,
1125 s[start[i]], s[start[i] + 1],
1126 s[start[i] + 2]);
1127
1128 if (U8_HANGUL_JAMO_T(u2)) {
1129 u1 += u2 -
1130 U8_HANGUL_JAMO_T_FIRST;
1131 i++;
1132 }
1133 }
1134
1135 U8_SAVE_HANGUL_AS_UTF8(t + l, 0, 1, 2, u1);
1136 i--;
1137 l += 3;
1138 continue;
1139 }
1140 }
1141
1142 /*
1143 * Let's then find out if this Starter has composition
1144 * mapping.
1145 */
1146 p = find_composition_start(uv, s + start[i], disp[i]);
1147 if (p == NULL)
1148 goto SAVE_THE_CHAR;
1149
1150 /*
1151 * We have a Starter with composition mapping and the next
1152 * character is a non-Starter. Let's try to find out if
1153 * we can do composition.
1154 */
1155
1156 saved_p = p;
1157 saved_i = i;
1158 saved_l = l;
1159 saved_marks_count = 0;
1160
1161 TRY_THE_NEXT_MARK:
1162 q = s + start[++i];
1163 size = disp[i];
1164
1165 /*
1166 * The next for() loop compares the non-Starter pointed by
1167 * 'q' with the possible (joinable) characters pointed by 'p'.
1168 *
1169 * The composition final table entry pointed by the 'p'
1170 * looks like the following:
1171 *
1172 * +---+---+---+-...-+---+---+---+---+-...-+---+---+
1173 * | C | b0| b2| ... | bn| F | B0| B1| ... | Bm| F |
1174 * +---+---+---+-...-+---+---+---+---+-...-+---+---+
1175 *
1176 * where C is the count byte indicating the number of
1177 * mapping pairs where each pair would be look like
1178 * (b0-bn F, B0-Bm F). The b0-bn are the bytes of the second
1179 * character of a canonical decomposition and the B0-Bm are
1180 * the bytes of a matching composite character. The F is
1181 * a filler byte after each character as the separator.
1182 */
1183
1184 match_not_found = B_TRUE;
1185
1186 for (C = *p++; C > 0; C--) {
1187 for (k = 0; k < size; p++, k++)
1188 if (*p != q[k])
1189 break;
1190
1191 /* Have we found it? */
1192 if (k >= size && *p == U8_TBL_ELEMENT_FILLER) {
1193 match_not_found = B_FALSE;
1194
1195 l = saved_l;
1196
1197 while (*++p != U8_TBL_ELEMENT_FILLER)
1198 t[l++] = *p;
1199
1200 break;
1201 }
1202
1203 /* We didn't find; skip to the next pair. */
1204 if (*p != U8_TBL_ELEMENT_FILLER)
1205 while (*++p != U8_TBL_ELEMENT_FILLER)
1206 ;
1207 while (*++p != U8_TBL_ELEMENT_FILLER)
1208 ;
1209 p++;
1210 }
1211
1212 /*
1213 * If there was no match, we will need to save the combining
1214 * mark for later appending. After that, if the next one
1215 * is a non-Starter and not blocked, then, we try once
1216 * again to do composition with the next non-Starter.
1217 *
1218 * If there was no match and this was a Starter, then,
1219 * this is a new start.
1220 *
1221 * If there was a match and a composition done and we have
1222 * more to check on, then, we retrieve a new composition final
1223 * table entry for the composite and then try to do the
1224 * composition again.
1225 */
1226
1227 if (match_not_found) {
1228 if (comb_class[i] == U8_COMBINING_CLASS_STARTER) {
1229 i--;
1230 goto SAVE_THE_CHAR;
1231 }
1232
1233 saved_marks[saved_marks_count++] = i;
1234 }
1235
1236 if (saved_l == l) {
1237 while (i < last) {
1238 if (blocked(comb_class, i + 1))
1239 saved_marks[saved_marks_count++] = ++i;
1240 else
1241 break;
1242 }
1243 if (i < last) {
1244 p = saved_p;
1245 goto TRY_THE_NEXT_MARK;
1246 }
1247 } else if (i < last) {
1248 p = find_composition_start(uv, t + saved_l,
1249 l - saved_l);
1250 if (p != NULL) {
1251 saved_p = p;
1252 goto TRY_THE_NEXT_MARK;
1253 }
1254 }
1255
1256 /*
1257 * There is no more composition possible.
1258 *
1259 * If there was no composition what so ever then we copy
1260 * over the original Starter and then append any non-Starters
1261 * remaining at the target string sequentially after that.
1262 */
1263
1264 if (saved_l == l) {
1265 p = s + start[saved_i];
1266 size = disp[saved_i];
1267 for (j = 0; j < size; j++)
1268 t[l++] = *p++;
1269 }
1270
1271 for (k = 0; k < saved_marks_count; k++) {
1272 p = s + start[saved_marks[k]];
1273 size = disp[saved_marks[k]];
1274 for (j = 0; j < size; j++)
1275 t[l++] = *p++;
1276 }
1277 }
1278
1279 /*
1280 * If the last character is a Starter and if we have a character
1281 * (possibly another Starter) that can be turned into a composite,
1282 * we do so and we do so until there is no more of composition
1283 * possible.
1284 */
1285 if (comb_class[last] == U8_COMBINING_CLASS_STARTER) {
1286 p = *os;
1287 saved_l = l - disp[last];
1288
1289 while (p < oslast) {
1290 size = u8_number_of_bytes[*p];
1291 if (size <= 1 || (p + size) > oslast)
1292 break;
1293
1294 saved_p = p;
1295
1296 for (i = 0; i < size; i++)
1297 tc[i] = *p++;
1298
1299 q = find_composition_start(uv, t + saved_l,
1300 l - saved_l);
1301 if (q == NULL) {
1302 p = saved_p;
1303 break;
1304 }
1305
1306 match_not_found = B_TRUE;
1307
1308 for (C = *q++; C > 0; C--) {
1309 for (k = 0; k < size; q++, k++)
1310 if (*q != tc[k])
1311 break;
1312
1313 if (k >= size && *q == U8_TBL_ELEMENT_FILLER) {
1314 match_not_found = B_FALSE;
1315
1316 l = saved_l;
1317
1318 while (*++q != U8_TBL_ELEMENT_FILLER) {
1319 /*
1320 * This is practically
1321 * impossible but we don't
1322 * want to take any chances.
1323 */
1324 if (l >=
1325 U8_STREAM_SAFE_TEXT_MAX) {
1326 p = saved_p;
1327 goto SAFE_RETURN;
1328 }
1329 t[l++] = *q;
1330 }
1331
1332 break;
1333 }
1334
1335 if (*q != U8_TBL_ELEMENT_FILLER)
1336 while (*++q != U8_TBL_ELEMENT_FILLER)
1337 ;
1338 while (*++q != U8_TBL_ELEMENT_FILLER)
1339 ;
1340 q++;
1341 }
1342
1343 if (match_not_found) {
1344 p = saved_p;
1345 break;
1346 }
1347 }
1348 SAFE_RETURN:
1349 *os = p;
1350 }
1351
1352 /*
1353 * Now we copy over the temporary string to the target string.
1354 * Since composition always reduces the number of characters or
1355 * the number of characters stay, we don't need to worry about
1356 * the buffer overflow here.
1357 */
1358 for (i = 0; i < l; i++)
1359 s[i] = t[i];
1360 s[l] = '\0';
1361
1362 return (l);
1363 }
1364
1365 /*
1366 * The collect_a_seq() function checks on the given string s, collect
1367 * a sequence of characters at u8s, and return the sequence. While it collects
1368 * a sequence, it also applies case conversion, canonical or compatibility
1369 * decomposition, canonical decomposition, or some or all of them and
1370 * in that order.
1371 *
1372 * The collected sequence cannot be bigger than 32 characters since if
1373 * it is having more than 31 characters, the sequence will be terminated
1374 * with a U+034F COMBINING GRAPHEME JOINER (CGJ) character and turned into
1375 * a Stream-Safe Text. The collected sequence is always terminated with
1376 * a null byte and the return value is the byte length of the sequence
1377 * including 0. The return value does not include the terminating
1378 * null byte.
1379 */
1380 static size_t
1381 collect_a_seq(size_t uv, uchar_t *u8s, uchar_t **source, uchar_t *slast,
1382 boolean_t is_it_toupper,
1383 boolean_t is_it_tolower,
1384 boolean_t canonical_decomposition,
1385 boolean_t compatibility_decomposition,
1386 boolean_t canonical_composition,
1387 int *errnum, u8_normalization_states_t *state)
1388 {
1389 uchar_t *s;
1390 int sz;
1391 int saved_sz;
1392 size_t i;
1393 size_t j;
1394 size_t k;
1395 size_t l;
1396 uchar_t comb_class[U8_MAX_CHARS_A_SEQ];
1397 uchar_t disp[U8_MAX_CHARS_A_SEQ];
1398 uchar_t start[U8_MAX_CHARS_A_SEQ];
1399 uchar_t u8t[U8_MB_CUR_MAX];
1400 uchar_t uts[U8_STREAM_SAFE_TEXT_MAX + 1];
1401 uchar_t tc;
1402 size_t last;
1403 size_t saved_last;
1404 uint32_t u1;
1405
1406 /*
1407 * Save the source string pointer which we will return a changed
1408 * pointer if we do processing.
1409 */
1410 s = *source;
1411
1412 /*
1413 * The following is a fallback for just in case callers are not
1414 * checking the string boundaries before the calling.
1415 */
1416 if (s >= slast) {
1417 u8s[0] = '\0';
1418
1419 return (0);
1420 }
1421
1422 /*
1423 * As the first thing, let's collect a character and do case
1424 * conversion if necessary.
1425 */
1426
1427 sz = u8_number_of_bytes[*s];
1428
1429 if (sz < 0) {
1430 *errnum = EILSEQ;
1431
1432 u8s[0] = *s++;
1433 u8s[1] = '\0';
1434
1435 *source = s;
1436
1437 return (1);
1438 }
1439
1440 if (sz == 1) {
1441 if (is_it_toupper)
1442 u8s[0] = U8_ASCII_TOUPPER(*s);
1443 else if (is_it_tolower)
1444 u8s[0] = U8_ASCII_TOLOWER(*s);
1445 else
1446 u8s[0] = *s;
1447 s++;
1448 u8s[1] = '\0';
1449 } else if ((s + sz) > slast) {
1450 *errnum = EINVAL;
1451
1452 for (i = 0; s < slast; )
1453 u8s[i++] = *s++;
1454 u8s[i] = '\0';
1455
1456 *source = s;
1457
1458 return (i);
1459 } else {
1460 if (is_it_toupper || is_it_tolower) {
1461 i = do_case_conv(uv, u8s, s, sz, is_it_toupper);
1462 s += sz;
1463 sz = i;
1464 } else {
1465 for (i = 0; i < sz; )
1466 u8s[i++] = *s++;
1467 u8s[i] = '\0';
1468 }
1469 }
1470
1471 /*
1472 * And then canonical/compatibility decomposition followed by
1473 * an optional canonical composition. Please be noted that
1474 * canonical composition is done only when a decomposition is
1475 * done.
1476 */
1477 if (canonical_decomposition || compatibility_decomposition) {
1478 if (sz == 1) {
1479 *state = U8_STATE_START;
1480
1481 saved_sz = 1;
1482
1483 comb_class[0] = 0;
1484 start[0] = 0;
1485 disp[0] = 1;
1486
1487 last = 1;
1488 } else {
1489 saved_sz = do_decomp(uv, u8s, u8s, sz,
1490 canonical_decomposition, state);
1491
1492 last = 0;
1493
1494 for (i = 0; i < saved_sz; ) {
1495 sz = u8_number_of_bytes[u8s[i]];
1496
1497 comb_class[last] = combining_class(uv,
1498 u8s + i, sz);
1499 start[last] = i;
1500 disp[last] = sz;
1501
1502 last++;
1503 i += sz;
1504 }
1505
1506 /*
1507 * Decomposition yields various Hangul related
1508 * states but not on combining marks. We need to
1509 * find out at here by checking on the last
1510 * character.
1511 */
1512 if (*state == U8_STATE_START) {
1513 if (comb_class[last - 1])
1514 *state = U8_STATE_COMBINING_MARK;
1515 }
1516 }
1517
1518 saved_last = last;
1519
1520 while (s < slast) {
1521 sz = u8_number_of_bytes[*s];
1522
1523 /*
1524 * If this is an illegal character, an incomplete
1525 * character, or an 7-bit ASCII Starter character,
1526 * then we have collected a sequence; break and let
1527 * the next call deal with the two cases.
1528 *
1529 * Note that this is okay only if you are using this
1530 * function with a fixed length string, not on
1531 * a buffer with multiple calls of one chunk at a time.
1532 */
1533 if (sz <= 1) {
1534 break;
1535 } else if ((s + sz) > slast) {
1536 break;
1537 } else {
1538 /*
1539 * If the previous character was a Hangul Jamo
1540 * and this character is a Hangul Jamo that
1541 * can be conjoined, we collect the Jamo.
1542 */
1543 if (*s == U8_HANGUL_JAMO_1ST_BYTE) {
1544 U8_PUT_3BYTES_INTO_UTF32(u1,
1545 *s, *(s + 1), *(s + 2));
1546
1547 if (U8_HANGUL_COMPOSABLE_L_V(*state,
1548 u1)) {
1549 i = 0;
1550 *state = U8_STATE_HANGUL_LV;
1551 goto COLLECT_A_HANGUL;
1552 }
1553
1554 if (U8_HANGUL_COMPOSABLE_LV_T(*state,
1555 u1)) {
1556 i = 0;
1557 *state = U8_STATE_HANGUL_LVT;
1558 goto COLLECT_A_HANGUL;
1559 }
1560 }
1561
1562 /*
1563 * Regardless of whatever it was, if this is
1564 * a Starter, we don't collect the character
1565 * since that's a new start and we will deal
1566 * with it at the next time.
1567 */
1568 i = combining_class(uv, s, sz);
1569 if (i == U8_COMBINING_CLASS_STARTER)
1570 break;
1571
1572 /*
1573 * We know the current character is a combining
1574 * mark. If the previous character wasn't
1575 * a Starter (not Hangul) or a combining mark,
1576 * then, we don't collect this combining mark.
1577 */
1578 if (*state != U8_STATE_START &&
1579 *state != U8_STATE_COMBINING_MARK)
1580 break;
1581
1582 *state = U8_STATE_COMBINING_MARK;
1583 COLLECT_A_HANGUL:
1584 /*
1585 * If we collected a Starter and combining
1586 * marks up to 30, i.e., total 31 characters,
1587 * then, we terminate this degenerately long
1588 * combining sequence with a U+034F COMBINING
1589 * GRAPHEME JOINER (CGJ) which is 0xCD 0x8F in
1590 * UTF-8 and turn this into a Stream-Safe
1591 * Text. This will be extremely rare but
1592 * possible.
1593 *
1594 * The following will also guarantee that
1595 * we are not writing more than 32 characters
1596 * plus a NULL at u8s[].
1597 */
1598 if (last >= U8_UPPER_LIMIT_IN_A_SEQ) {
1599 TURN_STREAM_SAFE:
1600 *state = U8_STATE_START;
1601 comb_class[last] = 0;
1602 start[last] = saved_sz;
1603 disp[last] = 2;
1604 last++;
1605
1606 u8s[saved_sz++] = 0xCD;
1607 u8s[saved_sz++] = 0x8F;
1608
1609 break;
1610 }
1611
1612 /*
1613 * Some combining marks also do decompose into
1614 * another combining mark or marks.
1615 */
1616 if (*state == U8_STATE_COMBINING_MARK) {
1617 k = last;
1618 l = sz;
1619 i = do_decomp(uv, uts, s, sz,
1620 canonical_decomposition, state);
1621 for (j = 0; j < i; ) {
1622 sz = u8_number_of_bytes[uts[j]];
1623
1624 comb_class[last] =
1625 combining_class(uv,
1626 uts + j, sz);
1627 start[last] = saved_sz + j;
1628 disp[last] = sz;
1629
1630 last++;
1631 if (last >=
1632 U8_UPPER_LIMIT_IN_A_SEQ) {
1633 last = k;
1634 goto TURN_STREAM_SAFE;
1635 }
1636 j += sz;
1637 }
1638
1639 *state = U8_STATE_COMBINING_MARK;
1640 sz = i;
1641 s += l;
1642
1643 for (i = 0; i < sz; i++)
1644 u8s[saved_sz++] = uts[i];
1645 } else {
1646 comb_class[last] = i;
1647 start[last] = saved_sz;
1648 disp[last] = sz;
1649 last++;
1650
1651 for (i = 0; i < sz; i++)
1652 u8s[saved_sz++] = *s++;
1653 }
1654
1655 /*
1656 * If this is U+0345 COMBINING GREEK
1657 * YPOGEGRAMMENI (0xCD 0x85 in UTF-8), a.k.a.,
1658 * iota subscript, and need to be converted to
1659 * uppercase letter, convert it to U+0399 GREEK
1660 * CAPITAL LETTER IOTA (0xCE 0x99 in UTF-8),
1661 * i.e., convert to capital adscript form as
1662 * specified in the Unicode standard.
1663 *
1664 * This is the only special case of (ambiguous)
1665 * case conversion at combining marks and
1666 * probably the standard will never have
1667 * anything similar like this in future.
1668 */
1669 if (is_it_toupper && sz >= 2 &&
1670 u8s[saved_sz - 2] == 0xCD &&
1671 u8s[saved_sz - 1] == 0x85) {
1672 u8s[saved_sz - 2] = 0xCE;
1673 u8s[saved_sz - 1] = 0x99;
1674 }
1675 }
1676 }
1677
1678 /*
1679 * Let's try to ensure a canonical ordering for the collected
1680 * combining marks. We do this only if we have collected
1681 * at least one more non-Starter. (The decomposition mapping
1682 * data tables have fully (and recursively) expanded and
1683 * canonically ordered decompositions.)
1684 *
1685 * The U8_SWAP_COMB_MARKS() convenience macro has some
1686 * assumptions and we are meeting the assumptions.
1687 */
1688 last--;
1689 if (last >= saved_last) {
1690 for (i = 0; i < last; i++)
1691 for (j = last; j > i; j--)
1692 if (comb_class[j] &&
1693 comb_class[j - 1] > comb_class[j]) {
1694 U8_SWAP_COMB_MARKS(j - 1, j);
1695 }
1696 }
1697
1698 *source = s;
1699
1700 if (! canonical_composition) {
1701 u8s[saved_sz] = '\0';
1702 return (saved_sz);
1703 }
1704
1705 /*
1706 * Now do the canonical composition. Note that we do this
1707 * only after a canonical or compatibility decomposition to
1708 * finish up NFC or NFKC.
1709 */
1710 sz = do_composition(uv, u8s, comb_class, start, disp, last,
1711 &s, slast);
1712 }
1713
1714 *source = s;
1715
1716 return ((size_t)sz);
1717 }
1718
1719 /*
1720 * The do_norm_compare() function does string comparion based on Unicode
1721 * simple case mappings and Unicode Normalization definitions.
1722 *
1723 * It does so by collecting a sequence of character at a time and comparing
1724 * the collected sequences from the strings.
1725 *
1726 * The meanings on the return values are the same as the usual strcmp().
1727 */
1728 static int
1729 do_norm_compare(size_t uv, uchar_t *s1, uchar_t *s2, size_t n1, size_t n2,
1730 int flag, int *errnum)
1731 {
1732 int result;
1733 size_t sz1;
1734 size_t sz2;
1735 uchar_t u8s1[U8_STREAM_SAFE_TEXT_MAX + 1];
1736 uchar_t u8s2[U8_STREAM_SAFE_TEXT_MAX + 1];
1737 uchar_t *s1last;
1738 uchar_t *s2last;
1739 boolean_t is_it_toupper;
1740 boolean_t is_it_tolower;
1741 boolean_t canonical_decomposition;
1742 boolean_t compatibility_decomposition;
1743 boolean_t canonical_composition;
1744 u8_normalization_states_t state;
1745
1746 s1last = s1 + n1;
1747 s2last = s2 + n2;
1748
1749 is_it_toupper = flag & U8_TEXTPREP_TOUPPER;
1750 is_it_tolower = flag & U8_TEXTPREP_TOLOWER;
1751 canonical_decomposition = flag & U8_CANON_DECOMP;
1752 compatibility_decomposition = flag & U8_COMPAT_DECOMP;
1753 canonical_composition = flag & U8_CANON_COMP;
1754
1755 while (s1 < s1last && s2 < s2last) {
1756 /*
1757 * If the current character is a 7-bit ASCII and the last
1758 * character, or, if the current character and the next
1759 * character are both some 7-bit ASCII characters then
1760 * we treat the current character as a sequence.
1761 *
1762 * In any other cases, we need to call collect_a_seq().
1763 */
1764
1765 if (U8_ISASCII(*s1) && ((s1 + 1) >= s1last ||
1766 ((s1 + 1) < s1last && U8_ISASCII(*(s1 + 1))))) {
1767 if (is_it_toupper)
1768 u8s1[0] = U8_ASCII_TOUPPER(*s1);
1769 else if (is_it_tolower)
1770 u8s1[0] = U8_ASCII_TOLOWER(*s1);
1771 else
1772 u8s1[0] = *s1;
1773 u8s1[1] = '\0';
1774 sz1 = 1;
1775 s1++;
1776 } else {
1777 state = U8_STATE_START;
1778 sz1 = collect_a_seq(uv, u8s1, &s1, s1last,
1779 is_it_toupper, is_it_tolower,
1780 canonical_decomposition,
1781 compatibility_decomposition,
1782 canonical_composition, errnum, &state);
1783 }
1784
1785 if (U8_ISASCII(*s2) && ((s2 + 1) >= s2last ||
1786 ((s2 + 1) < s2last && U8_ISASCII(*(s2 + 1))))) {
1787 if (is_it_toupper)
1788 u8s2[0] = U8_ASCII_TOUPPER(*s2);
1789 else if (is_it_tolower)
1790 u8s2[0] = U8_ASCII_TOLOWER(*s2);
1791 else
1792 u8s2[0] = *s2;
1793 u8s2[1] = '\0';
1794 sz2 = 1;
1795 s2++;
1796 } else {
1797 state = U8_STATE_START;
1798 sz2 = collect_a_seq(uv, u8s2, &s2, s2last,
1799 is_it_toupper, is_it_tolower,
1800 canonical_decomposition,
1801 compatibility_decomposition,
1802 canonical_composition, errnum, &state);
1803 }
1804
1805 /*
1806 * Now compare the two characters. If they are the same,
1807 * we move on to the next character sequences.
1808 */
1809 if (sz1 == 1 && sz2 == 1) {
1810 if (*u8s1 > *u8s2)
1811 return (1);
1812 if (*u8s1 < *u8s2)
1813 return (-1);
1814 } else {
1815 result = strcmp((const char *)u8s1, (const char *)u8s2);
1816 if (result != 0)
1817 return (result);
1818 }
1819 }
1820
1821 /*
1822 * We compared until the end of either or both strings.
1823 *
1824 * If we reached to or went over the ends for the both, that means
1825 * they are the same.
1826 *
1827 * If we reached only one end, that means the other string has
1828 * something which then can be used to determine the return value.
1829 */
1830 if (s1 >= s1last) {
1831 if (s2 >= s2last)
1832 return (0);
1833 return (-1);
1834 }
1835 return (1);
1836 }
1837
1838 /*
1839 * The u8_strcmp() function compares two UTF-8 strings quite similar to
1840 * the strcmp(). For the comparison, however, Unicode Normalization specific
1841 * equivalency and Unicode simple case conversion mappings based equivalency
1842 * can be requested and checked against.
1843 */
1844 int
1845 u8_strcmp(const char *s1, const char *s2, size_t n, int flag, size_t uv,
1846 int *errnum)
1847 {
1848 int f;
1849 size_t n1;
1850 size_t n2;
1851
1852 *errnum = 0;
1853
1854 /*
1855 * Check on the requested Unicode version, case conversion, and
1856 * normalization flag values.
1857 */
1858
1859 if (uv > U8_UNICODE_LATEST) {
1860 *errnum = ERANGE;
1861 uv = U8_UNICODE_LATEST;
1862 }
1863
1864 if (flag == 0) {
1865 flag = U8_STRCMP_CS;
1866 } else {
1867 f = flag & (U8_STRCMP_CS | U8_STRCMP_CI_UPPER |
1868 U8_STRCMP_CI_LOWER);
1869 if (f == 0) {
1870 flag |= U8_STRCMP_CS;
1871 } else if (f != U8_STRCMP_CS && f != U8_STRCMP_CI_UPPER &&
1872 f != U8_STRCMP_CI_LOWER) {
1873 *errnum = EBADF;
1874 flag = U8_STRCMP_CS;
1875 }
1876
1877 f = flag & (U8_CANON_DECOMP | U8_COMPAT_DECOMP | U8_CANON_COMP);
1878 if (f && f != U8_STRCMP_NFD && f != U8_STRCMP_NFC &&
1879 f != U8_STRCMP_NFKD && f != U8_STRCMP_NFKC) {
1880 *errnum = EBADF;
1881 flag = U8_STRCMP_CS;
1882 }
1883 }
1884
1885 if (flag == U8_STRCMP_CS) {
1886 return (n == 0 ? strcmp(s1, s2) : strncmp(s1, s2, n));
1887 }
1888
1889 n1 = strlen(s1);
1890 n2 = strlen(s2);
1891 if (n != 0) {
1892 if (n < n1)
1893 n1 = n;
1894 if (n < n2)
1895 n2 = n;
1896 }
1897
1898 /*
1899 * Simple case conversion can be done much faster and so we do
1900 * them separately here.
1901 */
1902 if (flag == U8_STRCMP_CI_UPPER) {
1903 return (do_case_compare(uv, (uchar_t *)s1, (uchar_t *)s2,
1904 n1, n2, B_TRUE, errnum));
1905 } else if (flag == U8_STRCMP_CI_LOWER) {
1906 return (do_case_compare(uv, (uchar_t *)s1, (uchar_t *)s2,
1907 n1, n2, B_FALSE, errnum));
1908 }
1909
1910 return (do_norm_compare(uv, (uchar_t *)s1, (uchar_t *)s2, n1, n2,
1911 flag, errnum));
1912 }
1913
1914 size_t
1915 u8_textprep_str(char *inarray, size_t *inlen, char *outarray, size_t *outlen,
1916 int flag, size_t unicode_version, int *errnum)
1917 {
1918 int f;
1919 int sz;
1920 uchar_t *ib;
1921 uchar_t *ibtail;
1922 uchar_t *ob;
1923 uchar_t *obtail;
1924 boolean_t do_not_ignore_null;
1925 boolean_t do_not_ignore_invalid;
1926 boolean_t is_it_toupper;
1927 boolean_t is_it_tolower;
1928 boolean_t canonical_decomposition;
1929 boolean_t compatibility_decomposition;
1930 boolean_t canonical_composition;
1931 size_t ret_val;
1932 size_t i;
1933 size_t j;
1934 uchar_t u8s[U8_STREAM_SAFE_TEXT_MAX + 1];
1935 u8_normalization_states_t state;
1936
1937 if (unicode_version > U8_UNICODE_LATEST) {
1938 *errnum = ERANGE;
1939 return ((size_t)-1);
1940 }
1941
1942 f = flag & (U8_TEXTPREP_TOUPPER | U8_TEXTPREP_TOLOWER);
1943 if (f == (U8_TEXTPREP_TOUPPER | U8_TEXTPREP_TOLOWER)) {
1944 *errnum = EBADF;
1945 return ((size_t)-1);
1946 }
1947
1948 f = flag & (U8_CANON_DECOMP | U8_COMPAT_DECOMP | U8_CANON_COMP);
1949 if (f && f != U8_TEXTPREP_NFD && f != U8_TEXTPREP_NFC &&
1950 f != U8_TEXTPREP_NFKD && f != U8_TEXTPREP_NFKC) {
1951 *errnum = EBADF;
1952 return ((size_t)-1);
1953 }
1954
1955 if (inarray == NULL || *inlen == 0)
1956 return (0);
1957
1958 if (outarray == NULL) {
1959 *errnum = E2BIG;
1960 return ((size_t)-1);
1961 }
1962
1963 ib = (uchar_t *)inarray;
1964 ob = (uchar_t *)outarray;
1965 ibtail = ib + *inlen;
1966 obtail = ob + *outlen;
1967
1968 do_not_ignore_null = !(flag & U8_TEXTPREP_IGNORE_NULL);
1969 do_not_ignore_invalid = !(flag & U8_TEXTPREP_IGNORE_INVALID);
1970 is_it_toupper = flag & U8_TEXTPREP_TOUPPER;
1971 is_it_tolower = flag & U8_TEXTPREP_TOLOWER;
1972
1973 ret_val = 0;
1974
1975 /*
1976 * If we don't have a normalization flag set, we do the simple case
1977 * conversion based text preparation separately below. Text
1978 * preparation involving Normalization will be done in the false task
1979 * block, again, separately since it will take much more time and
1980 * resource than doing simple case conversions.
1981 */
1982 if (f == 0) {
1983 while (ib < ibtail) {
1984 if (*ib == '\0' && do_not_ignore_null)
1985 break;
1986
1987 sz = u8_number_of_bytes[*ib];
1988
1989 if (sz < 0) {
1990 if (do_not_ignore_invalid) {
1991 *errnum = EILSEQ;
1992 ret_val = (size_t)-1;
1993 break;
1994 }
1995
1996 sz = 1;
1997 ret_val++;
1998 }
1999
2000 if (sz == 1) {
2001 if (ob >= obtail) {
2002 *errnum = E2BIG;
2003 ret_val = (size_t)-1;
2004 break;
2005 }
2006
2007 if (is_it_toupper)
2008 *ob = U8_ASCII_TOUPPER(*ib);
2009 else if (is_it_tolower)
2010 *ob = U8_ASCII_TOLOWER(*ib);
2011 else
2012 *ob = *ib;
2013 ib++;
2014 ob++;
2015 } else if ((ib + sz) > ibtail) {
2016 if (do_not_ignore_invalid) {
2017 *errnum = EINVAL;
2018 ret_val = (size_t)-1;
2019 break;
2020 }
2021
2022 if ((obtail - ob) < (ibtail - ib)) {
2023 *errnum = E2BIG;
2024 ret_val = (size_t)-1;
2025 break;
2026 }
2027
2028 /*
2029 * We treat the remaining incomplete character
2030 * bytes as a character.
2031 */
2032 ret_val++;
2033
2034 while (ib < ibtail)
2035 *ob++ = *ib++;
2036 } else {
2037 if (is_it_toupper || is_it_tolower) {
2038 i = do_case_conv(unicode_version, u8s,
2039 ib, sz, is_it_toupper);
2040
2041 if ((obtail - ob) < i) {
2042 *errnum = E2BIG;
2043 ret_val = (size_t)-1;
2044 break;
2045 }
2046
2047 ib += sz;
2048
2049 for (sz = 0; sz < i; sz++)
2050 *ob++ = u8s[sz];
2051 } else {
2052 if ((obtail - ob) < sz) {
2053 *errnum = E2BIG;
2054 ret_val = (size_t)-1;
2055 break;
2056 }
2057
2058 for (i = 0; i < sz; i++)
2059 *ob++ = *ib++;
2060 }
2061 }
2062 }
2063 } else {
2064 canonical_decomposition = flag & U8_CANON_DECOMP;
2065 compatibility_decomposition = flag & U8_COMPAT_DECOMP;
2066 canonical_composition = flag & U8_CANON_COMP;
2067
2068 while (ib < ibtail) {
2069 if (*ib == '\0' && do_not_ignore_null)
2070 break;
2071
2072 /*
2073 * If the current character is a 7-bit ASCII
2074 * character and it is the last character, or,
2075 * if the current character is a 7-bit ASCII
2076 * character and the next character is also a 7-bit
2077 * ASCII character, then, we copy over this
2078 * character without going through collect_a_seq().
2079 *
2080 * In any other cases, we need to look further with
2081 * the collect_a_seq() function.
2082 */
2083 if (U8_ISASCII(*ib) && ((ib + 1) >= ibtail ||
2084 ((ib + 1) < ibtail && U8_ISASCII(*(ib + 1))))) {
2085 if (ob >= obtail) {
2086 *errnum = E2BIG;
2087 ret_val = (size_t)-1;
2088 break;
2089 }
2090
2091 if (is_it_toupper)
2092 *ob = U8_ASCII_TOUPPER(*ib);
2093 else if (is_it_tolower)
2094 *ob = U8_ASCII_TOLOWER(*ib);
2095 else
2096 *ob = *ib;
2097 ib++;
2098 ob++;
2099 } else {
2100 *errnum = 0;
2101 state = U8_STATE_START;
2102
2103 j = collect_a_seq(unicode_version, u8s,
2104 &ib, ibtail,
2105 is_it_toupper,
2106 is_it_tolower,
2107 canonical_decomposition,
2108 compatibility_decomposition,
2109 canonical_composition,
2110 errnum, &state);
2111
2112 if (*errnum && do_not_ignore_invalid) {
2113 ret_val = (size_t)-1;
2114 break;
2115 }
2116
2117 if ((obtail - ob) < j) {
2118 *errnum = E2BIG;
2119 ret_val = (size_t)-1;
2120 break;
2121 }
2122
2123 for (i = 0; i < j; i++)
2124 *ob++ = u8s[i];
2125 }
2126 }
2127 }
2128
2129 *inlen = ibtail - ib;
2130 *outlen = obtail - ob;
2131
2132 return (ret_val);
2133 }
2134
2135 #if defined(_KERNEL) && defined(HAVE_SPL)
2136
2137 static int unicode_init(void) { return 0; }
2138 static int unicode_fini(void) { return 0; }
2139
2140 spl_module_init(unicode_init);
2141 spl_module_exit(unicode_fini);
2142
2143 MODULE_DESCRIPTION("Unicode implementation");
2144 MODULE_AUTHOR(ZFS_META_AUTHOR);
2145 MODULE_LICENSE(ZFS_META_LICENSE);
2146 MODULE_VERSION(ZFS_META_VERSION "-" ZFS_META_RELEASE);
2147
2148 EXPORT_SYMBOL(u8_validate);
2149 EXPORT_SYMBOL(u8_strcmp);
2150 EXPORT_SYMBOL(u8_textprep_str);
2151 #endif
ZFS On Linux mirror for PVE