1/* 2 * fs/cifs/cifs_unicode.c 3 * 4 * Copyright (c) International Business Machines Corp., 2000,2009 5 * Modified by Steve French (sfrench@us.ibm.com) 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 15 * the GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21#include <linux/fs.h> 22#include <linux/slab.h> 23#include "cifs_fs_sb.h" 24#include "cifs_unicode.h" 25#include "cifs_uniupr.h" 26#include "cifspdu.h" 27#include "cifsglob.h" 28#include "cifs_debug.h" 29 30int cifs_remap(struct cifs_sb_info *cifs_sb) 31{ 32 int map_type; 33 34 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SFM_CHR) 35 map_type = SFM_MAP_UNI_RSVD; 36 else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR) 37 map_type = SFU_MAP_UNI_RSVD; 38 else 39 map_type = NO_MAP_UNI_RSVD; 40 41 return map_type; 42} 43 44/* Convert character using the SFU - "Services for Unix" remapping range */ 45static bool 46convert_sfu_char(const __u16 src_char, char *target) 47{ 48 /* 49 * BB: Cannot handle remapping UNI_SLASH until all the calls to 50 * build_path_from_dentry are modified, as they use slash as 51 * separator. 52 */ 53 switch (src_char) { 54 case UNI_COLON: 55 *target = ':'; 56 break; 57 case UNI_ASTERISK: 58 *target = '*'; 59 break; 60 case UNI_QUESTION: 61 *target = '?'; 62 break; 63 case UNI_PIPE: 64 *target = '|'; 65 break; 66 case UNI_GRTRTHAN: 67 *target = '>'; 68 break; 69 case UNI_LESSTHAN: 70 *target = '<'; 71 break; 72 default: 73 return false; 74 } 75 return true; 76} 77 78/* Convert character using the SFM - "Services for Mac" remapping range */ 79static bool 80convert_sfm_char(const __u16 src_char, char *target) 81{ 82 switch (src_char) { 83 case SFM_COLON: 84 *target = ':'; 85 break; 86 case SFM_ASTERISK: 87 *target = '*'; 88 break; 89 case SFM_QUESTION: 90 *target = '?'; 91 break; 92 case SFM_PIPE: 93 *target = '|'; 94 break; 95 case SFM_GRTRTHAN: 96 *target = '>'; 97 break; 98 case SFM_LESSTHAN: 99 *target = '<'; 100 break; 101 case SFM_SLASH: 102 *target = '\\'; 103 break; 104 default: 105 return false; 106 } 107 return true; 108} 109 110 111/* 112 * cifs_mapchar - convert a host-endian char to proper char in codepage 113 * @target - where converted character should be copied 114 * @src_char - 2 byte host-endian source character 115 * @cp - codepage to which character should be converted 116 * @map_type - How should the 7 NTFS/SMB reserved characters be mapped to UCS2? 117 * 118 * This function handles the conversion of a single character. It is the 119 * responsibility of the caller to ensure that the target buffer is large 120 * enough to hold the result of the conversion (at least NLS_MAX_CHARSET_SIZE). 121 */ 122static int 123cifs_mapchar(char *target, const __u16 *from, const struct nls_table *cp, 124 int maptype) 125{ 126 int len = 1; 127 __u16 src_char; 128 129 src_char = *from; 130 131 if ((maptype == SFM_MAP_UNI_RSVD) && convert_sfm_char(src_char, target)) 132 return len; 133 else if ((maptype == SFU_MAP_UNI_RSVD) && 134 convert_sfu_char(src_char, target)) 135 return len; 136 137 /* if character not one of seven in special remap set */ 138 len = cp->uni2char(src_char, target, NLS_MAX_CHARSET_SIZE); 139 if (len <= 0) 140 goto surrogate_pair; 141 142 return len; 143 144surrogate_pair: 145 /* convert SURROGATE_PAIR and IVS */ 146 if (strcmp(cp->charset, "utf8")) 147 goto unknown; 148 len = utf16s_to_utf8s(from, 3, UTF16_LITTLE_ENDIAN, target, 6); 149 if (len <= 0) 150 goto unknown; 151 return len; 152 153unknown: 154 *target = '?'; 155 len = 1; 156 return len; 157} 158 159/* 160 * cifs_from_utf16 - convert utf16le string to local charset 161 * @to - destination buffer 162 * @from - source buffer 163 * @tolen - destination buffer size (in bytes) 164 * @fromlen - source buffer size (in bytes) 165 * @codepage - codepage to which characters should be converted 166 * @mapchar - should characters be remapped according to the mapchars option? 167 * 168 * Convert a little-endian utf16le string (as sent by the server) to a string 169 * in the provided codepage. The tolen and fromlen parameters are to ensure 170 * that the code doesn't walk off of the end of the buffer (which is always 171 * a danger if the alignment of the source buffer is off). The destination 172 * string is always properly null terminated and fits in the destination 173 * buffer. Returns the length of the destination string in bytes (including 174 * null terminator). 175 * 176 * Note that some windows versions actually send multiword UTF-16 characters 177 * instead of straight UTF16-2. The linux nls routines however aren't able to 178 * deal with those characters properly. In the event that we get some of 179 * those characters, they won't be translated properly. 180 */ 181int 182cifs_from_utf16(char *to, const __le16 *from, int tolen, int fromlen, 183 const struct nls_table *codepage, int map_type) 184{ 185 int i, charlen, safelen; 186 int outlen = 0; 187 int nullsize = nls_nullsize(codepage); 188 int fromwords = fromlen / 2; 189 char tmp[NLS_MAX_CHARSET_SIZE]; 190 __u16 ftmp[3]; /* ftmp[3] = 3array x 2bytes = 6bytes UTF-16 */ 191 192 /* 193 * because the chars can be of varying widths, we need to take care 194 * not to overflow the destination buffer when we get close to the 195 * end of it. Until we get to this offset, we don't need to check 196 * for overflow however. 197 */ 198 safelen = tolen - (NLS_MAX_CHARSET_SIZE + nullsize); 199 200 for (i = 0; i < fromwords; i++) { 201 ftmp[0] = get_unaligned_le16(&from[i]); 202 if (ftmp[0] == 0) 203 break; 204 if (i + 1 < fromwords) 205 ftmp[1] = get_unaligned_le16(&from[i + 1]); 206 else 207 ftmp[1] = 0; 208 if (i + 2 < fromwords) 209 ftmp[2] = get_unaligned_le16(&from[i + 2]); 210 else 211 ftmp[2] = 0; 212 213 /* 214 * check to see if converting this character might make the 215 * conversion bleed into the null terminator 216 */ 217 if (outlen >= safelen) { 218 charlen = cifs_mapchar(tmp, ftmp, codepage, map_type); 219 if ((outlen + charlen) > (tolen - nullsize)) 220 break; 221 } 222 223 /* put converted char into 'to' buffer */ 224 charlen = cifs_mapchar(&to[outlen], ftmp, codepage, map_type); 225 outlen += charlen; 226 227 /* charlen (=bytes of UTF-8 for 1 character) 228 * 4bytes UTF-8(surrogate pair) is charlen=4 229 * (4bytes UTF-16 code) 230 * 7-8bytes UTF-8(IVS) is charlen=3+4 or 4+4 231 * (2 UTF-8 pairs divided to 2 UTF-16 pairs) */ 232 if (charlen == 4) 233 i++; 234 else if (charlen >= 5) 235 /* 5-6bytes UTF-8 */ 236 i += 2; 237 } 238 239 /* properly null-terminate string */ 240 for (i = 0; i < nullsize; i++) 241 to[outlen++] = 0; 242 243 return outlen; 244} 245 246/* 247 * NAME: cifs_strtoUTF16() 248 * 249 * FUNCTION: Convert character string to unicode string 250 * 251 */ 252int 253cifs_strtoUTF16(__le16 *to, const char *from, int len, 254 const struct nls_table *codepage) 255{ 256 int charlen; 257 int i; 258 wchar_t wchar_to; /* needed to quiet sparse */ 259 260 /* special case for utf8 to handle no plane0 chars */ 261 if (!strcmp(codepage->charset, "utf8")) { 262 /* 263 * convert utf8 -> utf16, we assume we have enough space 264 * as caller should have assumed conversion does not overflow 265 * in destination len is length in wchar_t units (16bits) 266 */ 267 i = utf8s_to_utf16s(from, len, UTF16_LITTLE_ENDIAN, 268 (wchar_t *) to, len); 269 270 /* if success terminate and exit */ 271 if (i >= 0) 272 goto success; 273 /* 274 * if fails fall back to UCS encoding as this 275 * function should not return negative values 276 * currently can fail only if source contains 277 * invalid encoded characters 278 */ 279 } 280 281 for (i = 0; len && *from; i++, from += charlen, len -= charlen) { 282 charlen = codepage->char2uni(from, len, &wchar_to); 283 if (charlen < 1) { 284 cifs_dbg(VFS, "strtoUTF16: char2uni of 0x%x returned %d\n", 285 *from, charlen); 286 /* A question mark */ 287 wchar_to = 0x003f; 288 charlen = 1; 289 } 290 put_unaligned_le16(wchar_to, &to[i]); 291 } 292 293success: 294 put_unaligned_le16(0, &to[i]); 295 return i; 296} 297 298/* 299 * cifs_utf16_bytes - how long will a string be after conversion? 300 * @utf16 - pointer to input string 301 * @maxbytes - don't go past this many bytes of input string 302 * @codepage - destination codepage 303 * 304 * Walk a utf16le string and return the number of bytes that the string will 305 * be after being converted to the given charset, not including any null 306 * termination required. Don't walk past maxbytes in the source buffer. 307 */ 308int 309cifs_utf16_bytes(const __le16 *from, int maxbytes, 310 const struct nls_table *codepage) 311{ 312 int i; 313 int charlen, outlen = 0; 314 int maxwords = maxbytes / 2; 315 char tmp[NLS_MAX_CHARSET_SIZE]; 316 __u16 ftmp[3]; 317 318 for (i = 0; i < maxwords; i++) { 319 ftmp[0] = get_unaligned_le16(&from[i]); 320 if (ftmp[0] == 0) 321 break; 322 if (i + 1 < maxwords) 323 ftmp[1] = get_unaligned_le16(&from[i + 1]); 324 else 325 ftmp[1] = 0; 326 if (i + 2 < maxwords) 327 ftmp[2] = get_unaligned_le16(&from[i + 2]); 328 else 329 ftmp[2] = 0; 330 331 charlen = cifs_mapchar(tmp, ftmp, codepage, NO_MAP_UNI_RSVD); 332 outlen += charlen; 333 } 334 335 return outlen; 336} 337 338/* 339 * cifs_strndup_from_utf16 - copy a string from wire format to the local 340 * codepage 341 * @src - source string 342 * @maxlen - don't walk past this many bytes in the source string 343 * @is_unicode - is this a unicode string? 344 * @codepage - destination codepage 345 * 346 * Take a string given by the server, convert it to the local codepage and 347 * put it in a new buffer. Returns a pointer to the new string or NULL on 348 * error. 349 */ 350char * 351cifs_strndup_from_utf16(const char *src, const int maxlen, 352 const bool is_unicode, const struct nls_table *codepage) 353{ 354 int len; 355 char *dst; 356 357 if (is_unicode) { 358 len = cifs_utf16_bytes((__le16 *) src, maxlen, codepage); 359 len += nls_nullsize(codepage); 360 dst = kmalloc(len, GFP_KERNEL); 361 if (!dst) 362 return NULL; 363 cifs_from_utf16(dst, (__le16 *) src, len, maxlen, codepage, 364 NO_MAP_UNI_RSVD); 365 } else { 366 len = strnlen(src, maxlen); 367 len++; 368 dst = kmalloc(len, GFP_KERNEL); 369 if (!dst) 370 return NULL; 371 strlcpy(dst, src, len); 372 } 373 374 return dst; 375} 376 377static __le16 convert_to_sfu_char(char src_char) 378{ 379 __le16 dest_char; 380 381 switch (src_char) { 382 case ':': 383 dest_char = cpu_to_le16(UNI_COLON); 384 break; 385 case '*': 386 dest_char = cpu_to_le16(UNI_ASTERISK); 387 break; 388 case '?': 389 dest_char = cpu_to_le16(UNI_QUESTION); 390 break; 391 case '<': 392 dest_char = cpu_to_le16(UNI_LESSTHAN); 393 break; 394 case '>': 395 dest_char = cpu_to_le16(UNI_GRTRTHAN); 396 break; 397 case '|': 398 dest_char = cpu_to_le16(UNI_PIPE); 399 break; 400 default: 401 dest_char = 0; 402 } 403 404 return dest_char; 405} 406 407static __le16 convert_to_sfm_char(char src_char) 408{ 409 __le16 dest_char; 410 411 switch (src_char) { 412 case ':': 413 dest_char = cpu_to_le16(SFM_COLON); 414 break; 415 case '*': 416 dest_char = cpu_to_le16(SFM_ASTERISK); 417 break; 418 case '?': 419 dest_char = cpu_to_le16(SFM_QUESTION); 420 break; 421 case '<': 422 dest_char = cpu_to_le16(SFM_LESSTHAN); 423 break; 424 case '>': 425 dest_char = cpu_to_le16(SFM_GRTRTHAN); 426 break; 427 case '|': 428 dest_char = cpu_to_le16(SFM_PIPE); 429 break; 430 default: 431 dest_char = 0; 432 } 433 434 return dest_char; 435} 436 437/* 438 * Convert 16 bit Unicode pathname to wire format from string in current code 439 * page. Conversion may involve remapping up the six characters that are 440 * only legal in POSIX-like OS (if they are present in the string). Path 441 * names are little endian 16 bit Unicode on the wire 442 */ 443int 444cifsConvertToUTF16(__le16 *target, const char *source, int srclen, 445 const struct nls_table *cp, int map_chars) 446{ 447 int i, charlen; 448 int j = 0; 449 char src_char; 450 __le16 dst_char; 451 wchar_t tmp; 452 wchar_t *wchar_to; /* UTF-16 */ 453 int ret; 454 unicode_t u; 455 456 if (map_chars == NO_MAP_UNI_RSVD) 457 return cifs_strtoUTF16(target, source, PATH_MAX, cp); 458 459 wchar_to = kzalloc(6, GFP_KERNEL); 460 461 for (i = 0; i < srclen; j++) { 462 src_char = source[i]; 463 charlen = 1; 464 465 /* check if end of string */ 466 if (src_char == 0) 467 goto ctoUTF16_out; 468 469 /* see if we must remap this char */ 470 if (map_chars == SFU_MAP_UNI_RSVD) 471 dst_char = convert_to_sfu_char(src_char); 472 else if (map_chars == SFM_MAP_UNI_RSVD) 473 dst_char = convert_to_sfm_char(src_char); 474 else 475 dst_char = 0; 476 /* 477 * FIXME: We can not handle remapping backslash (UNI_SLASH) 478 * until all the calls to build_path_from_dentry are modified, 479 * as they use backslash as separator. 480 */ 481 if (dst_char == 0) { 482 charlen = cp->char2uni(source + i, srclen - i, &tmp); 483 dst_char = cpu_to_le16(tmp); 484 485 /* 486 * if no match, use question mark, which at least in 487 * some cases serves as wild card 488 */ 489 if (charlen > 0) 490 goto ctoUTF16; 491 492 /* convert SURROGATE_PAIR */ 493 if (strcmp(cp->charset, "utf8") || !wchar_to) 494 goto unknown; 495 if (*(source + i) & 0x80) { 496 charlen = utf8_to_utf32(source + i, 6, &u); 497 if (charlen < 0) 498 goto unknown; 499 } else 500 goto unknown; 501 ret = utf8s_to_utf16s(source + i, charlen, 502 UTF16_LITTLE_ENDIAN, 503 wchar_to, 6); 504 if (ret < 0) 505 goto unknown; 506 507 i += charlen; 508 dst_char = cpu_to_le16(*wchar_to); 509 if (charlen <= 3) 510 /* 1-3bytes UTF-8 to 2bytes UTF-16 */ 511 put_unaligned(dst_char, &target[j]); 512 else if (charlen == 4) { 513 /* 4bytes UTF-8(surrogate pair) to 4bytes UTF-16 514 * 7-8bytes UTF-8(IVS) divided to 2 UTF-16 515 * (charlen=3+4 or 4+4) */ 516 put_unaligned(dst_char, &target[j]); 517 dst_char = cpu_to_le16(*(wchar_to + 1)); 518 j++; 519 put_unaligned(dst_char, &target[j]); 520 } else if (charlen >= 5) { 521 /* 5-6bytes UTF-8 to 6bytes UTF-16 */ 522 put_unaligned(dst_char, &target[j]); 523 dst_char = cpu_to_le16(*(wchar_to + 1)); 524 j++; 525 put_unaligned(dst_char, &target[j]); 526 dst_char = cpu_to_le16(*(wchar_to + 2)); 527 j++; 528 put_unaligned(dst_char, &target[j]); 529 } 530 continue; 531 532unknown: 533 dst_char = cpu_to_le16(0x003f); 534 charlen = 1; 535 } 536 537ctoUTF16: 538 /* 539 * character may take more than one byte in the source string, 540 * but will take exactly two bytes in the target string 541 */ 542 i += charlen; 543 put_unaligned(dst_char, &target[j]); 544 } 545 546ctoUTF16_out: 547 put_unaligned(0, &target[j]); /* Null terminate target unicode string */ 548 kfree(wchar_to); 549 return j; 550} 551 552#ifdef CONFIG_CIFS_SMB2 553/* 554 * cifs_local_to_utf16_bytes - how long will a string be after conversion? 555 * @from - pointer to input string 556 * @maxbytes - don't go past this many bytes of input string 557 * @codepage - source codepage 558 * 559 * Walk a string and return the number of bytes that the string will 560 * be after being converted to the given charset, not including any null 561 * termination required. Don't walk past maxbytes in the source buffer. 562 */ 563 564static int 565cifs_local_to_utf16_bytes(const char *from, int len, 566 const struct nls_table *codepage) 567{ 568 int charlen; 569 int i; 570 wchar_t wchar_to; 571 572 for (i = 0; len && *from; i++, from += charlen, len -= charlen) { 573 charlen = codepage->char2uni(from, len, &wchar_to); 574 /* Failed conversion defaults to a question mark */ 575 if (charlen < 1) 576 charlen = 1; 577 } 578 return 2 * i; /* UTF16 characters are two bytes */ 579} 580 581/* 582 * cifs_strndup_to_utf16 - copy a string to wire format from the local codepage 583 * @src - source string 584 * @maxlen - don't walk past this many bytes in the source string 585 * @utf16_len - the length of the allocated string in bytes (including null) 586 * @cp - source codepage 587 * @remap - map special chars 588 * 589 * Take a string convert it from the local codepage to UTF16 and 590 * put it in a new buffer. Returns a pointer to the new string or NULL on 591 * error. 592 */ 593__le16 * 594cifs_strndup_to_utf16(const char *src, const int maxlen, int *utf16_len, 595 const struct nls_table *cp, int remap) 596{ 597 int len; 598 __le16 *dst; 599 600 len = cifs_local_to_utf16_bytes(src, maxlen, cp); 601 len += 2; /* NULL */ 602 dst = kmalloc(len, GFP_KERNEL); 603 if (!dst) { 604 *utf16_len = 0; 605 return NULL; 606 } 607 cifsConvertToUTF16(dst, src, strlen(src), cp, remap); 608 *utf16_len = len; 609 return dst; 610} 611#endif /* CONFIG_CIFS_SMB2 */ 612