Merge branch 'for-rmk/samsung3' of git://git.fluff.org/bjdooks/linux into devel-stable
[pandora-kernel.git] / fs / cifs / cifs_unicode.c
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  */
39 int
40 cifs_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
48         for (i = 0; i < maxwords && from[i]; i++) {
49                 charlen = codepage->uni2char(le16_to_cpu(from[i]), tmp,
50                                              NLS_MAX_CHARSET_SIZE);
51                 if (charlen > 0)
52                         outlen += charlen;
53                 else
54                         outlen++;
55         }
56
57         return outlen;
58 }
59
60 /*
61  * cifs_mapchar - convert a little-endian char to proper char in codepage
62  * @target - where converted character should be copied
63  * @src_char - 2 byte little-endian source character
64  * @cp - codepage to which character should be converted
65  * @mapchar - should character be mapped according to mapchars mount option?
66  *
67  * This function handles the conversion of a single character. It is the
68  * responsibility of the caller to ensure that the target buffer is large
69  * enough to hold the result of the conversion (at least NLS_MAX_CHARSET_SIZE).
70  */
71 static int
72 cifs_mapchar(char *target, const __le16 src_char, const struct nls_table *cp,
73              bool mapchar)
74 {
75         int len = 1;
76
77         if (!mapchar)
78                 goto cp_convert;
79
80         /*
81          * BB: Cannot handle remapping UNI_SLASH until all the calls to
82          *     build_path_from_dentry are modified, as they use slash as
83          *     separator.
84          */
85         switch (le16_to_cpu(src_char)) {
86         case UNI_COLON:
87                 *target = ':';
88                 break;
89         case UNI_ASTERIK:
90                 *target = '*';
91                 break;
92         case UNI_QUESTION:
93                 *target = '?';
94                 break;
95         case UNI_PIPE:
96                 *target = '|';
97                 break;
98         case UNI_GRTRTHAN:
99                 *target = '>';
100                 break;
101         case UNI_LESSTHAN:
102                 *target = '<';
103                 break;
104         default:
105                 goto cp_convert;
106         }
107
108 out:
109         return len;
110
111 cp_convert:
112         len = cp->uni2char(le16_to_cpu(src_char), target,
113                            NLS_MAX_CHARSET_SIZE);
114         if (len <= 0) {
115                 *target = '?';
116                 len = 1;
117         }
118         goto out;
119 }
120
121 /*
122  * cifs_from_ucs2 - convert utf16le string to local charset
123  * @to - destination buffer
124  * @from - source buffer
125  * @tolen - destination buffer size (in bytes)
126  * @fromlen - source buffer size (in bytes)
127  * @codepage - codepage to which characters should be converted
128  * @mapchar - should characters be remapped according to the mapchars option?
129  *
130  * Convert a little-endian ucs2le string (as sent by the server) to a string
131  * in the provided codepage. The tolen and fromlen parameters are to ensure
132  * that the code doesn't walk off of the end of the buffer (which is always
133  * a danger if the alignment of the source buffer is off). The destination
134  * string is always properly null terminated and fits in the destination
135  * buffer. Returns the length of the destination string in bytes (including
136  * null terminator).
137  *
138  * Note that some windows versions actually send multiword UTF-16 characters
139  * instead of straight UCS-2. The linux nls routines however aren't able to
140  * deal with those characters properly. In the event that we get some of
141  * those characters, they won't be translated properly.
142  */
143 int
144 cifs_from_ucs2(char *to, const __le16 *from, int tolen, int fromlen,
145                  const struct nls_table *codepage, bool mapchar)
146 {
147         int i, charlen, safelen;
148         int outlen = 0;
149         int nullsize = nls_nullsize(codepage);
150         int fromwords = fromlen / 2;
151         char tmp[NLS_MAX_CHARSET_SIZE];
152
153         /*
154          * because the chars can be of varying widths, we need to take care
155          * not to overflow the destination buffer when we get close to the
156          * end of it. Until we get to this offset, we don't need to check
157          * for overflow however.
158          */
159         safelen = tolen - (NLS_MAX_CHARSET_SIZE + nullsize);
160
161         for (i = 0; i < fromwords && from[i]; i++) {
162                 /*
163                  * check to see if converting this character might make the
164                  * conversion bleed into the null terminator
165                  */
166                 if (outlen >= safelen) {
167                         charlen = cifs_mapchar(tmp, from[i], codepage, mapchar);
168                         if ((outlen + charlen) > (tolen - nullsize))
169                                 break;
170                 }
171
172                 /* put converted char into 'to' buffer */
173                 charlen = cifs_mapchar(&to[outlen], from[i], codepage, mapchar);
174                 outlen += charlen;
175         }
176
177         /* properly null-terminate string */
178         for (i = 0; i < nullsize; i++)
179                 to[outlen++] = 0;
180
181         return outlen;
182 }
183
184 /*
185  * NAME:        cifs_strtoUCS()
186  *
187  * FUNCTION:    Convert character string to unicode string
188  *
189  */
190 int
191 cifs_strtoUCS(__le16 *to, const char *from, int len,
192               const struct nls_table *codepage)
193 {
194         int charlen;
195         int i;
196         wchar_t *wchar_to = (wchar_t *)to; /* needed to quiet sparse */
197
198         for (i = 0; len && *from; i++, from += charlen, len -= charlen) {
199
200                 /* works for 2.4.0 kernel or later */
201                 charlen = codepage->char2uni(from, len, &wchar_to[i]);
202                 if (charlen < 1) {
203                         cERROR(1, "strtoUCS: char2uni of %d returned %d",
204                                 (int)*from, charlen);
205                         /* A question mark */
206                         to[i] = cpu_to_le16(0x003f);
207                         charlen = 1;
208                 } else
209                         to[i] = cpu_to_le16(wchar_to[i]);
210
211         }
212
213         to[i] = 0;
214         return i;
215 }
216
217 /*
218  * cifs_strndup_from_ucs - copy a string from wire format to the local codepage
219  * @src - source string
220  * @maxlen - don't walk past this many bytes in the source string
221  * @is_unicode - is this a unicode string?
222  * @codepage - destination codepage
223  *
224  * Take a string given by the server, convert it to the local codepage and
225  * put it in a new buffer. Returns a pointer to the new string or NULL on
226  * error.
227  */
228 char *
229 cifs_strndup_from_ucs(const char *src, const int maxlen, const bool is_unicode,
230              const struct nls_table *codepage)
231 {
232         int len;
233         char *dst;
234
235         if (is_unicode) {
236                 len = cifs_ucs2_bytes((__le16 *) src, maxlen, codepage);
237                 len += nls_nullsize(codepage);
238                 dst = kmalloc(len, GFP_KERNEL);
239                 if (!dst)
240                         return NULL;
241                 cifs_from_ucs2(dst, (__le16 *) src, len, maxlen, codepage,
242                                false);
243         } else {
244                 len = strnlen(src, maxlen);
245                 len++;
246                 dst = kmalloc(len, GFP_KERNEL);
247                 if (!dst)
248                         return NULL;
249                 strlcpy(dst, src, len);
250         }
251
252         return dst;
253 }
254