xref: /openbmc/linux/fs/hfsplus/unicode.c (revision 4bb1eb3c) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  *  linux/fs/hfsplus/unicode.c
4  *
5  * Copyright (C) 2001
6  * Brad Boyer (flar@allandria.com)
7  * (C) 2003 Ardis Technologies <roman@ardistech.com>
8  *
9  * Handler routines for unicode strings
10  */
11 
12 #include <linux/types.h>
13 #include <linux/nls.h>
14 #include "hfsplus_fs.h"
15 #include "hfsplus_raw.h"
16 
17 /* Fold the case of a unicode char, given the 16 bit value */
18 /* Returns folded char, or 0 if ignorable */
19 static inline u16 case_fold(u16 c)
20 {
21 	u16 tmp;
22 
23 	tmp = hfsplus_case_fold_table[c >> 8];
24 	if (tmp)
25 		tmp = hfsplus_case_fold_table[tmp + (c & 0xff)];
26 	else
27 		tmp = c;
28 	return tmp;
29 }
30 
31 /* Compare unicode strings, return values like normal strcmp */
32 int hfsplus_strcasecmp(const struct hfsplus_unistr *s1,
33 		       const struct hfsplus_unistr *s2)
34 {
35 	u16 len1, len2, c1, c2;
36 	const hfsplus_unichr *p1, *p2;
37 
38 	len1 = be16_to_cpu(s1->length);
39 	len2 = be16_to_cpu(s2->length);
40 	p1 = s1->unicode;
41 	p2 = s2->unicode;
42 
43 	while (1) {
44 		c1 = c2 = 0;
45 
46 		while (len1 && !c1) {
47 			c1 = case_fold(be16_to_cpu(*p1));
48 			p1++;
49 			len1--;
50 		}
51 		while (len2 && !c2) {
52 			c2 = case_fold(be16_to_cpu(*p2));
53 			p2++;
54 			len2--;
55 		}
56 
57 		if (c1 != c2)
58 			return (c1 < c2) ? -1 : 1;
59 		if (!c1 && !c2)
60 			return 0;
61 	}
62 }
63 
64 /* Compare names as a sequence of 16-bit unsigned integers */
65 int hfsplus_strcmp(const struct hfsplus_unistr *s1,
66 		   const struct hfsplus_unistr *s2)
67 {
68 	u16 len1, len2, c1, c2;
69 	const hfsplus_unichr *p1, *p2;
70 	int len;
71 
72 	len1 = be16_to_cpu(s1->length);
73 	len2 = be16_to_cpu(s2->length);
74 	p1 = s1->unicode;
75 	p2 = s2->unicode;
76 
77 	for (len = min(len1, len2); len > 0; len--) {
78 		c1 = be16_to_cpu(*p1);
79 		c2 = be16_to_cpu(*p2);
80 		if (c1 != c2)
81 			return c1 < c2 ? -1 : 1;
82 		p1++;
83 		p2++;
84 	}
85 
86 	return len1 < len2 ? -1 :
87 	       len1 > len2 ? 1 : 0;
88 }
89 
90 
91 #define Hangul_SBase	0xac00
92 #define Hangul_LBase	0x1100
93 #define Hangul_VBase	0x1161
94 #define Hangul_TBase	0x11a7
95 #define Hangul_SCount	11172
96 #define Hangul_LCount	19
97 #define Hangul_VCount	21
98 #define Hangul_TCount	28
99 #define Hangul_NCount	(Hangul_VCount * Hangul_TCount)
100 
101 
102 static u16 *hfsplus_compose_lookup(u16 *p, u16 cc)
103 {
104 	int i, s, e;
105 
106 	s = 1;
107 	e = p[1];
108 	if (!e || cc < p[s * 2] || cc > p[e * 2])
109 		return NULL;
110 	do {
111 		i = (s + e) / 2;
112 		if (cc > p[i * 2])
113 			s = i + 1;
114 		else if (cc < p[i * 2])
115 			e = i - 1;
116 		else
117 			return hfsplus_compose_table + p[i * 2 + 1];
118 	} while (s <= e);
119 	return NULL;
120 }
121 
122 int hfsplus_uni2asc(struct super_block *sb,
123 		const struct hfsplus_unistr *ustr,
124 		char *astr, int *len_p)
125 {
126 	const hfsplus_unichr *ip;
127 	struct nls_table *nls = HFSPLUS_SB(sb)->nls;
128 	u8 *op;
129 	u16 cc, c0, c1;
130 	u16 *ce1, *ce2;
131 	int i, len, ustrlen, res, compose;
132 
133 	op = astr;
134 	ip = ustr->unicode;
135 	ustrlen = be16_to_cpu(ustr->length);
136 	len = *len_p;
137 	ce1 = NULL;
138 	compose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
139 
140 	while (ustrlen > 0) {
141 		c0 = be16_to_cpu(*ip++);
142 		ustrlen--;
143 		/* search for single decomposed char */
144 		if (likely(compose))
145 			ce1 = hfsplus_compose_lookup(hfsplus_compose_table, c0);
146 		if (ce1)
147 			cc = ce1[0];
148 		else
149 			cc = 0;
150 		if (cc) {
151 			/* start of a possibly decomposed Hangul char */
152 			if (cc != 0xffff)
153 				goto done;
154 			if (!ustrlen)
155 				goto same;
156 			c1 = be16_to_cpu(*ip) - Hangul_VBase;
157 			if (c1 < Hangul_VCount) {
158 				/* compose the Hangul char */
159 				cc = (c0 - Hangul_LBase) * Hangul_VCount;
160 				cc = (cc + c1) * Hangul_TCount;
161 				cc += Hangul_SBase;
162 				ip++;
163 				ustrlen--;
164 				if (!ustrlen)
165 					goto done;
166 				c1 = be16_to_cpu(*ip) - Hangul_TBase;
167 				if (c1 > 0 && c1 < Hangul_TCount) {
168 					cc += c1;
169 					ip++;
170 					ustrlen--;
171 				}
172 				goto done;
173 			}
174 		}
175 		while (1) {
176 			/* main loop for common case of not composed chars */
177 			if (!ustrlen)
178 				goto same;
179 			c1 = be16_to_cpu(*ip);
180 			if (likely(compose))
181 				ce1 = hfsplus_compose_lookup(
182 					hfsplus_compose_table, c1);
183 			if (ce1)
184 				break;
185 			switch (c0) {
186 			case 0:
187 				c0 = 0x2400;
188 				break;
189 			case '/':
190 				c0 = ':';
191 				break;
192 			}
193 			res = nls->uni2char(c0, op, len);
194 			if (res < 0) {
195 				if (res == -ENAMETOOLONG)
196 					goto out;
197 				*op = '?';
198 				res = 1;
199 			}
200 			op += res;
201 			len -= res;
202 			c0 = c1;
203 			ip++;
204 			ustrlen--;
205 		}
206 		ce2 = hfsplus_compose_lookup(ce1, c0);
207 		if (ce2) {
208 			i = 1;
209 			while (i < ustrlen) {
210 				ce1 = hfsplus_compose_lookup(ce2,
211 					be16_to_cpu(ip[i]));
212 				if (!ce1)
213 					break;
214 				i++;
215 				ce2 = ce1;
216 			}
217 			cc = ce2[0];
218 			if (cc) {
219 				ip += i;
220 				ustrlen -= i;
221 				goto done;
222 			}
223 		}
224 same:
225 		switch (c0) {
226 		case 0:
227 			cc = 0x2400;
228 			break;
229 		case '/':
230 			cc = ':';
231 			break;
232 		default:
233 			cc = c0;
234 		}
235 done:
236 		res = nls->uni2char(cc, op, len);
237 		if (res < 0) {
238 			if (res == -ENAMETOOLONG)
239 				goto out;
240 			*op = '?';
241 			res = 1;
242 		}
243 		op += res;
244 		len -= res;
245 	}
246 	res = 0;
247 out:
248 	*len_p = (char *)op - astr;
249 	return res;
250 }
251 
252 /*
253  * Convert one or more ASCII characters into a single unicode character.
254  * Returns the number of ASCII characters corresponding to the unicode char.
255  */
256 static inline int asc2unichar(struct super_block *sb, const char *astr, int len,
257 			      wchar_t *uc)
258 {
259 	int size = HFSPLUS_SB(sb)->nls->char2uni(astr, len, uc);
260 	if (size <= 0) {
261 		*uc = '?';
262 		size = 1;
263 	}
264 	switch (*uc) {
265 	case 0x2400:
266 		*uc = 0;
267 		break;
268 	case ':':
269 		*uc = '/';
270 		break;
271 	}
272 	return size;
273 }
274 
275 /* Decomposes a non-Hangul unicode character. */
276 static u16 *hfsplus_decompose_nonhangul(wchar_t uc, int *size)
277 {
278 	int off;
279 
280 	off = hfsplus_decompose_table[(uc >> 12) & 0xf];
281 	if (off == 0 || off == 0xffff)
282 		return NULL;
283 
284 	off = hfsplus_decompose_table[off + ((uc >> 8) & 0xf)];
285 	if (!off)
286 		return NULL;
287 
288 	off = hfsplus_decompose_table[off + ((uc >> 4) & 0xf)];
289 	if (!off)
290 		return NULL;
291 
292 	off = hfsplus_decompose_table[off + (uc & 0xf)];
293 	*size = off & 3;
294 	if (*size == 0)
295 		return NULL;
296 	return hfsplus_decompose_table + (off / 4);
297 }
298 
299 /*
300  * Try to decompose a unicode character as Hangul. Return 0 if @uc is not
301  * precomposed Hangul, otherwise return the length of the decomposition.
302  *
303  * This function was adapted from sample code from the Unicode Standard
304  * Annex #15: Unicode Normalization Forms, version 3.2.0.
305  *
306  * Copyright (C) 1991-2018 Unicode, Inc.  All rights reserved.  Distributed
307  * under the Terms of Use in http://www.unicode.org/copyright.html.
308  */
309 static int hfsplus_try_decompose_hangul(wchar_t uc, u16 *result)
310 {
311 	int index;
312 	int l, v, t;
313 
314 	index = uc - Hangul_SBase;
315 	if (index < 0 || index >= Hangul_SCount)
316 		return 0;
317 
318 	l = Hangul_LBase + index / Hangul_NCount;
319 	v = Hangul_VBase + (index % Hangul_NCount) / Hangul_TCount;
320 	t = Hangul_TBase + index % Hangul_TCount;
321 
322 	result[0] = l;
323 	result[1] = v;
324 	if (t != Hangul_TBase) {
325 		result[2] = t;
326 		return 3;
327 	}
328 	return 2;
329 }
330 
331 /* Decomposes a single unicode character. */
332 static u16 *decompose_unichar(wchar_t uc, int *size, u16 *hangul_buffer)
333 {
334 	u16 *result;
335 
336 	/* Hangul is handled separately */
337 	result = hangul_buffer;
338 	*size = hfsplus_try_decompose_hangul(uc, result);
339 	if (*size == 0)
340 		result = hfsplus_decompose_nonhangul(uc, size);
341 	return result;
342 }
343 
344 int hfsplus_asc2uni(struct super_block *sb,
345 		    struct hfsplus_unistr *ustr, int max_unistr_len,
346 		    const char *astr, int len)
347 {
348 	int size, dsize, decompose;
349 	u16 *dstr, outlen = 0;
350 	wchar_t c;
351 	u16 dhangul[3];
352 
353 	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
354 	while (outlen < max_unistr_len && len > 0) {
355 		size = asc2unichar(sb, astr, len, &c);
356 
357 		if (decompose)
358 			dstr = decompose_unichar(c, &dsize, dhangul);
359 		else
360 			dstr = NULL;
361 		if (dstr) {
362 			if (outlen + dsize > max_unistr_len)
363 				break;
364 			do {
365 				ustr->unicode[outlen++] = cpu_to_be16(*dstr++);
366 			} while (--dsize > 0);
367 		} else
368 			ustr->unicode[outlen++] = cpu_to_be16(c);
369 
370 		astr += size;
371 		len -= size;
372 	}
373 	ustr->length = cpu_to_be16(outlen);
374 	if (len > 0)
375 		return -ENAMETOOLONG;
376 	return 0;
377 }
378 
379 /*
380  * Hash a string to an integer as appropriate for the HFS+ filesystem.
381  * Composed unicode characters are decomposed and case-folding is performed
382  * if the appropriate bits are (un)set on the superblock.
383  */
384 int hfsplus_hash_dentry(const struct dentry *dentry, struct qstr *str)
385 {
386 	struct super_block *sb = dentry->d_sb;
387 	const char *astr;
388 	const u16 *dstr;
389 	int casefold, decompose, size, len;
390 	unsigned long hash;
391 	wchar_t c;
392 	u16 c2;
393 	u16 dhangul[3];
394 
395 	casefold = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);
396 	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
397 	hash = init_name_hash(dentry);
398 	astr = str->name;
399 	len = str->len;
400 	while (len > 0) {
401 		int dsize;
402 		size = asc2unichar(sb, astr, len, &c);
403 		astr += size;
404 		len -= size;
405 
406 		if (decompose)
407 			dstr = decompose_unichar(c, &dsize, dhangul);
408 		else
409 			dstr = NULL;
410 		if (dstr) {
411 			do {
412 				c2 = *dstr++;
413 				if (casefold)
414 					c2 = case_fold(c2);
415 				if (!casefold || c2)
416 					hash = partial_name_hash(c2, hash);
417 			} while (--dsize > 0);
418 		} else {
419 			c2 = c;
420 			if (casefold)
421 				c2 = case_fold(c2);
422 			if (!casefold || c2)
423 				hash = partial_name_hash(c2, hash);
424 		}
425 	}
426 	str->hash = end_name_hash(hash);
427 
428 	return 0;
429 }
430 
431 /*
432  * Compare strings with HFS+ filename ordering.
433  * Composed unicode characters are decomposed and case-folding is performed
434  * if the appropriate bits are (un)set on the superblock.
435  */
436 int hfsplus_compare_dentry(const struct dentry *dentry,
437 		unsigned int len, const char *str, const struct qstr *name)
438 {
439 	struct super_block *sb = dentry->d_sb;
440 	int casefold, decompose, size;
441 	int dsize1, dsize2, len1, len2;
442 	const u16 *dstr1, *dstr2;
443 	const char *astr1, *astr2;
444 	u16 c1, c2;
445 	wchar_t c;
446 	u16 dhangul_1[3], dhangul_2[3];
447 
448 	casefold = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);
449 	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
450 	astr1 = str;
451 	len1 = len;
452 	astr2 = name->name;
453 	len2 = name->len;
454 	dsize1 = dsize2 = 0;
455 	dstr1 = dstr2 = NULL;
456 
457 	while (len1 > 0 && len2 > 0) {
458 		if (!dsize1) {
459 			size = asc2unichar(sb, astr1, len1, &c);
460 			astr1 += size;
461 			len1 -= size;
462 
463 			if (decompose)
464 				dstr1 = decompose_unichar(c, &dsize1,
465 							  dhangul_1);
466 			if (!decompose || !dstr1) {
467 				c1 = c;
468 				dstr1 = &c1;
469 				dsize1 = 1;
470 			}
471 		}
472 
473 		if (!dsize2) {
474 			size = asc2unichar(sb, astr2, len2, &c);
475 			astr2 += size;
476 			len2 -= size;
477 
478 			if (decompose)
479 				dstr2 = decompose_unichar(c, &dsize2,
480 							  dhangul_2);
481 			if (!decompose || !dstr2) {
482 				c2 = c;
483 				dstr2 = &c2;
484 				dsize2 = 1;
485 			}
486 		}
487 
488 		c1 = *dstr1;
489 		c2 = *dstr2;
490 		if (casefold) {
491 			c1 = case_fold(c1);
492 			if (!c1) {
493 				dstr1++;
494 				dsize1--;
495 				continue;
496 			}
497 			c2 = case_fold(c2);
498 			if (!c2) {
499 				dstr2++;
500 				dsize2--;
501 				continue;
502 			}
503 		}
504 		if (c1 < c2)
505 			return -1;
506 		else if (c1 > c2)
507 			return 1;
508 
509 		dstr1++;
510 		dsize1--;
511 		dstr2++;
512 		dsize2--;
513 	}
514 
515 	if (len1 < len2)
516 		return -1;
517 	if (len1 > len2)
518 		return 1;
519 	return 0;
520 }
521