Root/
1 | /* |
2 | * unistr.c - NTFS Unicode string handling. Part of the Linux-NTFS project. |
3 | * |
4 | * Copyright (c) 2001-2006 Anton Altaparmakov |
5 | * |
6 | * This program/include file is free software; you can redistribute it and/or |
7 | * modify it under the terms of the GNU General Public License as published |
8 | * by the Free Software Foundation; either version 2 of the License, or |
9 | * (at your option) any later version. |
10 | * |
11 | * This program/include file is distributed in the hope that it will be |
12 | * useful, but WITHOUT ANY WARRANTY; without even the implied warranty |
13 | * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
14 | * GNU General Public License for more details. |
15 | * |
16 | * You should have received a copy of the GNU General Public License |
17 | * along with this program (in the main directory of the Linux-NTFS |
18 | * distribution in the file COPYING); if not, write to the Free Software |
19 | * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
20 | */ |
21 | |
22 | #include <linux/slab.h> |
23 | |
24 | #include "types.h" |
25 | #include "debug.h" |
26 | #include "ntfs.h" |
27 | |
28 | /* |
29 | * IMPORTANT |
30 | * ========= |
31 | * |
32 | * All these routines assume that the Unicode characters are in little endian |
33 | * encoding inside the strings!!! |
34 | */ |
35 | |
36 | /* |
37 | * This is used by the name collation functions to quickly determine what |
38 | * characters are (in)valid. |
39 | */ |
40 | static const u8 legal_ansi_char_array[0x40] = { |
41 | 0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, |
42 | 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, |
43 | |
44 | 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, |
45 | 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, |
46 | |
47 | 0x17, 0x07, 0x18, 0x17, 0x17, 0x17, 0x17, 0x17, |
48 | 0x17, 0x17, 0x18, 0x16, 0x16, 0x17, 0x07, 0x00, |
49 | |
50 | 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, |
51 | 0x17, 0x17, 0x04, 0x16, 0x18, 0x16, 0x18, 0x18, |
52 | }; |
53 | |
54 | /** |
55 | * ntfs_are_names_equal - compare two Unicode names for equality |
56 | * @s1: name to compare to @s2 |
57 | * @s1_len: length in Unicode characters of @s1 |
58 | * @s2: name to compare to @s1 |
59 | * @s2_len: length in Unicode characters of @s2 |
60 | * @ic: ignore case bool |
61 | * @upcase: upcase table (only if @ic == IGNORE_CASE) |
62 | * @upcase_size: length in Unicode characters of @upcase (if present) |
63 | * |
64 | * Compare the names @s1 and @s2 and return 'true' (1) if the names are |
65 | * identical, or 'false' (0) if they are not identical. If @ic is IGNORE_CASE, |
66 | * the @upcase table is used to performa a case insensitive comparison. |
67 | */ |
68 | bool ntfs_are_names_equal(const ntfschar *s1, size_t s1_len, |
69 | const ntfschar *s2, size_t s2_len, const IGNORE_CASE_BOOL ic, |
70 | const ntfschar *upcase, const u32 upcase_size) |
71 | { |
72 | if (s1_len != s2_len) |
73 | return false; |
74 | if (ic == CASE_SENSITIVE) |
75 | return !ntfs_ucsncmp(s1, s2, s1_len); |
76 | return !ntfs_ucsncasecmp(s1, s2, s1_len, upcase, upcase_size); |
77 | } |
78 | |
79 | /** |
80 | * ntfs_collate_names - collate two Unicode names |
81 | * @name1: first Unicode name to compare |
82 | * @name2: second Unicode name to compare |
83 | * @err_val: if @name1 contains an invalid character return this value |
84 | * @ic: either CASE_SENSITIVE or IGNORE_CASE |
85 | * @upcase: upcase table (ignored if @ic is CASE_SENSITIVE) |
86 | * @upcase_len: upcase table size (ignored if @ic is CASE_SENSITIVE) |
87 | * |
88 | * ntfs_collate_names collates two Unicode names and returns: |
89 | * |
90 | * -1 if the first name collates before the second one, |
91 | * 0 if the names match, |
92 | * 1 if the second name collates before the first one, or |
93 | * @err_val if an invalid character is found in @name1 during the comparison. |
94 | * |
95 | * The following characters are considered invalid: '"', '*', '<', '>' and '?'. |
96 | */ |
97 | int ntfs_collate_names(const ntfschar *name1, const u32 name1_len, |
98 | const ntfschar *name2, const u32 name2_len, |
99 | const int err_val, const IGNORE_CASE_BOOL ic, |
100 | const ntfschar *upcase, const u32 upcase_len) |
101 | { |
102 | u32 cnt, min_len; |
103 | u16 c1, c2; |
104 | |
105 | min_len = name1_len; |
106 | if (name1_len > name2_len) |
107 | min_len = name2_len; |
108 | for (cnt = 0; cnt < min_len; ++cnt) { |
109 | c1 = le16_to_cpu(*name1++); |
110 | c2 = le16_to_cpu(*name2++); |
111 | if (ic) { |
112 | if (c1 < upcase_len) |
113 | c1 = le16_to_cpu(upcase[c1]); |
114 | if (c2 < upcase_len) |
115 | c2 = le16_to_cpu(upcase[c2]); |
116 | } |
117 | if (c1 < 64 && legal_ansi_char_array[c1] & 8) |
118 | return err_val; |
119 | if (c1 < c2) |
120 | return -1; |
121 | if (c1 > c2) |
122 | return 1; |
123 | } |
124 | if (name1_len < name2_len) |
125 | return -1; |
126 | if (name1_len == name2_len) |
127 | return 0; |
128 | /* name1_len > name2_len */ |
129 | c1 = le16_to_cpu(*name1); |
130 | if (c1 < 64 && legal_ansi_char_array[c1] & 8) |
131 | return err_val; |
132 | return 1; |
133 | } |
134 | |
135 | /** |
136 | * ntfs_ucsncmp - compare two little endian Unicode strings |
137 | * @s1: first string |
138 | * @s2: second string |
139 | * @n: maximum unicode characters to compare |
140 | * |
141 | * Compare the first @n characters of the Unicode strings @s1 and @s2, |
142 | * The strings in little endian format and appropriate le16_to_cpu() |
143 | * conversion is performed on non-little endian machines. |
144 | * |
145 | * The function returns an integer less than, equal to, or greater than zero |
146 | * if @s1 (or the first @n Unicode characters thereof) is found, respectively, |
147 | * to be less than, to match, or be greater than @s2. |
148 | */ |
149 | int ntfs_ucsncmp(const ntfschar *s1, const ntfschar *s2, size_t n) |
150 | { |
151 | u16 c1, c2; |
152 | size_t i; |
153 | |
154 | for (i = 0; i < n; ++i) { |
155 | c1 = le16_to_cpu(s1[i]); |
156 | c2 = le16_to_cpu(s2[i]); |
157 | if (c1 < c2) |
158 | return -1; |
159 | if (c1 > c2) |
160 | return 1; |
161 | if (!c1) |
162 | break; |
163 | } |
164 | return 0; |
165 | } |
166 | |
167 | /** |
168 | * ntfs_ucsncasecmp - compare two little endian Unicode strings, ignoring case |
169 | * @s1: first string |
170 | * @s2: second string |
171 | * @n: maximum unicode characters to compare |
172 | * @upcase: upcase table |
173 | * @upcase_size: upcase table size in Unicode characters |
174 | * |
175 | * Compare the first @n characters of the Unicode strings @s1 and @s2, |
176 | * ignoring case. The strings in little endian format and appropriate |
177 | * le16_to_cpu() conversion is performed on non-little endian machines. |
178 | * |
179 | * Each character is uppercased using the @upcase table before the comparison. |
180 | * |
181 | * The function returns an integer less than, equal to, or greater than zero |
182 | * if @s1 (or the first @n Unicode characters thereof) is found, respectively, |
183 | * to be less than, to match, or be greater than @s2. |
184 | */ |
185 | int ntfs_ucsncasecmp(const ntfschar *s1, const ntfschar *s2, size_t n, |
186 | const ntfschar *upcase, const u32 upcase_size) |
187 | { |
188 | size_t i; |
189 | u16 c1, c2; |
190 | |
191 | for (i = 0; i < n; ++i) { |
192 | if ((c1 = le16_to_cpu(s1[i])) < upcase_size) |
193 | c1 = le16_to_cpu(upcase[c1]); |
194 | if ((c2 = le16_to_cpu(s2[i])) < upcase_size) |
195 | c2 = le16_to_cpu(upcase[c2]); |
196 | if (c1 < c2) |
197 | return -1; |
198 | if (c1 > c2) |
199 | return 1; |
200 | if (!c1) |
201 | break; |
202 | } |
203 | return 0; |
204 | } |
205 | |
206 | void ntfs_upcase_name(ntfschar *name, u32 name_len, const ntfschar *upcase, |
207 | const u32 upcase_len) |
208 | { |
209 | u32 i; |
210 | u16 u; |
211 | |
212 | for (i = 0; i < name_len; i++) |
213 | if ((u = le16_to_cpu(name[i])) < upcase_len) |
214 | name[i] = upcase[u]; |
215 | } |
216 | |
217 | void ntfs_file_upcase_value(FILE_NAME_ATTR *file_name_attr, |
218 | const ntfschar *upcase, const u32 upcase_len) |
219 | { |
220 | ntfs_upcase_name((ntfschar*)&file_name_attr->file_name, |
221 | file_name_attr->file_name_length, upcase, upcase_len); |
222 | } |
223 | |
224 | int ntfs_file_compare_values(FILE_NAME_ATTR *file_name_attr1, |
225 | FILE_NAME_ATTR *file_name_attr2, |
226 | const int err_val, const IGNORE_CASE_BOOL ic, |
227 | const ntfschar *upcase, const u32 upcase_len) |
228 | { |
229 | return ntfs_collate_names((ntfschar*)&file_name_attr1->file_name, |
230 | file_name_attr1->file_name_length, |
231 | (ntfschar*)&file_name_attr2->file_name, |
232 | file_name_attr2->file_name_length, |
233 | err_val, ic, upcase, upcase_len); |
234 | } |
235 | |
236 | /** |
237 | * ntfs_nlstoucs - convert NLS string to little endian Unicode string |
238 | * @vol: ntfs volume which we are working with |
239 | * @ins: input NLS string buffer |
240 | * @ins_len: length of input string in bytes |
241 | * @outs: on return contains the allocated output Unicode string buffer |
242 | * |
243 | * Convert the input string @ins, which is in whatever format the loaded NLS |
244 | * map dictates, into a little endian, 2-byte Unicode string. |
245 | * |
246 | * This function allocates the string and the caller is responsible for |
247 | * calling kmem_cache_free(ntfs_name_cache, *@outs); when finished with it. |
248 | * |
249 | * On success the function returns the number of Unicode characters written to |
250 | * the output string *@outs (>= 0), not counting the terminating Unicode NULL |
251 | * character. *@outs is set to the allocated output string buffer. |
252 | * |
253 | * On error, a negative number corresponding to the error code is returned. In |
254 | * that case the output string is not allocated. Both *@outs and *@outs_len |
255 | * are then undefined. |
256 | * |
257 | * This might look a bit odd due to fast path optimization... |
258 | */ |
259 | int ntfs_nlstoucs(const ntfs_volume *vol, const char *ins, |
260 | const int ins_len, ntfschar **outs) |
261 | { |
262 | struct nls_table *nls = vol->nls_map; |
263 | ntfschar *ucs; |
264 | wchar_t wc; |
265 | int i, o, wc_len; |
266 | |
267 | /* We do not trust outside sources. */ |
268 | if (likely(ins)) { |
269 | ucs = kmem_cache_alloc(ntfs_name_cache, GFP_NOFS); |
270 | if (likely(ucs)) { |
271 | for (i = o = 0; i < ins_len; i += wc_len) { |
272 | wc_len = nls->char2uni(ins + i, ins_len - i, |
273 | &wc); |
274 | if (likely(wc_len >= 0 && |
275 | o < NTFS_MAX_NAME_LEN)) { |
276 | if (likely(wc)) { |
277 | ucs[o++] = cpu_to_le16(wc); |
278 | continue; |
279 | } /* else if (!wc) */ |
280 | break; |
281 | } /* else if (wc_len < 0 || |
282 | o >= NTFS_MAX_NAME_LEN) */ |
283 | goto name_err; |
284 | } |
285 | ucs[o] = 0; |
286 | *outs = ucs; |
287 | return o; |
288 | } /* else if (!ucs) */ |
289 | ntfs_error(vol->sb, "Failed to allocate buffer for converted " |
290 | "name from ntfs_name_cache."); |
291 | return -ENOMEM; |
292 | } /* else if (!ins) */ |
293 | ntfs_error(vol->sb, "Received NULL pointer."); |
294 | return -EINVAL; |
295 | name_err: |
296 | kmem_cache_free(ntfs_name_cache, ucs); |
297 | if (wc_len < 0) { |
298 | ntfs_error(vol->sb, "Name using character set %s contains " |
299 | "characters that cannot be converted to " |
300 | "Unicode.", nls->charset); |
301 | i = -EILSEQ; |
302 | } else /* if (o >= NTFS_MAX_NAME_LEN) */ { |
303 | ntfs_error(vol->sb, "Name is too long (maximum length for a " |
304 | "name on NTFS is %d Unicode characters.", |
305 | NTFS_MAX_NAME_LEN); |
306 | i = -ENAMETOOLONG; |
307 | } |
308 | return i; |
309 | } |
310 | |
311 | /** |
312 | * ntfs_ucstonls - convert little endian Unicode string to NLS string |
313 | * @vol: ntfs volume which we are working with |
314 | * @ins: input Unicode string buffer |
315 | * @ins_len: length of input string in Unicode characters |
316 | * @outs: on return contains the (allocated) output NLS string buffer |
317 | * @outs_len: length of output string buffer in bytes |
318 | * |
319 | * Convert the input little endian, 2-byte Unicode string @ins, of length |
320 | * @ins_len into the string format dictated by the loaded NLS. |
321 | * |
322 | * If *@outs is NULL, this function allocates the string and the caller is |
323 | * responsible for calling kfree(*@outs); when finished with it. In this case |
324 | * @outs_len is ignored and can be 0. |
325 | * |
326 | * On success the function returns the number of bytes written to the output |
327 | * string *@outs (>= 0), not counting the terminating NULL byte. If the output |
328 | * string buffer was allocated, *@outs is set to it. |
329 | * |
330 | * On error, a negative number corresponding to the error code is returned. In |
331 | * that case the output string is not allocated. The contents of *@outs are |
332 | * then undefined. |
333 | * |
334 | * This might look a bit odd due to fast path optimization... |
335 | */ |
336 | int ntfs_ucstonls(const ntfs_volume *vol, const ntfschar *ins, |
337 | const int ins_len, unsigned char **outs, int outs_len) |
338 | { |
339 | struct nls_table *nls = vol->nls_map; |
340 | unsigned char *ns; |
341 | int i, o, ns_len, wc; |
342 | |
343 | /* We don't trust outside sources. */ |
344 | if (ins) { |
345 | ns = *outs; |
346 | ns_len = outs_len; |
347 | if (ns && !ns_len) { |
348 | wc = -ENAMETOOLONG; |
349 | goto conversion_err; |
350 | } |
351 | if (!ns) { |
352 | ns_len = ins_len * NLS_MAX_CHARSET_SIZE; |
353 | ns = kmalloc(ns_len + 1, GFP_NOFS); |
354 | if (!ns) |
355 | goto mem_err_out; |
356 | } |
357 | for (i = o = 0; i < ins_len; i++) { |
358 | retry: wc = nls->uni2char(le16_to_cpu(ins[i]), ns + o, |
359 | ns_len - o); |
360 | if (wc > 0) { |
361 | o += wc; |
362 | continue; |
363 | } else if (!wc) |
364 | break; |
365 | else if (wc == -ENAMETOOLONG && ns != *outs) { |
366 | unsigned char *tc; |
367 | /* Grow in multiples of 64 bytes. */ |
368 | tc = kmalloc((ns_len + 64) & |
369 | ~63, GFP_NOFS); |
370 | if (tc) { |
371 | memcpy(tc, ns, ns_len); |
372 | ns_len = ((ns_len + 64) & ~63) - 1; |
373 | kfree(ns); |
374 | ns = tc; |
375 | goto retry; |
376 | } /* No memory so goto conversion_error; */ |
377 | } /* wc < 0, real error. */ |
378 | goto conversion_err; |
379 | } |
380 | ns[o] = 0; |
381 | *outs = ns; |
382 | return o; |
383 | } /* else (!ins) */ |
384 | ntfs_error(vol->sb, "Received NULL pointer."); |
385 | return -EINVAL; |
386 | conversion_err: |
387 | ntfs_error(vol->sb, "Unicode name contains characters that cannot be " |
388 | "converted to character set %s. You might want to " |
389 | "try to use the mount option nls=utf8.", nls->charset); |
390 | if (ns != *outs) |
391 | kfree(ns); |
392 | if (wc != -ENAMETOOLONG) |
393 | wc = -EILSEQ; |
394 | return wc; |
395 | mem_err_out: |
396 | ntfs_error(vol->sb, "Failed to allocate name!"); |
397 | return -ENOMEM; |
398 | } |
399 |
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