Root/
1 | /* |
2 | * linux/fs/hfsplus/unicode.c |
3 | * |
4 | * Copyright (C) 2001 |
5 | * Brad Boyer (flar@allandria.com) |
6 | * (C) 2003 Ardis Technologies <roman@ardistech.com> |
7 | * |
8 | * Handler routines for unicode strings |
9 | */ |
10 | |
11 | #include <linux/types.h> |
12 | #include <linux/nls.h> |
13 | #include "hfsplus_fs.h" |
14 | #include "hfsplus_raw.h" |
15 | |
16 | /* Fold the case of a unicode char, given the 16 bit value */ |
17 | /* Returns folded char, or 0 if ignorable */ |
18 | static inline u16 case_fold(u16 c) |
19 | { |
20 | u16 tmp; |
21 | |
22 | tmp = hfsplus_case_fold_table[c >> 8]; |
23 | if (tmp) |
24 | tmp = hfsplus_case_fold_table[tmp + (c & 0xff)]; |
25 | else |
26 | tmp = c; |
27 | return tmp; |
28 | } |
29 | |
30 | /* Compare unicode strings, return values like normal strcmp */ |
31 | int hfsplus_strcasecmp(const struct hfsplus_unistr *s1, |
32 | const struct hfsplus_unistr *s2) |
33 | { |
34 | u16 len1, len2, c1, c2; |
35 | const hfsplus_unichr *p1, *p2; |
36 | |
37 | len1 = be16_to_cpu(s1->length); |
38 | len2 = be16_to_cpu(s2->length); |
39 | p1 = s1->unicode; |
40 | p2 = s2->unicode; |
41 | |
42 | while (1) { |
43 | c1 = c2 = 0; |
44 | |
45 | while (len1 && !c1) { |
46 | c1 = case_fold(be16_to_cpu(*p1)); |
47 | p1++; |
48 | len1--; |
49 | } |
50 | while (len2 && !c2) { |
51 | c2 = case_fold(be16_to_cpu(*p2)); |
52 | p2++; |
53 | len2--; |
54 | } |
55 | |
56 | if (c1 != c2) |
57 | return (c1 < c2) ? -1 : 1; |
58 | if (!c1 && !c2) |
59 | return 0; |
60 | } |
61 | } |
62 | |
63 | /* Compare names as a sequence of 16-bit unsigned integers */ |
64 | int hfsplus_strcmp(const struct hfsplus_unistr *s1, |
65 | const struct hfsplus_unistr *s2) |
66 | { |
67 | u16 len1, len2, c1, c2; |
68 | const hfsplus_unichr *p1, *p2; |
69 | int len; |
70 | |
71 | len1 = be16_to_cpu(s1->length); |
72 | len2 = be16_to_cpu(s2->length); |
73 | p1 = s1->unicode; |
74 | p2 = s2->unicode; |
75 | |
76 | for (len = min(len1, len2); len > 0; len--) { |
77 | c1 = be16_to_cpu(*p1); |
78 | c2 = be16_to_cpu(*p2); |
79 | if (c1 != c2) |
80 | return c1 < c2 ? -1 : 1; |
81 | p1++; |
82 | p2++; |
83 | } |
84 | |
85 | return len1 < len2 ? -1 : |
86 | len1 > len2 ? 1 : 0; |
87 | } |
88 | |
89 | |
90 | #define Hangul_SBase 0xac00 |
91 | #define Hangul_LBase 0x1100 |
92 | #define Hangul_VBase 0x1161 |
93 | #define Hangul_TBase 0x11a7 |
94 | #define Hangul_SCount 11172 |
95 | #define Hangul_LCount 19 |
96 | #define Hangul_VCount 21 |
97 | #define Hangul_TCount 28 |
98 | #define Hangul_NCount (Hangul_VCount * Hangul_TCount) |
99 | |
100 | |
101 | static u16 *hfsplus_compose_lookup(u16 *p, u16 cc) |
102 | { |
103 | int i, s, e; |
104 | |
105 | s = 1; |
106 | e = p[1]; |
107 | if (!e || cc < p[s * 2] || cc > p[e * 2]) |
108 | return NULL; |
109 | do { |
110 | i = (s + e) / 2; |
111 | if (cc > p[i * 2]) |
112 | s = i + 1; |
113 | else if (cc < p[i * 2]) |
114 | e = i - 1; |
115 | else |
116 | return hfsplus_compose_table + p[i * 2 + 1]; |
117 | } while (s <= e); |
118 | return NULL; |
119 | } |
120 | |
121 | int hfsplus_uni2asc(struct super_block *sb, const struct hfsplus_unistr *ustr, char *astr, int *len_p) |
122 | { |
123 | const hfsplus_unichr *ip; |
124 | struct nls_table *nls = HFSPLUS_SB(sb).nls; |
125 | u8 *op; |
126 | u16 cc, c0, c1; |
127 | u16 *ce1, *ce2; |
128 | int i, len, ustrlen, res, compose; |
129 | |
130 | op = astr; |
131 | ip = ustr->unicode; |
132 | ustrlen = be16_to_cpu(ustr->length); |
133 | len = *len_p; |
134 | ce1 = NULL; |
135 | compose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE); |
136 | |
137 | while (ustrlen > 0) { |
138 | c0 = be16_to_cpu(*ip++); |
139 | ustrlen--; |
140 | /* search for single decomposed char */ |
141 | if (likely(compose)) |
142 | ce1 = hfsplus_compose_lookup(hfsplus_compose_table, c0); |
143 | if (ce1 && (cc = ce1[0])) { |
144 | /* start of a possibly decomposed Hangul char */ |
145 | if (cc != 0xffff) |
146 | goto done; |
147 | if (!ustrlen) |
148 | goto same; |
149 | c1 = be16_to_cpu(*ip) - Hangul_VBase; |
150 | if (c1 < Hangul_VCount) { |
151 | /* compose the Hangul char */ |
152 | cc = (c0 - Hangul_LBase) * Hangul_VCount; |
153 | cc = (cc + c1) * Hangul_TCount; |
154 | cc += Hangul_SBase; |
155 | ip++; |
156 | ustrlen--; |
157 | if (!ustrlen) |
158 | goto done; |
159 | c1 = be16_to_cpu(*ip) - Hangul_TBase; |
160 | if (c1 > 0 && c1 < Hangul_TCount) { |
161 | cc += c1; |
162 | ip++; |
163 | ustrlen--; |
164 | } |
165 | goto done; |
166 | } |
167 | } |
168 | while (1) { |
169 | /* main loop for common case of not composed chars */ |
170 | if (!ustrlen) |
171 | goto same; |
172 | c1 = be16_to_cpu(*ip); |
173 | if (likely(compose)) |
174 | ce1 = hfsplus_compose_lookup(hfsplus_compose_table, c1); |
175 | if (ce1) |
176 | break; |
177 | switch (c0) { |
178 | case 0: |
179 | c0 = 0x2400; |
180 | break; |
181 | case '/': |
182 | c0 = ':'; |
183 | break; |
184 | } |
185 | res = nls->uni2char(c0, op, len); |
186 | if (res < 0) { |
187 | if (res == -ENAMETOOLONG) |
188 | goto out; |
189 | *op = '?'; |
190 | res = 1; |
191 | } |
192 | op += res; |
193 | len -= res; |
194 | c0 = c1; |
195 | ip++; |
196 | ustrlen--; |
197 | } |
198 | ce2 = hfsplus_compose_lookup(ce1, c0); |
199 | if (ce2) { |
200 | i = 1; |
201 | while (i < ustrlen) { |
202 | ce1 = hfsplus_compose_lookup(ce2, be16_to_cpu(ip[i])); |
203 | if (!ce1) |
204 | break; |
205 | i++; |
206 | ce2 = ce1; |
207 | } |
208 | if ((cc = ce2[0])) { |
209 | ip += i; |
210 | ustrlen -= i; |
211 | goto done; |
212 | } |
213 | } |
214 | same: |
215 | switch (c0) { |
216 | case 0: |
217 | cc = 0x2400; |
218 | break; |
219 | case '/': |
220 | cc = ':'; |
221 | break; |
222 | default: |
223 | cc = c0; |
224 | } |
225 | done: |
226 | res = nls->uni2char(cc, op, len); |
227 | if (res < 0) { |
228 | if (res == -ENAMETOOLONG) |
229 | goto out; |
230 | *op = '?'; |
231 | res = 1; |
232 | } |
233 | op += res; |
234 | len -= res; |
235 | } |
236 | res = 0; |
237 | out: |
238 | *len_p = (char *)op - astr; |
239 | return res; |
240 | } |
241 | |
242 | /* |
243 | * Convert one or more ASCII characters into a single unicode character. |
244 | * Returns the number of ASCII characters corresponding to the unicode char. |
245 | */ |
246 | static inline int asc2unichar(struct super_block *sb, const char *astr, int len, |
247 | wchar_t *uc) |
248 | { |
249 | int size = HFSPLUS_SB(sb).nls->char2uni(astr, len, uc); |
250 | if (size <= 0) { |
251 | *uc = '?'; |
252 | size = 1; |
253 | } |
254 | switch (*uc) { |
255 | case 0x2400: |
256 | *uc = 0; |
257 | break; |
258 | case ':': |
259 | *uc = '/'; |
260 | break; |
261 | } |
262 | return size; |
263 | } |
264 | |
265 | /* Decomposes a single unicode character. */ |
266 | static inline u16 *decompose_unichar(wchar_t uc, int *size) |
267 | { |
268 | int off; |
269 | |
270 | off = hfsplus_decompose_table[(uc >> 12) & 0xf]; |
271 | if (off == 0 || off == 0xffff) |
272 | return NULL; |
273 | |
274 | off = hfsplus_decompose_table[off + ((uc >> 8) & 0xf)]; |
275 | if (!off) |
276 | return NULL; |
277 | |
278 | off = hfsplus_decompose_table[off + ((uc >> 4) & 0xf)]; |
279 | if (!off) |
280 | return NULL; |
281 | |
282 | off = hfsplus_decompose_table[off + (uc & 0xf)]; |
283 | *size = off & 3; |
284 | if (*size == 0) |
285 | return NULL; |
286 | return hfsplus_decompose_table + (off / 4); |
287 | } |
288 | |
289 | int hfsplus_asc2uni(struct super_block *sb, struct hfsplus_unistr *ustr, |
290 | const char *astr, int len) |
291 | { |
292 | int size, dsize, decompose; |
293 | u16 *dstr, outlen = 0; |
294 | wchar_t c; |
295 | |
296 | decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE); |
297 | while (outlen < HFSPLUS_MAX_STRLEN && len > 0) { |
298 | size = asc2unichar(sb, astr, len, &c); |
299 | |
300 | if (decompose && (dstr = decompose_unichar(c, &dsize))) { |
301 | if (outlen + dsize > HFSPLUS_MAX_STRLEN) |
302 | break; |
303 | do { |
304 | ustr->unicode[outlen++] = cpu_to_be16(*dstr++); |
305 | } while (--dsize > 0); |
306 | } else |
307 | ustr->unicode[outlen++] = cpu_to_be16(c); |
308 | |
309 | astr += size; |
310 | len -= size; |
311 | } |
312 | ustr->length = cpu_to_be16(outlen); |
313 | if (len > 0) |
314 | return -ENAMETOOLONG; |
315 | return 0; |
316 | } |
317 | |
318 | /* |
319 | * Hash a string to an integer as appropriate for the HFS+ filesystem. |
320 | * Composed unicode characters are decomposed and case-folding is performed |
321 | * if the appropriate bits are (un)set on the superblock. |
322 | */ |
323 | int hfsplus_hash_dentry(struct dentry *dentry, struct qstr *str) |
324 | { |
325 | struct super_block *sb = dentry->d_sb; |
326 | const char *astr; |
327 | const u16 *dstr; |
328 | int casefold, decompose, size, len; |
329 | unsigned long hash; |
330 | wchar_t c; |
331 | u16 c2; |
332 | |
333 | casefold = (HFSPLUS_SB(sb).flags & HFSPLUS_SB_CASEFOLD); |
334 | decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE); |
335 | hash = init_name_hash(); |
336 | astr = str->name; |
337 | len = str->len; |
338 | while (len > 0) { |
339 | int uninitialized_var(dsize); |
340 | size = asc2unichar(sb, astr, len, &c); |
341 | astr += size; |
342 | len -= size; |
343 | |
344 | if (decompose && (dstr = decompose_unichar(c, &dsize))) { |
345 | do { |
346 | c2 = *dstr++; |
347 | if (!casefold || (c2 = case_fold(c2))) |
348 | hash = partial_name_hash(c2, hash); |
349 | } while (--dsize > 0); |
350 | } else { |
351 | c2 = c; |
352 | if (!casefold || (c2 = case_fold(c2))) |
353 | hash = partial_name_hash(c2, hash); |
354 | } |
355 | } |
356 | str->hash = end_name_hash(hash); |
357 | |
358 | return 0; |
359 | } |
360 | |
361 | /* |
362 | * Compare strings with HFS+ filename ordering. |
363 | * Composed unicode characters are decomposed and case-folding is performed |
364 | * if the appropriate bits are (un)set on the superblock. |
365 | */ |
366 | int hfsplus_compare_dentry(struct dentry *dentry, struct qstr *s1, struct qstr *s2) |
367 | { |
368 | struct super_block *sb = dentry->d_sb; |
369 | int casefold, decompose, size; |
370 | int dsize1, dsize2, len1, len2; |
371 | const u16 *dstr1, *dstr2; |
372 | const char *astr1, *astr2; |
373 | u16 c1, c2; |
374 | wchar_t c; |
375 | |
376 | casefold = (HFSPLUS_SB(sb).flags & HFSPLUS_SB_CASEFOLD); |
377 | decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE); |
378 | astr1 = s1->name; |
379 | len1 = s1->len; |
380 | astr2 = s2->name; |
381 | len2 = s2->len; |
382 | dsize1 = dsize2 = 0; |
383 | dstr1 = dstr2 = NULL; |
384 | |
385 | while (len1 > 0 && len2 > 0) { |
386 | if (!dsize1) { |
387 | size = asc2unichar(sb, astr1, len1, &c); |
388 | astr1 += size; |
389 | len1 -= size; |
390 | |
391 | if (!decompose || !(dstr1 = decompose_unichar(c, &dsize1))) { |
392 | c1 = c; |
393 | dstr1 = &c1; |
394 | dsize1 = 1; |
395 | } |
396 | } |
397 | |
398 | if (!dsize2) { |
399 | size = asc2unichar(sb, astr2, len2, &c); |
400 | astr2 += size; |
401 | len2 -= size; |
402 | |
403 | if (!decompose || !(dstr2 = decompose_unichar(c, &dsize2))) { |
404 | c2 = c; |
405 | dstr2 = &c2; |
406 | dsize2 = 1; |
407 | } |
408 | } |
409 | |
410 | c1 = *dstr1; |
411 | c2 = *dstr2; |
412 | if (casefold) { |
413 | if (!(c1 = case_fold(c1))) { |
414 | dstr1++; |
415 | dsize1--; |
416 | continue; |
417 | } |
418 | if (!(c2 = case_fold(c2))) { |
419 | dstr2++; |
420 | dsize2--; |
421 | continue; |
422 | } |
423 | } |
424 | if (c1 < c2) |
425 | return -1; |
426 | else if (c1 > c2) |
427 | return 1; |
428 | |
429 | dstr1++; |
430 | dsize1--; |
431 | dstr2++; |
432 | dsize2--; |
433 | } |
434 | |
435 | if (len1 < len2) |
436 | return -1; |
437 | if (len1 > len2) |
438 | return 1; |
439 | return 0; |
440 | } |
441 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9