1 /*
2 * Copyright 2013 Garrett D'Amore <garrett@damore.org>
3 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
4 * Copyright (c) 2002-2004 Tim J. Robbins. All rights reserved.
5 * Copyright (c) 1993
6 * The Regents of the University of California. All rights reserved.
7 *
8 * This code is derived from software contributed to Berkeley by
9 * Paul Borman at Krystal Technologies.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 4. Neither the name of the University nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36 #include "lint.h"
37 #include <errno.h>
38 #include <limits.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <wchar.h>
42 #include <sys/types.h>
43 #include <sys/euc.h>
44 #include "mblocal.h"
45 #include "lctype.h"
46
47 static size_t _EUC_mbrtowc_impl(wchar_t *_RESTRICT_KYWD,
48 const char *_RESTRICT_KYWD,
49 size_t, mbstate_t *_RESTRICT_KYWD, uint8_t, uint8_t, uint8_t, uint8_t);
50 static size_t _EUC_wcrtomb_impl(char *_RESTRICT_KYWD, wchar_t,
51 mbstate_t *_RESTRICT_KYWD, uint8_t, uint8_t, uint8_t, uint8_t);
52
53 static size_t _EUC_CN_mbrtowc(wchar_t *_RESTRICT_KYWD,
54 const char *_RESTRICT_KYWD,
55 size_t, mbstate_t *_RESTRICT_KYWD);
56 static size_t _EUC_JP_mbrtowc(wchar_t *_RESTRICT_KYWD,
57 const char *_RESTRICT_KYWD,
58 size_t, mbstate_t *_RESTRICT_KYWD);
59 static size_t _EUC_KR_mbrtowc(wchar_t *_RESTRICT_KYWD,
60 const char *_RESTRICT_KYWD,
61 size_t, mbstate_t *_RESTRICT_KYWD);
62 static size_t _EUC_TW_mbrtowc(wchar_t *_RESTRICT_KYWD,
63 const char *_RESTRICT_KYWD,
64 size_t, mbstate_t *_RESTRICT_KYWD);
65
66 static size_t _EUC_CN_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
67 mbstate_t *_RESTRICT_KYWD);
68 static size_t _EUC_JP_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
69 mbstate_t *_RESTRICT_KYWD);
70 static size_t _EUC_KR_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
71 mbstate_t *_RESTRICT_KYWD);
72 static size_t _EUC_TW_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
73 mbstate_t *_RESTRICT_KYWD);
74
75 static size_t _EUC_CN_mbsnrtowcs(wchar_t *_RESTRICT_KYWD,
76 const char **_RESTRICT_KYWD, size_t, size_t,
77 mbstate_t *_RESTRICT_KYWD);
78 static size_t _EUC_JP_mbsnrtowcs(wchar_t *_RESTRICT_KYWD,
79 const char **_RESTRICT_KYWD, size_t, size_t,
80 mbstate_t *_RESTRICT_KYWD);
81 static size_t _EUC_KR_mbsnrtowcs(wchar_t *_RESTRICT_KYWD,
82 const char **_RESTRICT_KYWD, size_t, size_t,
83 mbstate_t *_RESTRICT_KYWD);
84 static size_t _EUC_TW_mbsnrtowcs(wchar_t *_RESTRICT_KYWD,
85 const char **_RESTRICT_KYWD, size_t, size_t,
86 mbstate_t *_RESTRICT_KYWD);
87
88 static size_t _EUC_CN_wcsnrtombs(char *_RESTRICT_KYWD,
89 const wchar_t **_RESTRICT_KYWD, size_t, size_t,
90 mbstate_t *_RESTRICT_KYWD);
91 static size_t _EUC_JP_wcsnrtombs(char *_RESTRICT_KYWD,
92 const wchar_t **_RESTRICT_KYWD, size_t, size_t,
93 mbstate_t *_RESTRICT_KYWD);
94 static size_t _EUC_KR_wcsnrtombs(char *_RESTRICT_KYWD,
95 const wchar_t **_RESTRICT_KYWD, size_t, size_t,
96 mbstate_t *_RESTRICT_KYWD);
97 static size_t _EUC_TW_wcsnrtombs(char *_RESTRICT_KYWD,
98 const wchar_t **_RESTRICT_KYWD, size_t, size_t,
99 mbstate_t *_RESTRICT_KYWD);
100
101 static int _EUC_mbsinit(const mbstate_t *);
102
103 typedef struct {
104 wchar_t ch;
105 int set;
106 int want;
107 } _EucState;
108
109 int
110 _EUC_mbsinit(const mbstate_t *ps)
111 {
112
113 return (ps == NULL || ((const _EucState *)ps)->want == 0);
114 }
115
116 /*
117 * EUC-CN uses CS0, CS1 and CS2 (4 bytes).
118 */
119 void
120 _EUC_CN_init(struct lc_ctype *lct)
121 {
122 lct->lc_mbrtowc = _EUC_CN_mbrtowc;
123 lct->lc_wcrtomb = _EUC_CN_wcrtomb;
124 lct->lc_mbsnrtowcs = _EUC_CN_mbsnrtowcs;
125 lct->lc_wcsnrtombs = _EUC_CN_wcsnrtombs;
126 lct->lc_mbsinit = _EUC_mbsinit;
127
128 lct->lc_max_mblen = 4;
129 lct->lc_is_ascii = 0;
130 }
131
132 static size_t
133 _EUC_CN_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
134 size_t n, mbstate_t *_RESTRICT_KYWD ps)
135 {
136 return (_EUC_mbrtowc_impl(pwc, s, n, ps, SS2, 4, 0, 0));
137 }
138
139 static size_t
140 _EUC_CN_mbsnrtowcs(wchar_t *_RESTRICT_KYWD dst,
141 const char **_RESTRICT_KYWD src,
142 size_t nms, size_t len, mbstate_t *_RESTRICT_KYWD ps)
143 {
144 return (__mbsnrtowcs_std(dst, src, nms, len, ps, _EUC_CN_mbrtowc));
145 }
146
147 static size_t
148 _EUC_CN_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
149 mbstate_t *_RESTRICT_KYWD ps)
150 {
151 return (_EUC_wcrtomb_impl(s, wc, ps, SS2, 4, 0, 0));
152 }
153
154 static size_t
155 _EUC_CN_wcsnrtombs(char *_RESTRICT_KYWD dst, const wchar_t **_RESTRICT_KYWD src,
156 size_t nwc, size_t len, mbstate_t *_RESTRICT_KYWD ps)
157 {
158 return (__wcsnrtombs_std(dst, src, nwc, len, ps, _EUC_CN_wcrtomb));
159 }
160
161 /*
162 * EUC-KR uses only CS0 and CS1.
163 */
164 void
165 _EUC_KR_init(struct lc_ctype *lct)
166 {
167 lct->lc_mbrtowc = _EUC_KR_mbrtowc;
168 lct->lc_wcrtomb = _EUC_KR_wcrtomb;
169 lct->lc_mbsnrtowcs = _EUC_KR_mbsnrtowcs;
170 lct->lc_wcsnrtombs = _EUC_KR_wcsnrtombs;
171 lct->lc_mbsinit = _EUC_mbsinit;
172
173 lct->lc_max_mblen = 2;
174 lct->lc_is_ascii = 0;
175 }
176
177 static size_t
178 _EUC_KR_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
179 size_t n, mbstate_t *_RESTRICT_KYWD ps)
180 {
181 return (_EUC_mbrtowc_impl(pwc, s, n, ps, 0, 0, 0, 0));
182 }
183
184 static size_t
185 _EUC_KR_mbsnrtowcs(wchar_t *_RESTRICT_KYWD dst,
186 const char **_RESTRICT_KYWD src,
187 size_t nms, size_t len, mbstate_t *_RESTRICT_KYWD ps)
188 {
189 return (__mbsnrtowcs_std(dst, src, nms, len, ps, _EUC_KR_mbrtowc));
190 }
191
192 static size_t
193 _EUC_KR_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
194 mbstate_t *_RESTRICT_KYWD ps)
195 {
196 return (_EUC_wcrtomb_impl(s, wc, ps, 0, 0, 0, 0));
197 }
198
199 static size_t
200 _EUC_KR_wcsnrtombs(char *_RESTRICT_KYWD dst, const wchar_t **_RESTRICT_KYWD src,
201 size_t nwc, size_t len, mbstate_t *_RESTRICT_KYWD ps)
202 {
203 return (__wcsnrtombs_std(dst, src, nwc, len, ps, _EUC_KR_wcrtomb));
204 }
205
206 /*
207 * EUC-JP uses CS0, CS1, CS2, and CS3.
208 */
209 void
210 _EUC_JP_init(struct lc_ctype *lct)
211 {
212 lct->lc_mbrtowc = _EUC_JP_mbrtowc;
213 lct->lc_wcrtomb = _EUC_JP_wcrtomb;
214 lct->lc_mbsnrtowcs = _EUC_JP_mbsnrtowcs;
215 lct->lc_wcsnrtombs = _EUC_JP_wcsnrtombs;
216 lct->lc_mbsinit = _EUC_mbsinit;
217
218 lct->lc_max_mblen = 3;
219 lct->lc_is_ascii = 0;
220 }
221
222 static size_t
223 _EUC_JP_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
224 size_t n, mbstate_t *_RESTRICT_KYWD ps)
225 {
226 return (_EUC_mbrtowc_impl(pwc, s, n, ps, SS2, 2, SS3, 3));
227 }
228
229 static size_t
230 _EUC_JP_mbsnrtowcs(wchar_t *_RESTRICT_KYWD dst,
231 const char **_RESTRICT_KYWD src,
232 size_t nms, size_t len, mbstate_t *_RESTRICT_KYWD ps)
233 {
234 return (__mbsnrtowcs_std(dst, src, nms, len, ps, _EUC_JP_mbrtowc));
235 }
236
237 static size_t
238 _EUC_JP_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
239 mbstate_t *_RESTRICT_KYWD ps)
240 {
241 return (_EUC_wcrtomb_impl(s, wc, ps, SS2, 2, SS3, 3));
242 }
243
244 static size_t
245 _EUC_JP_wcsnrtombs(char *_RESTRICT_KYWD dst, const wchar_t **_RESTRICT_KYWD src,
246 size_t nwc, size_t len, mbstate_t *_RESTRICT_KYWD ps)
247 {
248 return (__wcsnrtombs_std(dst, src, nwc, len, ps, _EUC_JP_wcrtomb));
249 }
250
251 /*
252 * EUC-TW uses CS0, CS1, and CS2.
253 */
254 void
255 _EUC_TW_init(struct lc_ctype *lct)
256 {
257 lct->lc_mbrtowc = _EUC_TW_mbrtowc;
258 lct->lc_wcrtomb = _EUC_TW_wcrtomb;
259 lct->lc_mbsnrtowcs = _EUC_TW_mbsnrtowcs;
260 lct->lc_wcsnrtombs = _EUC_TW_wcsnrtombs;
261 lct->lc_mbsinit = _EUC_mbsinit;
262
263 lct->lc_max_mblen = 4;
264 lct->lc_is_ascii = 0;
265 }
266
267 static size_t
268 _EUC_TW_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
269 size_t n, mbstate_t *_RESTRICT_KYWD ps)
270 {
271 return (_EUC_mbrtowc_impl(pwc, s, n, ps, SS2, 4, 0, 0));
272 }
273
274 static size_t
275 _EUC_TW_mbsnrtowcs(wchar_t *_RESTRICT_KYWD dst,
276 const char **_RESTRICT_KYWD src,
277 size_t nms, size_t len, mbstate_t *_RESTRICT_KYWD ps)
278 {
279 return (__mbsnrtowcs_std(dst, src, nms, len, ps, _EUC_TW_mbrtowc));
280 }
281
282 static size_t
283 _EUC_TW_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
284 mbstate_t *_RESTRICT_KYWD ps)
285 {
286 return (_EUC_wcrtomb_impl(s, wc, ps, SS2, 4, 0, 0));
287 }
288
289 static size_t
290 _EUC_TW_wcsnrtombs(char *_RESTRICT_KYWD dst, const wchar_t **_RESTRICT_KYWD src,
291 size_t nwc, size_t len, mbstate_t *_RESTRICT_KYWD ps)
292 {
293 return (__wcsnrtombs_std(dst, src, nwc, len, ps, _EUC_TW_wcrtomb));
294 }
295
296 /*
297 * Common EUC code.
298 */
299
300 static size_t
301 _EUC_mbrtowc_impl(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
302 size_t n, mbstate_t *_RESTRICT_KYWD ps,
303 uint8_t cs2, uint8_t cs2width, uint8_t cs3, uint8_t cs3width)
304 {
305 _EucState *es;
306 int i, want;
307 wchar_t wc;
308 unsigned char ch;
309
310 es = (_EucState *)ps;
311
312 if (es->want < 0 || es->want > MB_CUR_MAX) {
313 errno = EINVAL;
314 return ((size_t)-1);
315 }
316
317 if (s == NULL) {
318 s = "";
319 n = 1;
320 pwc = NULL;
321 }
322
323 if (n == 0)
324 /* Incomplete multibyte sequence */
325 return ((size_t)-2);
326
327 if (es->want == 0) {
328 /* Fast path for plain ASCII (CS0) */
329 if (((ch = (unsigned char)*s) & 0x80) == 0) {
330 if (pwc != NULL)
331 *pwc = ch;
332 return (ch != '\0' ? 1 : 0);
333 }
334
335 if (ch >= 0xa1) {
336 /* CS1 */
337 want = 2;
338 } else if (ch == cs2) {
339 want = cs2width;
340 } else if (ch == cs3) {
341 want = cs3width;
342 } else {
343 errno = EILSEQ;
344 return ((size_t)-1);
345 }
346
347
348 es->want = want;
349 es->ch = 0;
350 } else {
351 want = es->want;
352 wc = es->ch;
353 }
354
355 for (i = 0; i < MIN(want, n); i++) {
356 wc <<= 8;
357 wc |= *s;
358 s++;
359 }
360 if (i < want) {
361 /* Incomplete multibyte sequence */
362 es->want = want - i;
363 es->ch = wc;
364 return ((size_t)-2);
365 }
366 if (pwc != NULL)
367 *pwc = wc;
368 es->want = 0;
369 return (wc == L'\0' ? 0 : want);
370 }
371
372 static size_t
373 _EUC_wcrtomb_impl(char *_RESTRICT_KYWD s, wchar_t wc,
374 mbstate_t *_RESTRICT_KYWD ps,
375 uint8_t cs2, uint8_t cs2width, uint8_t cs3, uint8_t cs3width)
376 {
377 _EucState *es;
378 int i, len;
379 wchar_t nm;
380
381 es = (_EucState *)ps;
382
383 if (es->want != 0) {
384 errno = EINVAL;
385 return ((size_t)-1);
386 }
387
388 if (s == NULL)
389 /* Reset to initial shift state (no-op) */
390 return (1);
391
392 if ((wc & ~0x7f) == 0) {
393 /* Fast path for plain ASCII (CS0) */
394 *s = (char)wc;
395 return (1);
396 }
397
398 /* Determine the "length" */
399 if ((unsigned)wc > 0xffffff) {
400 len = 4;
401 } else if ((unsigned)wc > 0xffff) {
402 len = 3;
403 } else if ((unsigned)wc > 0xff) {
404 len = 2;
405 } else {
406 len = 1;
407 }
408
409 if (len > MB_CUR_MAX) {
410 errno = EILSEQ;
411 return ((size_t)-1);
412 }
413
414 /* This first check excludes CS1, which is implicitly valid. */
415 if ((wc < 0xa100) || (wc > 0xffff)) {
416 /* Check for valid CS2 or CS3 */
417 nm = (wc >> ((len - 1) * 8));
418 if (nm == cs2) {
419 if (len != cs2width) {
420 errno = EILSEQ;
421 return ((size_t)-1);
422 }
423 } else if (nm == cs3) {
424 if (len != cs3width) {
425 errno = EILSEQ;
426 return ((size_t)-1);
427 }
428 } else {
429 errno = EILSEQ;
430 return ((size_t)-1);
431 }
432 }
433
434 /* Stash the bytes, least significant last */
435 for (i = len - 1; i >= 0; i--) {
436 s[i] = (wc & 0xff);
437 wc >>= 8;
438 }
439 return (len);
440 }