Loading...
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_unicode.h"
24#include "cifs_uniupr.h"
25#include "cifspdu.h"
26#include "cifsglob.h"
27#include "cifs_debug.h"
28
29/*
30 * cifs_ucs2_bytes - how long will a string be after conversion?
31 * @ucs - pointer to input string
32 * @maxbytes - don't go past this many bytes of input string
33 * @codepage - destination codepage
34 *
35 * Walk a ucs2le string and return the number of bytes that the string will
36 * be after being converted to the given charset, not including any null
37 * termination required. Don't walk past maxbytes in the source buffer.
38 */
39int
40cifs_ucs2_bytes(const __le16 *from, int maxbytes,
41 const struct nls_table *codepage)
42{
43 int i;
44 int charlen, outlen = 0;
45 int maxwords = maxbytes / 2;
46 char tmp[NLS_MAX_CHARSET_SIZE];
47 __u16 ftmp;
48
49 for (i = 0; i < maxwords; i++) {
50 ftmp = get_unaligned_le16(&from[i]);
51 if (ftmp == 0)
52 break;
53
54 charlen = codepage->uni2char(ftmp, tmp, NLS_MAX_CHARSET_SIZE);
55 if (charlen > 0)
56 outlen += charlen;
57 else
58 outlen++;
59 }
60
61 return outlen;
62}
63
64/*
65 * cifs_mapchar - convert a host-endian char to proper char in codepage
66 * @target - where converted character should be copied
67 * @src_char - 2 byte host-endian source character
68 * @cp - codepage to which character should be converted
69 * @mapchar - should character be mapped according to mapchars mount option?
70 *
71 * This function handles the conversion of a single character. It is the
72 * responsibility of the caller to ensure that the target buffer is large
73 * enough to hold the result of the conversion (at least NLS_MAX_CHARSET_SIZE).
74 */
75static int
76cifs_mapchar(char *target, const __u16 src_char, const struct nls_table *cp,
77 bool mapchar)
78{
79 int len = 1;
80
81 if (!mapchar)
82 goto cp_convert;
83
84 /*
85 * BB: Cannot handle remapping UNI_SLASH until all the calls to
86 * build_path_from_dentry are modified, as they use slash as
87 * separator.
88 */
89 switch (src_char) {
90 case UNI_COLON:
91 *target = ':';
92 break;
93 case UNI_ASTERISK:
94 *target = '*';
95 break;
96 case UNI_QUESTION:
97 *target = '?';
98 break;
99 case UNI_PIPE:
100 *target = '|';
101 break;
102 case UNI_GRTRTHAN:
103 *target = '>';
104 break;
105 case UNI_LESSTHAN:
106 *target = '<';
107 break;
108 default:
109 goto cp_convert;
110 }
111
112out:
113 return len;
114
115cp_convert:
116 len = cp->uni2char(src_char, target, NLS_MAX_CHARSET_SIZE);
117 if (len <= 0) {
118 *target = '?';
119 len = 1;
120 }
121 goto out;
122}
123
124/*
125 * cifs_from_ucs2 - convert utf16le string to local charset
126 * @to - destination buffer
127 * @from - source buffer
128 * @tolen - destination buffer size (in bytes)
129 * @fromlen - source buffer size (in bytes)
130 * @codepage - codepage to which characters should be converted
131 * @mapchar - should characters be remapped according to the mapchars option?
132 *
133 * Convert a little-endian ucs2le string (as sent by the server) to a string
134 * in the provided codepage. The tolen and fromlen parameters are to ensure
135 * that the code doesn't walk off of the end of the buffer (which is always
136 * a danger if the alignment of the source buffer is off). The destination
137 * string is always properly null terminated and fits in the destination
138 * buffer. Returns the length of the destination string in bytes (including
139 * null terminator).
140 *
141 * Note that some windows versions actually send multiword UTF-16 characters
142 * instead of straight UCS-2. The linux nls routines however aren't able to
143 * deal with those characters properly. In the event that we get some of
144 * those characters, they won't be translated properly.
145 */
146int
147cifs_from_ucs2(char *to, const __le16 *from, int tolen, int fromlen,
148 const struct nls_table *codepage, bool mapchar)
149{
150 int i, charlen, safelen;
151 int outlen = 0;
152 int nullsize = nls_nullsize(codepage);
153 int fromwords = fromlen / 2;
154 char tmp[NLS_MAX_CHARSET_SIZE];
155 __u16 ftmp;
156
157 /*
158 * because the chars can be of varying widths, we need to take care
159 * not to overflow the destination buffer when we get close to the
160 * end of it. Until we get to this offset, we don't need to check
161 * for overflow however.
162 */
163 safelen = tolen - (NLS_MAX_CHARSET_SIZE + nullsize);
164
165 for (i = 0; i < fromwords; i++) {
166 ftmp = get_unaligned_le16(&from[i]);
167 if (ftmp == 0)
168 break;
169
170 /*
171 * check to see if converting this character might make the
172 * conversion bleed into the null terminator
173 */
174 if (outlen >= safelen) {
175 charlen = cifs_mapchar(tmp, ftmp, codepage, mapchar);
176 if ((outlen + charlen) > (tolen - nullsize))
177 break;
178 }
179
180 /* put converted char into 'to' buffer */
181 charlen = cifs_mapchar(&to[outlen], ftmp, codepage, mapchar);
182 outlen += charlen;
183 }
184
185 /* properly null-terminate string */
186 for (i = 0; i < nullsize; i++)
187 to[outlen++] = 0;
188
189 return outlen;
190}
191
192/*
193 * NAME: cifs_strtoUCS()
194 *
195 * FUNCTION: Convert character string to unicode string
196 *
197 */
198int
199cifs_strtoUCS(__le16 *to, const char *from, int len,
200 const struct nls_table *codepage)
201{
202 int charlen;
203 int i;
204 wchar_t wchar_to; /* needed to quiet sparse */
205
206 for (i = 0; len && *from; i++, from += charlen, len -= charlen) {
207 charlen = codepage->char2uni(from, len, &wchar_to);
208 if (charlen < 1) {
209 cERROR(1, "strtoUCS: char2uni of 0x%x returned %d",
210 *from, charlen);
211 /* A question mark */
212 wchar_to = 0x003f;
213 charlen = 1;
214 }
215 put_unaligned_le16(wchar_to, &to[i]);
216 }
217
218 put_unaligned_le16(0, &to[i]);
219 return i;
220}
221
222/*
223 * cifs_strndup_from_ucs - copy a string from wire format to the local codepage
224 * @src - source string
225 * @maxlen - don't walk past this many bytes in the source string
226 * @is_unicode - is this a unicode string?
227 * @codepage - destination codepage
228 *
229 * Take a string given by the server, convert it to the local codepage and
230 * put it in a new buffer. Returns a pointer to the new string or NULL on
231 * error.
232 */
233char *
234cifs_strndup_from_ucs(const char *src, const int maxlen, const bool is_unicode,
235 const struct nls_table *codepage)
236{
237 int len;
238 char *dst;
239
240 if (is_unicode) {
241 len = cifs_ucs2_bytes((__le16 *) src, maxlen, codepage);
242 len += nls_nullsize(codepage);
243 dst = kmalloc(len, GFP_KERNEL);
244 if (!dst)
245 return NULL;
246 cifs_from_ucs2(dst, (__le16 *) src, len, maxlen, codepage,
247 false);
248 } else {
249 len = strnlen(src, maxlen);
250 len++;
251 dst = kmalloc(len, GFP_KERNEL);
252 if (!dst)
253 return NULL;
254 strlcpy(dst, src, len);
255 }
256
257 return dst;
258}
259
260/*
261 * Convert 16 bit Unicode pathname to wire format from string in current code
262 * page. Conversion may involve remapping up the six characters that are
263 * only legal in POSIX-like OS (if they are present in the string). Path
264 * names are little endian 16 bit Unicode on the wire
265 */
266int
267cifsConvertToUCS(__le16 *target, const char *source, int srclen,
268 const struct nls_table *cp, int mapChars)
269{
270 int i, j, charlen;
271 char src_char;
272 __le16 dst_char;
273 wchar_t tmp;
274
275 if (!mapChars)
276 return cifs_strtoUCS(target, source, PATH_MAX, cp);
277
278 for (i = 0, j = 0; i < srclen; j++) {
279 src_char = source[i];
280 charlen = 1;
281 switch (src_char) {
282 case 0:
283 put_unaligned(0, &target[j]);
284 goto ctoUCS_out;
285 case ':':
286 dst_char = cpu_to_le16(UNI_COLON);
287 break;
288 case '*':
289 dst_char = cpu_to_le16(UNI_ASTERISK);
290 break;
291 case '?':
292 dst_char = cpu_to_le16(UNI_QUESTION);
293 break;
294 case '<':
295 dst_char = cpu_to_le16(UNI_LESSTHAN);
296 break;
297 case '>':
298 dst_char = cpu_to_le16(UNI_GRTRTHAN);
299 break;
300 case '|':
301 dst_char = cpu_to_le16(UNI_PIPE);
302 break;
303 /*
304 * FIXME: We can not handle remapping backslash (UNI_SLASH)
305 * until all the calls to build_path_from_dentry are modified,
306 * as they use backslash as separator.
307 */
308 default:
309 charlen = cp->char2uni(source + i, srclen - i, &tmp);
310 dst_char = cpu_to_le16(tmp);
311
312 /*
313 * if no match, use question mark, which at least in
314 * some cases serves as wild card
315 */
316 if (charlen < 1) {
317 dst_char = cpu_to_le16(0x003f);
318 charlen = 1;
319 }
320 }
321 /*
322 * character may take more than one byte in the source string,
323 * but will take exactly two bytes in the target string
324 */
325 i += charlen;
326 put_unaligned(dst_char, &target[j]);
327 }
328
329ctoUCS_out:
330 return i;
331}
332
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 *
4 * Copyright (c) International Business Machines Corp., 2000,2009
5 * Modified by Steve French (sfrench@us.ibm.com)
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/* Convert character using the SFU - "Services for Unix" remapping range */
31static bool
32convert_sfu_char(const __u16 src_char, char *target)
33{
34 /*
35 * BB: Cannot handle remapping UNI_SLASH until all the calls to
36 * build_path_from_dentry are modified, as they use slash as
37 * separator.
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/* Convert character using the SFM - "Services for Mac" remapping range */
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 * cifs_mapchar - convert a host-endian char to proper char in codepage
109 * @target - where converted character should be copied
110 * @src_char - 2 byte host-endian source character
111 * @cp - codepage to which character should be converted
112 * @map_type - How should the 7 NTFS/SMB reserved characters be mapped to UCS2?
113 *
114 * This function handles the conversion of a single character. It is the
115 * responsibility of the caller to ensure that the target buffer is large
116 * enough to hold the result of the conversion (at least NLS_MAX_CHARSET_SIZE).
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 /* if character not one of seven in special remap set */
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 /* convert SURROGATE_PAIR and IVS */
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 * cifs_from_utf16 - convert utf16le string to local charset
157 * @to - destination buffer
158 * @from - source buffer
159 * @tolen - destination buffer size (in bytes)
160 * @fromlen - source buffer size (in bytes)
161 * @codepage - codepage to which characters should be converted
162 * @mapchar - should characters be remapped according to the mapchars option?
163 *
164 * Convert a little-endian utf16le string (as sent by the server) to a string
165 * in the provided codepage. The tolen and fromlen parameters are to ensure
166 * that the code doesn't walk off of the end of the buffer (which is always
167 * a danger if the alignment of the source buffer is off). The destination
168 * string is always properly null terminated and fits in the destination
169 * buffer. Returns the length of the destination string in bytes (including
170 * null terminator).
171 *
172 * Note that some windows versions actually send multiword UTF-16 characters
173 * instead of straight UTF16-2. The linux nls routines however aren't able to
174 * deal with those characters properly. In the event that we get some of
175 * those characters, they won't be translated properly.
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]; /* ftmp[3] = 3array x 2bytes = 6bytes UTF-16 */
187
188 /*
189 * because the chars can be of varying widths, we need to take care
190 * not to overflow the destination buffer when we get close to the
191 * end of it. Until we get to this offset, we don't need to check
192 * for overflow however.
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 * check to see if converting this character might make the
211 * conversion bleed into the null terminator
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 /* put converted char into 'to' buffer */
220 charlen = cifs_mapchar(&to[outlen], ftmp, codepage, map_type);
221 outlen += charlen;
222
223 /* charlen (=bytes of UTF-8 for 1 character)
224 * 4bytes UTF-8(surrogate pair) is charlen=4
225 * (4bytes UTF-16 code)
226 * 7-8bytes UTF-8(IVS) is charlen=3+4 or 4+4
227 * (2 UTF-8 pairs divided to 2 UTF-16 pairs) */
228 if (charlen == 4)
229 i++;
230 else if (charlen >= 5)
231 /* 5-6bytes UTF-8 */
232 i += 2;
233 }
234
235 /* properly null-terminate string */
236 for (i = 0; i < nullsize; i++)
237 to[outlen++] = 0;
238
239 return outlen;
240}
241
242/*
243 * NAME: cifs_strtoUTF16()
244 *
245 * FUNCTION: Convert character string to unicode string
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; /* needed to quiet sparse */
255
256 /* special case for utf8 to handle no plane0 chars */
257 if (!strcmp(codepage->charset, "utf8")) {
258 /*
259 * convert utf8 -> utf16, we assume we have enough space
260 * as caller should have assumed conversion does not overflow
261 * in destination len is length in wchar_t units (16bits)
262 */
263 i = utf8s_to_utf16s(from, len, UTF16_LITTLE_ENDIAN,
264 (wchar_t *) to, len);
265
266 /* if success terminate and exit */
267 if (i >= 0)
268 goto success;
269 /*
270 * if fails fall back to UCS encoding as this
271 * function should not return negative values
272 * currently can fail only if source contains
273 * invalid encoded characters
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 /* A question mark */
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 * cifs_utf16_bytes - how long will a string be after conversion?
296 * @utf16 - pointer to input string
297 * @maxbytes - don't go past this many bytes of input string
298 * @codepage - destination codepage
299 *
300 * Walk a utf16le string and return the number of bytes that the string will
301 * be after being converted to the given charset, not including any null
302 * termination required. Don't walk past maxbytes in the source buffer.
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 * cifs_strndup_from_utf16 - copy a string from wire format to the local
336 * codepage
337 * @src - source string
338 * @maxlen - don't walk past this many bytes in the source string
339 * @is_unicode - is this a unicode string?
340 * @codepage - destination codepage
341 *
342 * Take a string given by the server, convert it to the local codepage and
343 * put it in a new buffer. Returns a pointer to the new string or NULL on
344 * error.
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 * Convert 16 bit Unicode pathname to wire format from string in current code
449 * page. Conversion may involve remapping up the six characters that are
450 * only legal in POSIX-like OS (if they are present in the string). Path
451 * names are little endian 16 bit Unicode on the wire
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; /* UTF-16 */
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 /* check if end of string */
476 if (src_char == 0)
477 goto ctoUTF16_out;
478
479 /* see if we must remap this char */
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 * Remap spaces and periods found at the end of every
487 * component of the path. The special cases of '.' and
488 * '..' do not need to be dealt with explicitly because
489 * they are addressed in namei.c:link_path_walk().
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 * FIXME: We can not handle remapping backslash (UNI_SLASH)
501 * until all the calls to build_path_from_dentry are modified,
502 * as they use backslash as separator.
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 * if no match, use question mark, which at least in
510 * some cases serves as wild card
511 */
512 if (charlen > 0)
513 goto ctoUTF16;
514
515 /* convert SURROGATE_PAIR */
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 /* 1-3bytes UTF-8 to 2bytes UTF-16 */
534 put_unaligned(dst_char, &target[j]);
535 else if (charlen == 4) {
536 /* 4bytes UTF-8(surrogate pair) to 4bytes UTF-16
537 * 7-8bytes UTF-8(IVS) divided to 2 UTF-16
538 * (charlen=3+4 or 4+4) */
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 /* 5-6bytes UTF-8 to 6bytes UTF-16 */
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 * character may take more than one byte in the source string,
563 * but will take exactly two bytes in the target string
564 */
565 i += charlen;
566 put_unaligned(dst_char, &target[j]);
567 }
568
569ctoUTF16_out:
570 put_unaligned(0, &target[j]); /* Null terminate target unicode string */
571 kfree(wchar_to);
572 return j;
573}
574
575/*
576 * cifs_local_to_utf16_bytes - how long will a string be after conversion?
577 * @from - pointer to input string
578 * @maxbytes - don't go past this many bytes of input string
579 * @codepage - source codepage
580 *
581 * Walk a string and return the number of bytes that the string will
582 * be after being converted to the given charset, not including any null
583 * termination required. Don't walk past maxbytes in the source buffer.
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 /* Failed conversion defaults to a question mark */
597 if (charlen < 1)
598 charlen = 1;
599 }
600 return 2 * i; /* UTF16 characters are two bytes */
601}
602
603/*
604 * cifs_strndup_to_utf16 - copy a string to wire format from the local codepage
605 * @src - source string
606 * @maxlen - don't walk past this many bytes in the source string
607 * @utf16_len - the length of the allocated string in bytes (including null)
608 * @cp - source codepage
609 * @remap - map special chars
610 *
611 * Take a string convert it from the local codepage to UTF16 and
612 * put it in a new buffer. Returns a pointer to the new string or NULL on
613 * error.
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; /* NULL */
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}