~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/hfsplus/unicode.c

Version: ~ [ linux-5.18-rc6 ] ~ [ linux-5.17.6 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.38 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.114 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.192 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.241 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.277 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.312 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp