xlat16_iconv.c revision 330897 
1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2003, 2005 Ryuichiro Imura
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 * $FreeBSD: stable/11/lib/libkiconv/xlat16_iconv.c 330897 2018-03-14 03:19:51Z eadler $
29 */
30
31/*
32 * kiconv(3) requires shared linked, and reduce module size
33 * when statically linked.
34 */
35
36#ifdef PIC
37
38#include <sys/types.h>
39#include <sys/iconv.h>
40#include <sys/sysctl.h>
41
42#include <ctype.h>
43#include <dlfcn.h>
44#include <err.h>
45#include <errno.h>
46#include <locale.h>
47#include <stdio.h>
48#include <stdlib.h>
49#include <string.h>
50#include <wctype.h>
51
52#include "quirks.h"
53
54struct xlat16_table {
55	uint32_t *	idx[0x200];
56	void *		data;
57	size_t		size;
58};
59
60static struct xlat16_table kiconv_xlat16_open(const char *, const char *, int);
61static int chklocale(int, const char *);
62
63#ifdef ICONV_DLOPEN
64typedef void *iconv_t;
65static int my_iconv_init(void);
66static iconv_t (*my_iconv_open)(const char *, const char *);
67static size_t (*my_iconv)(iconv_t, char **, size_t *, char **, size_t *);
68static int (*my_iconv_close)(iconv_t);
69#else
70#include <iconv.h>
71#define my_iconv_init() 0
72#define my_iconv_open iconv_open
73#define my_iconv iconv
74#define my_iconv_close iconv_close
75#endif
76static size_t my_iconv_char(iconv_t, u_char **, size_t *, u_char **, size_t *);
77
78int
79kiconv_add_xlat16_cspair(const char *tocode, const char *fromcode, int flag)
80{
81	int error;
82	size_t idxsize;
83	struct xlat16_table xt;
84	void *data;
85	char *p;
86	const char unicode[] = ENCODING_UNICODE;
87
88	if ((flag & KICONV_WCTYPE) == 0 &&
89	    strcmp(unicode, tocode) != 0 &&
90	    strcmp(unicode, fromcode) != 0 &&
91	    kiconv_lookupconv(unicode) == 0) {
92		error = kiconv_add_xlat16_cspair(unicode, fromcode, flag);
93		if (error)
94			return (-1);
95		error = kiconv_add_xlat16_cspair(tocode, unicode, flag);
96		return (error);
97	}
98
99	if (kiconv_lookupcs(tocode, fromcode) == 0)
100		return (0);
101
102	if (flag & KICONV_WCTYPE)
103		xt = kiconv_xlat16_open(fromcode, fromcode, flag);
104	else
105		xt = kiconv_xlat16_open(tocode, fromcode, flag);
106	if (xt.size == 0)
107		return (-1);
108
109	idxsize = sizeof(xt.idx);
110
111	if ((idxsize + xt.size) > ICONV_CSMAXDATALEN) {
112		errno = E2BIG;
113		return (-1);
114	}
115
116	if ((data = malloc(idxsize + xt.size)) != NULL) {
117		p = data;
118		memcpy(p, xt.idx, idxsize);
119		p += idxsize;
120		memcpy(p, xt.data, xt.size);
121		error = kiconv_add_xlat16_table(tocode, fromcode, data,
122		    (int)(idxsize + xt.size));
123		return (error);
124	}
125
126	return (-1);
127}
128
129int
130kiconv_add_xlat16_cspairs(const char *foreigncode, const char *localcode)
131{
132	int error, locale;
133
134	error = kiconv_add_xlat16_cspair(foreigncode, localcode,
135	    KICONV_FROM_LOWER | KICONV_FROM_UPPER);
136	if (error)
137		return (error);
138	error = kiconv_add_xlat16_cspair(localcode, foreigncode,
139	    KICONV_LOWER | KICONV_UPPER);
140	if (error)
141		return (error);
142	locale = chklocale(LC_CTYPE, localcode);
143	if (locale == 0) {
144		error = kiconv_add_xlat16_cspair(KICONV_WCTYPE_NAME, localcode,
145		    KICONV_WCTYPE);
146		if (error)
147			return (error);
148	}
149
150	return (0);
151}
152
153static struct xlat16_table
154kiconv_xlat16_open(const char *tocode, const char *fromcode, int lcase)
155{
156	u_char src[3], dst[4], *srcp, *dstp, ud, ld;
157	int us, ls, ret;
158	uint16_t c;
159	uint32_t table[0x80];
160	size_t inbytesleft, outbytesleft, pre_q_size, post_q_size;
161	struct xlat16_table xt;
162	struct quirk_replace_list *pre_q_list, *post_q_list;
163	iconv_t cd;
164	char *p;
165
166	xt.data = NULL;
167	xt.size = 0;
168
169	src[2] = '\0';
170	dst[3] = '\0';
171
172	ret = my_iconv_init();
173	if (ret)
174		return (xt);
175
176	cd = my_iconv_open(search_quirk(tocode, fromcode, &pre_q_list, &pre_q_size),
177	    search_quirk(fromcode, tocode, &post_q_list, &post_q_size));
178	if (cd == (iconv_t) (-1))
179		return (xt);
180
181	if ((xt.data = malloc(0x200 * 0x80 * sizeof(uint32_t))) == NULL)
182		return (xt);
183
184	p = xt.data;
185
186	for (ls = 0 ; ls < 0x200 ; ls++) {
187		xt.idx[ls] = NULL;
188		for (us = 0 ; us < 0x80 ; us++) {
189			srcp = src;
190			dstp = dst;
191
192			inbytesleft = 2;
193			outbytesleft = 3;
194			bzero(dst, outbytesleft);
195
196			c = ((ls & 0x100 ? us | 0x80 : us) << 8) | (u_char)ls;
197
198			if (lcase & KICONV_WCTYPE) {
199				if ((c & 0xff) == 0)
200					c >>= 8;
201				if (iswupper(c)) {
202					c = towlower(c);
203					if ((c & 0xff00) == 0)
204						c <<= 8;
205					table[us] = c | XLAT16_HAS_LOWER_CASE;
206				} else if (iswlower(c)) {
207					c = towupper(c);
208					if ((c & 0xff00) == 0)
209						c <<= 8;
210					table[us] = c | XLAT16_HAS_UPPER_CASE;
211				} else
212					table[us] = 0;
213				/*
214				 * store not NULL
215				 */
216				if (table[us])
217					xt.idx[ls] = table;
218
219				continue;
220			}
221
222			c = quirk_vendor2unix(c, pre_q_list, pre_q_size);
223			src[0] = (u_char)(c >> 8);
224			src[1] = (u_char)c;
225
226			ret = my_iconv_char(cd, &srcp, &inbytesleft,
227				&dstp, &outbytesleft);
228			if (ret == -1) {
229				table[us] = 0;
230				continue;
231			}
232
233			ud = (u_char)dst[0];
234			ld = (u_char)dst[1];
235
236			switch(outbytesleft) {
237			case 0:
238#ifdef XLAT16_ACCEPT_3BYTE_CHR
239				table[us] = (ud << 8) | ld;
240				table[us] |= (u_char)dst[2] << 16;
241				table[us] |= XLAT16_IS_3BYTE_CHR;
242#else
243				table[us] = 0;
244				continue;
245#endif
246				break;
247			case 1:
248				table[us] = quirk_unix2vendor((ud << 8) | ld,
249				    post_q_list, post_q_size);
250				if ((table[us] >> 8) == 0)
251					table[us] |= XLAT16_ACCEPT_NULL_OUT;
252				break;
253			case 2:
254				table[us] = ud;
255				if (lcase & KICONV_LOWER && ud != tolower(ud)) {
256					table[us] |= (u_char)tolower(ud) << 16;
257					table[us] |= XLAT16_HAS_LOWER_CASE;
258				}
259				if (lcase & KICONV_UPPER && ud != toupper(ud)) {
260					table[us] |= (u_char)toupper(ud) << 16;
261					table[us] |= XLAT16_HAS_UPPER_CASE;
262				}
263				break;
264			}
265
266			switch(inbytesleft) {
267			case 0:
268				if ((ls & 0xff) == 0)
269					table[us] |= XLAT16_ACCEPT_NULL_IN;
270				break;
271			case 1:
272				c = ls > 0xff ? us | 0x80 : us;
273				if (lcase & KICONV_FROM_LOWER && c != tolower(c)) {
274					table[us] |= (u_char)tolower(c) << 16;
275					table[us] |= XLAT16_HAS_FROM_LOWER_CASE;
276				}
277				if (lcase & KICONV_FROM_UPPER && c != toupper(c)) {
278					table[us] |= (u_char)toupper(c) << 16;
279					table[us] |= XLAT16_HAS_FROM_UPPER_CASE;
280				}
281				break;
282			}
283
284			if (table[us] == 0)
285				continue;
286
287			/*
288			 * store not NULL
289			 */
290			xt.idx[ls] = table;
291		}
292		if (xt.idx[ls]) {
293			memcpy(p, table, sizeof(table));
294			p += sizeof(table);
295		}
296	}
297	my_iconv_close(cd);
298
299	xt.size = p - (char *)xt.data;
300	xt.data = realloc(xt.data, xt.size);
301	return (xt);
302}
303
304static int
305chklocale(int category, const char *code)
306{
307	char *p;
308	int error = -1;
309
310	p = strchr(setlocale(category, NULL), '.');
311	if (p++) {
312		error = strcasecmp(code, p);
313		if (error) {
314			/* XXX - can't avoid calling quirk here... */
315			error = strcasecmp(code, kiconv_quirkcs(p,
316			    KICONV_VENDOR_MICSFT));
317		}
318	}
319	return (error);
320}
321
322#ifdef ICONV_DLOPEN
323static int
324my_iconv_init(void)
325{
326	void *iconv_lib;
327
328	iconv_lib = dlopen("libiconv.so", RTLD_LAZY | RTLD_GLOBAL);
329	if (iconv_lib == NULL) {
330		warn("Unable to load iconv library: %s\n", dlerror());
331		errno = ENOENT;
332		return (-1);
333	}
334	my_iconv_open = dlsym(iconv_lib, "iconv_open");
335	my_iconv = dlsym(iconv_lib, "iconv");
336	my_iconv_close = dlsym(iconv_lib, "iconv_close");
337
338	return (0);
339}
340#endif
341
342static size_t
343my_iconv_char(iconv_t cd, u_char **ibuf, size_t * ilen, u_char **obuf,
344	size_t * olen)
345{
346	u_char *sp, *dp, ilocal[3], olocal[3];
347	u_char c1, c2;
348	int ret;
349	size_t ir, or;
350
351	sp = *ibuf;
352	dp = *obuf;
353	ir = *ilen;
354
355	bzero(*obuf, *olen);
356	ret = my_iconv(cd, (char **)&sp, ilen, (char **)&dp, olen);
357	c1 = (*obuf)[0];
358	c2 = (*obuf)[1];
359
360	if (ret == -1) {
361		if (*ilen == ir - 1 && (*ibuf)[1] == '\0' && (c1 || c2))
362			return (0);
363		else
364			return (-1);
365	}
366
367	/*
368	 * We must judge if inbuf is a single byte char or double byte char.
369	 * Here, to judge, try first byte(*sp) conversion and compare.
370	 */
371	ir = 1;
372	or = 3;
373
374	bzero(olocal, or);
375	memcpy(ilocal, *ibuf, sizeof(ilocal));
376	sp = ilocal;
377	dp = olocal;
378
379	if ((my_iconv(cd,(char **)&sp, &ir, (char **)&dp, &or)) != -1) {
380		if (olocal[0] != c1)
381			return (ret);
382
383		if (olocal[1] == c2 && (*ibuf)[1] == '\0') {
384			/*
385			 * inbuf is a single byte char
386			 */
387			*ilen = 1;
388			*olen = or;
389			return (ret);
390		}
391
392		switch(or) {
393		case 0:
394		case 1:
395			if (olocal[1] == c2) {
396				/*
397				 * inbuf is a single byte char,
398				 * so return false here.
399				 */
400				return (-1);
401			} else {
402				/*
403				 * inbuf is a double byte char
404				 */
405				return (ret);
406			}
407			break;
408		case 2:
409			/*
410			 * should compare second byte of inbuf
411			 */
412			break;
413		}
414	} else {
415		/*
416		 * inbuf clould not be splitted, so inbuf is
417		 * a double byte char.
418		 */
419		return (ret);
420	}
421
422	/*
423	 * try second byte(*(sp+1)) conversion, and compare
424	 */
425	ir = 1;
426	or = 3;
427
428	bzero(olocal, or);
429
430	sp = ilocal + 1;
431	dp = olocal;
432
433	if ((my_iconv(cd,(char **)&sp, &ir, (char **)&dp, &or)) != -1) {
434		if (olocal[0] == c2)
435			/*
436			 * inbuf is a single byte char
437			 */
438			return (-1);
439	}
440
441	return (ret);
442}
443
444#else /* statically linked */
445
446#include <sys/types.h>
447#include <sys/iconv.h>
448#include <errno.h>
449
450int
451kiconv_add_xlat16_cspair(const char *tocode __unused, const char *fromcode __unused,
452    int flag __unused)
453{
454
455	errno = EINVAL;
456	return (-1);
457}
458
459int
460kiconv_add_xlat16_cspairs(const char *tocode __unused, const char *fromcode __unused)
461{
462	errno = EINVAL;
463	return (-1);
464}
465
466#endif /* PIC */
467