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