xref: /titanic_51/usr/src/common/smbsrv/smb_oem.c (revision 7f11fd00fc23e2af7ae21cc8837a2b86380dcfa7)
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 }
376