1
2
3
4
5
6
7#include <linux/fs.h>
8#include <linux/slab.h>
9#include "cifs_fs_sb.h"
10#include "cifs_unicode.h"
11#include "cifs_uniupr.h"
12#include "cifspdu.h"
13#include "cifsglob.h"
14#include "cifs_debug.h"
15
16int cifs_remap(struct cifs_sb_info *cifs_sb)
17{
18 int map_type;
19
20 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR)
21 map_type = SFM_MAP_UNI_RSVD;
22 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
23 map_type = SFU_MAP_UNI_RSVD;
24 else
25 map_type = NO_MAP_UNI_RSVD;
26
27 return map_type;
28}
29
30
31static bool
32convert_sfu_char(const __u16 src_char, char *target)
33{
34
35
36
37
38
39 switch (src_char) {
40 case UNI_COLON:
41 *target = ':';
42 break;
43 case UNI_ASTERISK:
44 *target = '*';
45 break;
46 case UNI_QUESTION:
47 *target = '?';
48 break;
49 case UNI_PIPE:
50 *target = '|';
51 break;
52 case UNI_GRTRTHAN:
53 *target = '>';
54 break;
55 case UNI_LESSTHAN:
56 *target = '<';
57 break;
58 default:
59 return false;
60 }
61 return true;
62}
63
64
65static bool
66convert_sfm_char(const __u16 src_char, char *target)
67{
68 if (src_char >= 0xF001 && src_char <= 0xF01F) {
69 *target = src_char - 0xF000;
70 return true;
71 }
72 switch (src_char) {
73 case SFM_COLON:
74 *target = ':';
75 break;
76 case SFM_DOUBLEQUOTE:
77 *target = '"';
78 break;
79 case SFM_ASTERISK:
80 *target = '*';
81 break;
82 case SFM_QUESTION:
83 *target = '?';
84 break;
85 case SFM_PIPE:
86 *target = '|';
87 break;
88 case SFM_GRTRTHAN:
89 *target = '>';
90 break;
91 case SFM_LESSTHAN:
92 *target = '<';
93 break;
94 case SFM_SPACE:
95 *target = ' ';
96 break;
97 case SFM_PERIOD:
98 *target = '.';
99 break;
100 default:
101 return false;
102 }
103 return true;
104}
105
106
107
108
109
110
111
112
113
114
115
116
117
118static int
119cifs_mapchar(char *target, const __u16 *from, const struct nls_table *cp,
120 int maptype)
121{
122 int len = 1;
123 __u16 src_char;
124
125 src_char = *from;
126
127 if ((maptype == SFM_MAP_UNI_RSVD) && convert_sfm_char(src_char, target))
128 return len;
129 else if ((maptype == SFU_MAP_UNI_RSVD) &&
130 convert_sfu_char(src_char, target))
131 return len;
132
133
134 len = cp->uni2char(src_char, target, NLS_MAX_CHARSET_SIZE);
135 if (len <= 0)
136 goto surrogate_pair;
137
138 return len;
139
140surrogate_pair:
141
142 if (strcmp(cp->charset, "utf8"))
143 goto unknown;
144 len = utf16s_to_utf8s(from, 3, UTF16_LITTLE_ENDIAN, target, 6);
145 if (len <= 0)
146 goto unknown;
147 return len;
148
149unknown:
150 *target = '?';
151 len = 1;
152 return len;
153}
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177int
178cifs_from_utf16(char *to, const __le16 *from, int tolen, int fromlen,
179 const struct nls_table *codepage, int map_type)
180{
181 int i, charlen, safelen;
182 int outlen = 0;
183 int nullsize = nls_nullsize(codepage);
184 int fromwords = fromlen / 2;
185 char tmp[NLS_MAX_CHARSET_SIZE];
186 __u16 ftmp[3];
187
188
189
190
191
192
193
194 safelen = tolen - (NLS_MAX_CHARSET_SIZE + nullsize);
195
196 for (i = 0; i < fromwords; i++) {
197 ftmp[0] = get_unaligned_le16(&from[i]);
198 if (ftmp[0] == 0)
199 break;
200 if (i + 1 < fromwords)
201 ftmp[1] = get_unaligned_le16(&from[i + 1]);
202 else
203 ftmp[1] = 0;
204 if (i + 2 < fromwords)
205 ftmp[2] = get_unaligned_le16(&from[i + 2]);
206 else
207 ftmp[2] = 0;
208
209
210
211
212
213 if (outlen >= safelen) {
214 charlen = cifs_mapchar(tmp, ftmp, codepage, map_type);
215 if ((outlen + charlen) > (tolen - nullsize))
216 break;
217 }
218
219
220 charlen = cifs_mapchar(&to[outlen], ftmp, codepage, map_type);
221 outlen += charlen;
222
223
224
225
226
227
228 if (charlen == 4)
229 i++;
230 else if (charlen >= 5)
231
232 i += 2;
233 }
234
235
236 for (i = 0; i < nullsize; i++)
237 to[outlen++] = 0;
238
239 return outlen;
240}
241
242
243
244
245
246
247
248int
249cifs_strtoUTF16(__le16 *to, const char *from, int len,
250 const struct nls_table *codepage)
251{
252 int charlen;
253 int i;
254 wchar_t wchar_to;
255
256
257 if (!strcmp(codepage->charset, "utf8")) {
258
259
260
261
262
263 i = utf8s_to_utf16s(from, len, UTF16_LITTLE_ENDIAN,
264 (wchar_t *) to, len);
265
266
267 if (i >= 0)
268 goto success;
269
270
271
272
273
274
275 }
276
277 for (i = 0; len && *from; i++, from += charlen, len -= charlen) {
278 charlen = codepage->char2uni(from, len, &wchar_to);
279 if (charlen < 1) {
280 cifs_dbg(VFS, "strtoUTF16: char2uni of 0x%x returned %d\n",
281 *from, charlen);
282
283 wchar_to = 0x003f;
284 charlen = 1;
285 }
286 put_unaligned_le16(wchar_to, &to[i]);
287 }
288
289success:
290 put_unaligned_le16(0, &to[i]);
291 return i;
292}
293
294
295
296
297
298
299
300
301
302
303
304int
305cifs_utf16_bytes(const __le16 *from, int maxbytes,
306 const struct nls_table *codepage)
307{
308 int i;
309 int charlen, outlen = 0;
310 int maxwords = maxbytes / 2;
311 char tmp[NLS_MAX_CHARSET_SIZE];
312 __u16 ftmp[3];
313
314 for (i = 0; i < maxwords; i++) {
315 ftmp[0] = get_unaligned_le16(&from[i]);
316 if (ftmp[0] == 0)
317 break;
318 if (i + 1 < maxwords)
319 ftmp[1] = get_unaligned_le16(&from[i + 1]);
320 else
321 ftmp[1] = 0;
322 if (i + 2 < maxwords)
323 ftmp[2] = get_unaligned_le16(&from[i + 2]);
324 else
325 ftmp[2] = 0;
326
327 charlen = cifs_mapchar(tmp, ftmp, codepage, NO_MAP_UNI_RSVD);
328 outlen += charlen;
329 }
330
331 return outlen;
332}
333
334
335
336
337
338
339
340
341
342
343
344
345
346char *
347cifs_strndup_from_utf16(const char *src, const int maxlen,
348 const bool is_unicode, const struct nls_table *codepage)
349{
350 int len;
351 char *dst;
352
353 if (is_unicode) {
354 len = cifs_utf16_bytes((__le16 *) src, maxlen, codepage);
355 len += nls_nullsize(codepage);
356 dst = kmalloc(len, GFP_KERNEL);
357 if (!dst)
358 return NULL;
359 cifs_from_utf16(dst, (__le16 *) src, len, maxlen, codepage,
360 NO_MAP_UNI_RSVD);
361 } else {
362 dst = kstrndup(src, maxlen, GFP_KERNEL);
363 }
364
365 return dst;
366}
367
368static __le16 convert_to_sfu_char(char src_char)
369{
370 __le16 dest_char;
371
372 switch (src_char) {
373 case ':':
374 dest_char = cpu_to_le16(UNI_COLON);
375 break;
376 case '*':
377 dest_char = cpu_to_le16(UNI_ASTERISK);
378 break;
379 case '?':
380 dest_char = cpu_to_le16(UNI_QUESTION);
381 break;
382 case '<':
383 dest_char = cpu_to_le16(UNI_LESSTHAN);
384 break;
385 case '>':
386 dest_char = cpu_to_le16(UNI_GRTRTHAN);
387 break;
388 case '|':
389 dest_char = cpu_to_le16(UNI_PIPE);
390 break;
391 default:
392 dest_char = 0;
393 }
394
395 return dest_char;
396}
397
398static __le16 convert_to_sfm_char(char src_char, bool end_of_string)
399{
400 __le16 dest_char;
401
402 if (src_char >= 0x01 && src_char <= 0x1F) {
403 dest_char = cpu_to_le16(src_char + 0xF000);
404 return dest_char;
405 }
406 switch (src_char) {
407 case ':':
408 dest_char = cpu_to_le16(SFM_COLON);
409 break;
410 case '"':
411 dest_char = cpu_to_le16(SFM_DOUBLEQUOTE);
412 break;
413 case '*':
414 dest_char = cpu_to_le16(SFM_ASTERISK);
415 break;
416 case '?':
417 dest_char = cpu_to_le16(SFM_QUESTION);
418 break;
419 case '<':
420 dest_char = cpu_to_le16(SFM_LESSTHAN);
421 break;
422 case '>':
423 dest_char = cpu_to_le16(SFM_GRTRTHAN);
424 break;
425 case '|':
426 dest_char = cpu_to_le16(SFM_PIPE);
427 break;
428 case '.':
429 if (end_of_string)
430 dest_char = cpu_to_le16(SFM_PERIOD);
431 else
432 dest_char = 0;
433 break;
434 case ' ':
435 if (end_of_string)
436 dest_char = cpu_to_le16(SFM_SPACE);
437 else
438 dest_char = 0;
439 break;
440 default:
441 dest_char = 0;
442 }
443
444 return dest_char;
445}
446
447
448
449
450
451
452
453int
454cifsConvertToUTF16(__le16 *target, const char *source, int srclen,
455 const struct nls_table *cp, int map_chars)
456{
457 int i, charlen;
458 int j = 0;
459 char src_char;
460 __le16 dst_char;
461 wchar_t tmp;
462 wchar_t *wchar_to;
463 int ret;
464 unicode_t u;
465
466 if (map_chars == NO_MAP_UNI_RSVD)
467 return cifs_strtoUTF16(target, source, PATH_MAX, cp);
468
469 wchar_to = kzalloc(6, GFP_KERNEL);
470
471 for (i = 0; i < srclen; j++) {
472 src_char = source[i];
473 charlen = 1;
474
475
476 if (src_char == 0)
477 goto ctoUTF16_out;
478
479
480 if (map_chars == SFU_MAP_UNI_RSVD)
481 dst_char = convert_to_sfu_char(src_char);
482 else if (map_chars == SFM_MAP_UNI_RSVD) {
483 bool end_of_string;
484
485
486
487
488
489
490
491 if ((i == srclen - 1) || (source[i+1] == '\\'))
492 end_of_string = true;
493 else
494 end_of_string = false;
495
496 dst_char = convert_to_sfm_char(src_char, end_of_string);
497 } else
498 dst_char = 0;
499
500
501
502
503
504 if (dst_char == 0) {
505 charlen = cp->char2uni(source + i, srclen - i, &tmp);
506 dst_char = cpu_to_le16(tmp);
507
508
509
510
511
512 if (charlen > 0)
513 goto ctoUTF16;
514
515
516 if (strcmp(cp->charset, "utf8") || !wchar_to)
517 goto unknown;
518 if (*(source + i) & 0x80) {
519 charlen = utf8_to_utf32(source + i, 6, &u);
520 if (charlen < 0)
521 goto unknown;
522 } else
523 goto unknown;
524 ret = utf8s_to_utf16s(source + i, charlen,
525 UTF16_LITTLE_ENDIAN,
526 wchar_to, 6);
527 if (ret < 0)
528 goto unknown;
529
530 i += charlen;
531 dst_char = cpu_to_le16(*wchar_to);
532 if (charlen <= 3)
533
534 put_unaligned(dst_char, &target[j]);
535 else if (charlen == 4) {
536
537
538
539 put_unaligned(dst_char, &target[j]);
540 dst_char = cpu_to_le16(*(wchar_to + 1));
541 j++;
542 put_unaligned(dst_char, &target[j]);
543 } else if (charlen >= 5) {
544
545 put_unaligned(dst_char, &target[j]);
546 dst_char = cpu_to_le16(*(wchar_to + 1));
547 j++;
548 put_unaligned(dst_char, &target[j]);
549 dst_char = cpu_to_le16(*(wchar_to + 2));
550 j++;
551 put_unaligned(dst_char, &target[j]);
552 }
553 continue;
554
555unknown:
556 dst_char = cpu_to_le16(0x003f);
557 charlen = 1;
558 }
559
560ctoUTF16:
561
562
563
564
565 i += charlen;
566 put_unaligned(dst_char, &target[j]);
567 }
568
569ctoUTF16_out:
570 put_unaligned(0, &target[j]);
571 kfree(wchar_to);
572 return j;
573}
574
575
576
577
578
579
580
581
582
583
584
585
586static int
587cifs_local_to_utf16_bytes(const char *from, int len,
588 const struct nls_table *codepage)
589{
590 int charlen;
591 int i;
592 wchar_t wchar_to;
593
594 for (i = 0; len && *from; i++, from += charlen, len -= charlen) {
595 charlen = codepage->char2uni(from, len, &wchar_to);
596
597 if (charlen < 1)
598 charlen = 1;
599 }
600 return 2 * i;
601}
602
603
604
605
606
607
608
609
610
611
612
613
614
615__le16 *
616cifs_strndup_to_utf16(const char *src, const int maxlen, int *utf16_len,
617 const struct nls_table *cp, int remap)
618{
619 int len;
620 __le16 *dst;
621
622 len = cifs_local_to_utf16_bytes(src, maxlen, cp);
623 len += 2;
624 dst = kmalloc(len, GFP_KERNEL);
625 if (!dst) {
626 *utf16_len = 0;
627 return NULL;
628 }
629 cifsConvertToUTF16(dst, src, strlen(src), cp, remap);
630 *utf16_len = len;
631 return dst;
632}
633