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 uninitialized_var(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