This source file includes following definitions.
- convert_ch_to_uni
- convert_uni_to_ch
- nls_upper
- nls_wstrchr
- nls_dosname_cmp
- nls_uniname_cmp
- nls_uniname_to_dosname
- nls_dosname_to_uniname
- nls_uniname_to_cstring
- nls_cstring_to_uniname
1
2
3
4
5
6 #include <linux/string.h>
7 #include <linux/nls.h>
8 #include "exfat.h"
9
10 static u16 bad_dos_chars[] = {
11
12 0x002B, 0x002C, 0x003B, 0x003D, 0x005B, 0x005D,
13 0xFF0B, 0xFF0C, 0xFF1B, 0xFF1D, 0xFF3B, 0xFF3D,
14 0
15 };
16
17 static u16 bad_uni_chars[] = {
18
19 0x0022, 0x002A, 0x002F, 0x003A,
20 0x003C, 0x003E, 0x003F, 0x005C, 0x007C,
21 0
22 };
23
24 static int convert_ch_to_uni(struct nls_table *nls, u16 *uni, u8 *ch,
25 bool *lossy)
26 {
27 int len;
28
29 *uni = 0x0;
30
31 if (ch[0] < 0x80) {
32 *uni = (u16)ch[0];
33 return 1;
34 }
35
36 len = nls->char2uni(ch, NLS_MAX_CHARSET_SIZE, uni);
37 if (len < 0) {
38
39 pr_info("%s: fail to use nls\n", __func__);
40 if (lossy)
41 *lossy = true;
42 *uni = (u16)'_';
43 if (!strcmp(nls->charset, "utf8"))
44 return 1;
45 else
46 return 2;
47 }
48
49 return len;
50 }
51
52 static int convert_uni_to_ch(struct nls_table *nls, u8 *ch, u16 uni,
53 bool *lossy)
54 {
55 int len;
56
57 ch[0] = 0x0;
58
59 if (uni < 0x0080) {
60 ch[0] = (u8)uni;
61 return 1;
62 }
63
64 len = nls->uni2char(uni, ch, NLS_MAX_CHARSET_SIZE);
65 if (len < 0) {
66
67 pr_info("%s: fail to use nls\n", __func__);
68 if (lossy)
69 *lossy = true;
70 ch[0] = '_';
71 return 1;
72 }
73
74 return len;
75 }
76
77 u16 nls_upper(struct super_block *sb, u16 a)
78 {
79 struct fs_info_t *p_fs = &(EXFAT_SB(sb)->fs_info);
80
81 if (EXFAT_SB(sb)->options.casesensitive)
82 return a;
83 if (p_fs->vol_utbl && p_fs->vol_utbl[get_col_index(a)])
84 return p_fs->vol_utbl[get_col_index(a)][get_row_index(a)];
85 else
86 return a;
87 }
88
89 static u16 *nls_wstrchr(u16 *str, u16 wchar)
90 {
91 while (*str) {
92 if (*(str++) == wchar)
93 return str;
94 }
95
96 return NULL;
97 }
98
99 int nls_dosname_cmp(struct super_block *sb, u8 *a, u8 *b)
100 {
101 return strncmp(a, b, DOS_NAME_LENGTH);
102 }
103
104 int nls_uniname_cmp(struct super_block *sb, u16 *a, u16 *b)
105 {
106 int i;
107
108 for (i = 0; i < MAX_NAME_LENGTH; i++, a++, b++) {
109 if (nls_upper(sb, *a) != nls_upper(sb, *b))
110 return 1;
111 if (*a == 0x0)
112 return 0;
113 }
114 return 0;
115 }
116
117 void nls_uniname_to_dosname(struct super_block *sb,
118 struct dos_name_t *p_dosname,
119 struct uni_name_t *p_uniname, bool *p_lossy)
120 {
121 int i, j, len;
122 bool lossy = false;
123 u8 buf[MAX_CHARSET_SIZE];
124 u8 lower = 0, upper = 0;
125 u8 *dosname = p_dosname->name;
126 u16 *uniname = p_uniname->name;
127 u16 *p, *last_period;
128 struct nls_table *nls = EXFAT_SB(sb)->nls_disk;
129
130 for (i = 0; i < DOS_NAME_LENGTH; i++)
131 *(dosname + i) = ' ';
132
133 if (!nls_uniname_cmp(sb, uniname, (u16 *)UNI_CUR_DIR_NAME)) {
134 *(dosname) = '.';
135 p_dosname->name_case = 0x0;
136 if (p_lossy)
137 *p_lossy = false;
138 return;
139 }
140
141 if (!nls_uniname_cmp(sb, uniname, (u16 *)UNI_PAR_DIR_NAME)) {
142 *(dosname) = '.';
143 *(dosname + 1) = '.';
144 p_dosname->name_case = 0x0;
145 if (p_lossy)
146 *p_lossy = false;
147 return;
148 }
149
150
151 last_period = NULL;
152 for (p = uniname; *p; p++) {
153 if (*p == (u16)'.')
154 last_period = p;
155 }
156
157 i = 0;
158 while (i < DOS_NAME_LENGTH) {
159 if (i == 8) {
160 if (!last_period)
161 break;
162
163 if (uniname <= last_period) {
164 if (uniname < last_period)
165 lossy = true;
166 uniname = last_period + 1;
167 }
168 }
169
170 if (*uniname == (u16)'\0') {
171 break;
172 } else if (*uniname == (u16)' ') {
173 lossy = true;
174 } else if (*uniname == (u16)'.') {
175 if (uniname < last_period)
176 lossy = true;
177 else
178 i = 8;
179 } else if (nls_wstrchr(bad_dos_chars, *uniname)) {
180 lossy = true;
181 *(dosname + i) = '_';
182 i++;
183 } else {
184 len = convert_uni_to_ch(nls, buf, *uniname, &lossy);
185
186 if (len > 1) {
187 if ((i >= 8) && ((i + len) > DOS_NAME_LENGTH))
188 break;
189
190 if ((i < 8) && ((i + len) > 8)) {
191 i = 8;
192 continue;
193 }
194
195 lower = 0xFF;
196
197 for (j = 0; j < len; j++, i++)
198 *(dosname + i) = *(buf + j);
199 } else {
200 if ((*buf >= 'a') && (*buf <= 'z')) {
201 *(dosname + i) = *buf - ('a' - 'A');
202
203 if (i < 8)
204 lower |= 0x08;
205 else
206 lower |= 0x10;
207 } else if ((*buf >= 'A') && (*buf <= 'Z')) {
208 *(dosname + i) = *buf;
209
210 if (i < 8)
211 upper |= 0x08;
212 else
213 upper |= 0x10;
214 } else {
215 *(dosname + i) = *buf;
216 }
217 i++;
218 }
219 }
220
221 uniname++;
222 }
223
224 if (*dosname == 0xE5)
225 *dosname = 0x05;
226
227 if (*uniname != 0x0)
228 lossy = true;
229
230 if (upper & lower)
231 p_dosname->name_case = 0xFF;
232 else
233 p_dosname->name_case = lower;
234
235 if (p_lossy)
236 *p_lossy = lossy;
237 }
238
239 void nls_dosname_to_uniname(struct super_block *sb,
240 struct uni_name_t *p_uniname,
241 struct dos_name_t *p_dosname)
242 {
243 int i = 0, j, n = 0;
244 u8 buf[DOS_NAME_LENGTH + 2];
245 u8 *dosname = p_dosname->name;
246 u16 *uniname = p_uniname->name;
247 struct nls_table *nls = EXFAT_SB(sb)->nls_disk;
248
249 if (*dosname == 0x05) {
250 *buf = 0xE5;
251 i++;
252 n++;
253 }
254
255 for (; i < 8; i++, n++) {
256 if (*(dosname + i) == ' ')
257 break;
258
259 if ((*(dosname + i) >= 'A') && (*(dosname + i) <= 'Z') &&
260 (p_dosname->name_case & 0x08))
261 *(buf + n) = *(dosname + i) + ('a' - 'A');
262 else
263 *(buf + n) = *(dosname + i);
264 }
265 if (*(dosname + 8) != ' ') {
266 *(buf + n) = '.';
267 n++;
268 }
269
270 for (i = 8; i < DOS_NAME_LENGTH; i++, n++) {
271 if (*(dosname + i) == ' ')
272 break;
273
274 if ((*(dosname + i) >= 'A') && (*(dosname + i) <= 'Z') &&
275 (p_dosname->name_case & 0x10))
276 *(buf + n) = *(dosname + i) + ('a' - 'A');
277 else
278 *(buf + n) = *(dosname + i);
279 }
280 *(buf + n) = '\0';
281
282 i = 0;
283 j = 0;
284 while (j < (MAX_NAME_LENGTH - 1)) {
285 if (*(buf + i) == '\0')
286 break;
287
288 i += convert_ch_to_uni(nls, uniname, (buf + i), NULL);
289
290 uniname++;
291 j++;
292 }
293
294 *uniname = (u16)'\0';
295 }
296
297 void nls_uniname_to_cstring(struct super_block *sb, u8 *p_cstring,
298 struct uni_name_t *p_uniname)
299 {
300 int i, j, len;
301 u8 buf[MAX_CHARSET_SIZE];
302 u16 *uniname = p_uniname->name;
303 struct nls_table *nls = EXFAT_SB(sb)->nls_io;
304
305 if (!nls) {
306 len = utf16s_to_utf8s(uniname, MAX_NAME_LENGTH,
307 UTF16_HOST_ENDIAN, p_cstring,
308 MAX_NAME_LENGTH);
309 p_cstring[len] = 0;
310 return;
311 }
312
313 i = 0;
314 while (i < (MAX_NAME_LENGTH - 1)) {
315 if (*uniname == (u16)'\0')
316 break;
317
318 len = convert_uni_to_ch(nls, buf, *uniname, NULL);
319
320 if (len > 1) {
321 for (j = 0; j < len; j++)
322 *p_cstring++ = (char)*(buf + j);
323 } else {
324 *p_cstring++ = (char)*buf;
325 }
326
327 uniname++;
328 i++;
329 }
330
331 *p_cstring = '\0';
332 }
333
334 void nls_cstring_to_uniname(struct super_block *sb,
335 struct uni_name_t *p_uniname, u8 *p_cstring,
336 bool *p_lossy)
337 {
338 int i, j;
339 bool lossy = false;
340 u8 *end_of_name;
341 u8 upname[MAX_NAME_LENGTH * 2];
342 u16 *uniname = p_uniname->name;
343 struct nls_table *nls = EXFAT_SB(sb)->nls_io;
344
345
346 end_of_name = p_cstring + strlen(p_cstring);
347
348 while (*(--end_of_name) == ' ') {
349 if (end_of_name < p_cstring)
350 break;
351 }
352 *(++end_of_name) = '\0';
353
354 if (strcmp(p_cstring, ".") && strcmp(p_cstring, "..")) {
355
356 while (*(--end_of_name) == '.') {
357 if (end_of_name < p_cstring)
358 break;
359 }
360 *(++end_of_name) = '\0';
361 }
362
363 if (*p_cstring == '\0')
364 lossy = true;
365
366 if (!nls) {
367 i = utf8s_to_utf16s(p_cstring, MAX_NAME_LENGTH,
368 UTF16_HOST_ENDIAN, uniname,
369 MAX_NAME_LENGTH);
370 for (j = 0; j < i; j++)
371 SET16_A(upname + j * 2, nls_upper(sb, uniname[j]));
372 uniname[i] = '\0';
373 } else {
374 i = 0;
375 j = 0;
376 while (j < (MAX_NAME_LENGTH - 1)) {
377 if (*(p_cstring + i) == '\0')
378 break;
379
380 i += convert_ch_to_uni(nls, uniname,
381 (u8 *)(p_cstring + i), &lossy);
382
383 if ((*uniname < 0x0020) ||
384 nls_wstrchr(bad_uni_chars, *uniname))
385 lossy = true;
386
387 SET16_A(upname + j * 2, nls_upper(sb, *uniname));
388
389 uniname++;
390 j++;
391 }
392
393 if (*(p_cstring + i) != '\0')
394 lossy = true;
395 *uniname = (u16)'\0';
396 }
397
398 p_uniname->name_len = j;
399 p_uniname->name_hash = calc_checksum_2byte(upname, j << 1, 0,
400 CS_DEFAULT);
401
402 if (p_lossy)
403 *p_lossy = lossy;
404 }