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