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