2 * fs/cifs/cifs_unicode.c
4 * Copyright (c) International Business Machines Corp., 2000,2005
5 * Modified by Steve French (sfrench@us.ibm.com)
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.
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.
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
22 #include "cifs_unicode.h"
23 #include "cifs_uniupr.h"
26 #include "cifs_debug.h"
29 * cifs_ucs2_bytes - how long will a string be after conversion?
30 * @ucs - pointer to input string
31 * @maxbytes - don't go past this many bytes of input string
32 * @codepage - destination codepage
34 * Walk a ucs2le string and return the number of bytes that the string will
35 * be after being converted to the given charset, not including any null
36 * termination required. Don't walk past maxbytes in the source buffer.
39 cifs_ucs2_bytes(const __le16
*from
, int maxbytes
,
40 const struct nls_table
*codepage
)
43 int charlen
, outlen
= 0;
44 int maxwords
= maxbytes
/ 2;
45 char tmp
[NLS_MAX_CHARSET_SIZE
];
47 for (i
= 0; from
[i
] && i
< maxwords
; i
++) {
48 charlen
= codepage
->uni2char(le16_to_cpu(from
[i
]), tmp
,
49 NLS_MAX_CHARSET_SIZE
);
60 * cifs_mapchar - convert a little-endian char to proper char in codepage
61 * @target - where converted character should be copied
62 * @src_char - 2 byte little-endian source character
63 * @cp - codepage to which character should be converted
64 * @mapchar - should character be mapped according to mapchars mount option?
66 * This function handles the conversion of a single character. It is the
67 * responsibility of the caller to ensure that the target buffer is large
68 * enough to hold the result of the conversion (at least NLS_MAX_CHARSET_SIZE).
71 cifs_mapchar(char *target
, const __le16 src_char
, const struct nls_table
*cp
,
80 * BB: Cannot handle remapping UNI_SLASH until all the calls to
81 * build_path_from_dentry are modified, as they use slash as
84 switch (le16_to_cpu(src_char
)) {
111 len
= cp
->uni2char(le16_to_cpu(src_char
), target
,
112 NLS_MAX_CHARSET_SIZE
);
121 * cifs_from_ucs2 - convert utf16le string to local charset
122 * @to - destination buffer
123 * @from - source buffer
124 * @tolen - destination buffer size (in bytes)
125 * @fromlen - source buffer size (in bytes)
126 * @codepage - codepage to which characters should be converted
127 * @mapchar - should characters be remapped according to the mapchars option?
129 * Convert a little-endian ucs2le string (as sent by the server) to a string
130 * in the provided codepage. The tolen and fromlen parameters are to ensure
131 * that the code doesn't walk off of the end of the buffer (which is always
132 * a danger if the alignment of the source buffer is off). The destination
133 * string is always properly null terminated and fits in the destination
134 * buffer. Returns the length of the destination string in bytes (including
137 * Note that some windows versions actually send multiword UTF-16 characters
138 * instead of straight UCS-2. The linux nls routines however aren't able to
139 * deal with those characters properly. In the event that we get some of
140 * those characters, they won't be translated properly.
143 cifs_from_ucs2(char *to
, const __le16
*from
, int tolen
, int fromlen
,
144 const struct nls_table
*codepage
, bool mapchar
)
146 int i
, charlen
, safelen
;
148 int nullsize
= nls_nullsize(codepage
);
149 int fromwords
= fromlen
/ 2;
150 char tmp
[NLS_MAX_CHARSET_SIZE
];
153 * because the chars can be of varying widths, we need to take care
154 * not to overflow the destination buffer when we get close to the
155 * end of it. Until we get to this offset, we don't need to check
156 * for overflow however.
158 safelen
= tolen
- (NLS_MAX_CHARSET_SIZE
+ nullsize
);
160 for (i
= 0; i
< fromwords
&& from
[i
]; i
++) {
162 * check to see if converting this character might make the
163 * conversion bleed into the null terminator
165 if (outlen
>= safelen
) {
166 charlen
= cifs_mapchar(tmp
, from
[i
], codepage
, mapchar
);
167 if ((outlen
+ charlen
) > (tolen
- nullsize
))
171 /* put converted char into 'to' buffer */
172 charlen
= cifs_mapchar(&to
[outlen
], from
[i
], codepage
, mapchar
);
176 /* properly null-terminate string */
177 for (i
= 0; i
< nullsize
; i
++)
184 * NAME: cifs_strfromUCS()
186 * FUNCTION: Convert little-endian unicode string to character string
190 cifs_strfromUCS_le(char *to
, const __le16
*from
,
191 int len
, const struct nls_table
*codepage
)
196 for (i
= 0; (i
< len
) && from
[i
]; i
++) {
198 /* 2.4.0 kernel or greater */
200 codepage
->uni2char(le16_to_cpu(from
[i
]), &to
[outlen
],
201 NLS_MAX_CHARSET_SIZE
);
213 * NAME: cifs_strtoUCS()
215 * FUNCTION: Convert character string to unicode string
219 cifs_strtoUCS(__le16
*to
, const char *from
, int len
,
220 const struct nls_table
*codepage
)
224 wchar_t *wchar_to
= (wchar_t *)to
; /* needed to quiet sparse */
226 for (i
= 0; len
&& *from
; i
++, from
+= charlen
, len
-= charlen
) {
228 /* works for 2.4.0 kernel or later */
229 charlen
= codepage
->char2uni(from
, len
, &wchar_to
[i
]);
232 ("strtoUCS: char2uni of %d returned %d",
233 (int)*from
, charlen
));
234 /* A question mark */
235 to
[i
] = cpu_to_le16(0x003f);
238 to
[i
] = cpu_to_le16(wchar_to
[i
]);
This page took 0.067357 seconds and 5 git commands to generate.