1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 *
25 * Copyright 2014 Nexenta Systems, Inc. All rights reserved.
26 */
27
28 /*
29 * Support for oem <-> unicode translations.
30 */
31
32 #if !defined(_KERNEL) && !defined(_FAKE_KERNEL)
33 #include <stdlib.h>
34 #include <thread.h>
35 #include <synch.h>
36 #include <string.h>
37 #else
38 #include <sys/ksynch.h>
39 #endif /* _KERNEL */
40
41 #include <sys/byteorder.h>
42 #include <smbsrv/alloc.h>
43 #include <smbsrv/string.h>
44
45 /*
46 * cpid The oemcpg_table index for this oempage.
47 * value The conversion values.
48 */
49 typedef struct oempage {
50 uint32_t cpid;
51 smb_wchar_t *value;
52 } oempage_t;
53
54 /*
55 * filename The actual filename contains the codepage.
56 * bytesperchar The codepage uses double or single bytes per char.
57 * oempage The oempage is used to convert Unicode characters to
58 * OEM characters. Memory needs to be allocated for
59 * the value field of oempage to store the table.
60 * ucspage The unicode page is used to convert OEM characters
61 * to Unicode characters. Memory needs to be allocated
62 * for the value field of ucspage to store the table.
63 * valid True if the codepage has been initialized.
64 */
65 typedef struct oem_codepage {
66 char *filename;
67 uint32_t bytesperchar;
68 oempage_t oempage;
69 oempage_t ucspage;
70 boolean_t valid;
71 } oem_codepage_t;
72
73 static oem_codepage_t oemcpg_table[] = {
74 {"850.cpg", 1, {0, 0}, {0, 0}, 0}, /* Multilingual Latin1 */
75 {"950.cpg", 2, {1, 0}, {1, 0}, 0}, /* Chinese Traditional */
76 {"1252.cpg", 1, {2, 0}, {2, 0}, 0}, /* MS Latin1 */
77 {"949.cpg", 2, {3, 0}, {3, 0}, 0}, /* Korean */
78 {"936.cpg", 2, {4, 0}, {4, 0}, 0}, /* Chinese Simplified */
79 {"932.cpg", 2, {5, 0}, {5, 0}, 0}, /* Japanese */
80 {"852.cpg", 1, {6, 0}, {6, 0}, 0}, /* Multilingual Latin2 */
81 {"1250.cpg", 1, {7, 0}, {7, 0}, 0}, /* MS Latin2 */
82 {"1253.cpg", 1, {8, 0}, {8, 0}, 0}, /* MS Greek */
83 {"737.cpg", 1, {9, 0}, {9, 0}, 0}, /* Greek */
84 {"1254.cpg", 1, {10, 0}, {10, 0}, 0}, /* MS Turkish */
85 {"857.cpg", 1, {11, 0}, {11, 0}, 0}, /* Multilingual Latin5 */
86 {"1251.cpg", 1, {12, 0}, {12, 0}, 0}, /* MS Cyrillic */
87 {"866.cpg", 1, {13, 0}, {13, 0}, 0}, /* Cyrillic II */
88 {"1255.cpg", 1, {14, 0}, {14, 0}, 0}, /* MS Hebrew */
89 {"862.cpg", 1, {15, 0}, {15, 0}, 0}, /* Hebrew */
90 {"1256.cpg", 1, {16, 0}, {16, 0}, 0}, /* MS Arabic */
91 {"720.cpg", 1, {17, 0}, {17, 0}, 0} /* Arabic */
92 };
93
94 #define MAX_OEMPAGES (sizeof (oemcpg_table) / sizeof (oemcpg_table[0]))
95 #define MAX_UNICODE_IDX 65536
96
97 /*
98 * The default SMB OEM codepage for English is codepage 850.
99 */
100 const smb_wchar_t oem_codepage_850[256] = {
101 0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
102 0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
103 0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
104 0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
105 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
106 0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
107 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
108 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
109 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
110 0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
111 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
112 0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
113 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
114 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
115 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
116 0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
117 0x00C7, 0x00FC, 0x00E9, 0x00E2, 0x00E4, 0x00E0, 0x00E5, 0x00E7,
118 0x00EA, 0x00EB, 0x00E8, 0x00EF, 0x00EE, 0x00EC, 0x00C4, 0x00C5,
119 0x00C9, 0x00E6, 0x00C6, 0x00F4, 0x00F6, 0x00F2, 0x00FB, 0x00F9,
120 0x00FF, 0x00D6, 0x00DC, 0x00F8, 0x00A3, 0x00D8, 0x00D7, 0x0192,
121 0x00E1, 0x00ED, 0x00F3, 0x00FA, 0x00F1, 0x00D1, 0x00AA, 0x00BA,
122 0x00BF, 0x00AE, 0x00AC, 0x00BD, 0x00BC, 0x00A1, 0x00AB, 0x00BB,
123 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x00C1, 0x00C2, 0x00C0,
124 0x00A9, 0x2563, 0x2551, 0x2557, 0x255D, 0x00A2, 0x00A5, 0x2510,
125 0x2514, 0x2534, 0x252C, 0x251C, 0x2500, 0x253C, 0x00E3, 0x00C3,
126 0x255A, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256C, 0x00A4,
127 0x00F0, 0x00D0, 0x00CA, 0x00CB, 0x00C8, 0x0131, 0x00CD, 0x00CE,
128 0x00CF, 0x2518, 0x250C, 0x2588, 0x2584, 0x00A6, 0x00CC, 0x2580,
129 0x00D3, 0x00DF, 0x00D4, 0x00D2, 0x00F5, 0x00D5, 0x00B5, 0x00FE,
130 0x00DE, 0x00DA, 0x00DB, 0x00D9, 0x00FD, 0x00DD, 0x00AF, 0x00B4,
131 0x00AD, 0x00B1, 0x2017, 0x00BE, 0x00B6, 0x00A7, 0x00F7, 0x00B8,
132 0x00B0, 0x00A8, 0x00B7, 0x00B9, 0x00B3, 0x00B2, 0x25A0, 0x00A0
133 };
134
135 /*
136 * The default telnet OEM codepage for English is codepage 1252.
137 */
138 const smb_wchar_t oem_codepage_1252[256] = {
139 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8,
140 0x9, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, 0x10,
141 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
142 0x19, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F, 0x20,
143 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
144 0x29, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F, 0x30,
145 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38,
146 0x39, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F, 0x40,
147 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
148 0x49, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x50,
149 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
150 0x59, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F, 0x60,
151 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
152 0x69, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, 0x70,
153 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
154 0x79, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F, 0x20AC,
155 0x81, 0x201A, 0x192, 0x201E, 0x2026, 0x2020, 0x2021, 0x02C6,
156 0x2030, 0x160, 0x2039, 0x152, 0x8D, 0x017D, 0x8F, 0x90,
157 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0x02DC,
158 0x2122, 0x161, 0x203A, 0x153, 0x9D, 0x017E, 0x178, 0x00A0,
159 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7, 0x00A8,
160 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF, 0x00B0,
161 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7, 0x00B8,
162 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF, 0x00C0,
163 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C8,
164 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF, 0x00D0,
165 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7, 0x00D8,
166 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF, 0x00E0,
167 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8,
168 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, 0x00F0,
169 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7, 0x00F8,
170 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF
171 };
172
173 static oempage_t *oem_get_oempage(uint32_t);
174 static oempage_t *oem_get_ucspage(uint32_t);
175 static void oem_codepage_init(uint32_t);
176 static void oem_codepage_setup(uint32_t);
177
178 /*
179 * Convert a unicode string to an oem string.
180 *
181 * The conversion will stop at the end of the unicode string
182 * or when (nbytes - 1) oem characters have been stored.
183 *
184 * The number of converted unicode characters is returned,
185 * or 0 on error.
186 */
187 size_t
188 ucstooem(char *oem, const smb_wchar_t *ucs, size_t nbytes, uint32_t cpid)
189 {
190 oempage_t *ucspage;
191 uint32_t count = 0;
192 smb_wchar_t oemchar;
193
194 if (ucs == NULL || oem == NULL)
195 return (0);
196
197 if ((ucspage = oem_get_ucspage(cpid)) == NULL)
198 return (0);
199
200 while (nbytes != 0 && (oemchar = ucspage->value[*ucs]) != 0) {
201 if (oemchar & 0xff00 && nbytes >= MTS_MB_CHAR_MAX) {
202 *oem++ = oemchar >> 8;
203 *oem++ = (char)oemchar;
204 nbytes -= 2;
205 } else if (nbytes > 1) {
206 *oem++ = (char)oemchar;
207 nbytes--;
208 } else {
209 break;
210 }
211
212 count++;
213 ucs++;
214 }
215
216 *oem = '\0';
217 return (count);
218 }
219
220 /*
221 * Convert an oem string to a unicode string.
222 *
223 * The conversion will stop at the end of the oem string or
224 * when nwchars - 1 have been converted.
225 *
226 * The number of converted oem chars is returned, or 0 on error.
227 * An oem char may be either 1 or 2 bytes.
228 */
229 size_t
230 oemtoucs(smb_wchar_t *ucs, const char *oem, size_t nwchars, uint32_t cpid)
231 {
232 oempage_t *oempage;
233 size_t count = nwchars;
234 smb_wchar_t oemchar;
235
236 if (ucs == NULL || oem == NULL)
237 return (0);
238
239 if ((oempage = oem_get_oempage(cpid)) == NULL)
240 return (0);
241
242 while ((oemchar = (smb_wchar_t)*oem++ & 0xff) != 0) {
243 /*
244 * Cannot find one byte oemchar in table.
245 * Must be a lead byte. Try two bytes.
246 */
247 if ((oempage->value[oemchar] == 0) && (oemchar != 0)) {
248 oemchar = oemchar << 8 | (*oem++ & 0xff);
249 if (oempage->value[oemchar] == 0) {
250 *ucs = 0;
251 break;
252 }
253 }
254 #ifdef _BIG_ENDIAN
255 *ucs = LE_IN16(&oempage->value[oemchar]);
256 #else
257 *ucs = oempage->value[oemchar];
258 #endif
259 count--;
260 ucs++;
261 }
262
263 *ucs = 0;
264 return (nwchars - count);
265 }
266
267 /*
268 * Get a pointer to the oem page for the specific codepage id.
269 */
270 static oempage_t *
271 oem_get_oempage(uint32_t cpid)
272 {
273 if (cpid >= MAX_OEMPAGES)
274 return (NULL);
275
276 if (!oemcpg_table[cpid].valid) {
277 oem_codepage_init(cpid);
278
279 if (!oemcpg_table[cpid].valid)
280 return (NULL);
281 }
282
283 return (&oemcpg_table[cpid].oempage);
284 }
285
286 /*
287 * Get a pointer to the ucs page for the specific codepage id.
288 */
289 static oempage_t *
290 oem_get_ucspage(uint32_t cpid)
291 {
292 if (cpid >= MAX_OEMPAGES)
293 return (NULL);
294
295 if (!oemcpg_table[cpid].valid) {
296 oem_codepage_init(cpid);
297
298 if (!oemcpg_table[cpid].valid)
299 return (NULL);
300 }
301
302 return (&oemcpg_table[cpid].ucspage);
303 }
304
305 /*
306 * Initialize the oem page in the oem table.
307 */
308 static void
309 oem_codepage_init(uint32_t cpid)
310 {
311 #if !defined(_KERNEL) && !defined(_FAKE_KERNEL)
312 static mutex_t mutex;
313
314 (void) mutex_lock(&mutex);
315 oem_codepage_setup(cpid);
316 (void) mutex_unlock(&mutex);
317 #else
318 static kmutex_t mutex;
319
320 mutex_enter(&mutex);
321 oem_codepage_setup(cpid);
322 mutex_exit(&mutex);
323 #endif /* _KERNEL */
324 }
325
326 static void
327 oem_codepage_setup(uint32_t cpid)
328 {
329 const smb_wchar_t *default_oem_cp;
330 oem_codepage_t *oemcpg;
331 uint32_t bytesperchar;
332 uint32_t max_oem_index;
333 int i;
334
335 switch (cpid) {
336 case OEM_CPG_850:
337 default_oem_cp = oem_codepage_850;
338 break;
339 case OEM_CPG_1252:
340 default_oem_cp = oem_codepage_1252;
341 default:
342 return;
343 }
344
345 oemcpg = &oemcpg_table[cpid];
346 if (oemcpg->valid)
347 return;
348
349 /*
350 * max_oem_index will be 256 or 65536 dependent
351 * on the OEM codepage.
352 */
353 bytesperchar = oemcpg_table[cpid].bytesperchar;
354 max_oem_index = 1 << (bytesperchar * 8);
355
356 oemcpg->oempage.value =
357 MEM_ZALLOC("oem", max_oem_index * sizeof (smb_wchar_t));
358 if (oemcpg->oempage.value == NULL)
359 return;
360
361 oemcpg->ucspage.value =
362 MEM_ZALLOC("oem", MAX_UNICODE_IDX * sizeof (smb_wchar_t));
363 if (oemcpg->ucspage.value == NULL) {
364 MEM_FREE("oem", oemcpg->oempage.value);
365 oemcpg->oempage.value = NULL;
366 return;
367 }
368
369 for (i = 0; i < max_oem_index; i++) {
370 oemcpg->oempage.value[i] = default_oem_cp[i];
371 oemcpg->ucspage.value[default_oem_cp[i]] = (smb_wchar_t)i;
372 }
373
374 oemcpg->valid = B_TRUE;
375 }