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 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 */ 71static int 72cifs_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 108out: 109 return len; 110 111cp_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 */ 143int 144cifs_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 */ 190int 191cifs_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 */ 228char * 229cifs_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