diff options
Diffstat (limited to 'lib/libkiconv/xlat16_iconv.c')
-rw-r--r-- | lib/libkiconv/xlat16_iconv.c | 374 |
1 files changed, 374 insertions, 0 deletions
diff --git a/lib/libkiconv/xlat16_iconv.c b/lib/libkiconv/xlat16_iconv.c new file mode 100644 index 0000000..2490107 --- /dev/null +++ b/lib/libkiconv/xlat16_iconv.c @@ -0,0 +1,374 @@ +/*- + * Copyright (c) 2003 Ryuichiro Imura + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD$ + */ + +/* + * kiconv(3) requires shared linked, and reduce module size + * when statically linked. + */ + +#ifdef PIC + +#include <sys/types.h> +#include <sys/iconv.h> +#include <sys/sysctl.h> + +#include <ctype.h> +#include <dlfcn.h> +#include <err.h> +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "quirks.h" + +typedef void *iconv_t; + +struct xlat16_table { + uint32_t * idx[0x200]; + void * data; + size_t size; +}; + +static struct xlat16_table kiconv_xlat16_open(const char *, const char *, int); + +static int my_iconv_init(void); +static iconv_t (*my_iconv_open)(const char *, const char *); +static size_t (*my_iconv)(iconv_t, const char **, size_t *, char **, size_t *); +static int (*my_iconv_close)(iconv_t); +static size_t my_iconv_char(iconv_t, const u_char **, size_t *, u_char **, size_t *); + +int +kiconv_add_xlat16_cspair(const char *tocode, const char *fromcode, int flag) +{ + int error; + size_t i, size, idxsize; + struct iconv_cspair_info *csi; + struct xlat16_table xt; + void *data, *p; + + if (sysctlbyname("kern.iconv.cslist", NULL, &size, NULL, 0) == -1) + return (-1); + if (size > 0) { + csi = malloc(size); + if (csi == NULL) + return (-1); + if (sysctlbyname("kern.iconv.cslist", csi, &size, NULL, 0) == -1) { + free(csi); + return (-1); + } + for (i = 0; i < (size/sizeof(*csi)); i++, csi++){ + if (strcmp(csi->cs_to, tocode) == 0 && + strcmp(csi->cs_from, fromcode) == 0) + return (0); + } + } + + xt = kiconv_xlat16_open(tocode, fromcode, flag); + if (xt.size == 0) + return (-1); + + idxsize = sizeof(xt.idx); + + if ((idxsize + xt.size) > ICONV_CSMAXDATALEN) { + errno = E2BIG; + return (-1); + } + + if ((data = malloc(idxsize + xt.size)) != NULL) { + p = data; + memcpy(p, xt.idx, idxsize); + p += idxsize; + memcpy(p, xt.data, xt.size); + error = kiconv_add_xlat16_table(tocode, fromcode, data, + (int)(idxsize + xt.size)); + return (error); + } + + return (-1); +} + +static struct xlat16_table +kiconv_xlat16_open(const char *tocode, const char *fromcode, int lcase) +{ + u_char src[3], dst[4], *srcp, *dstp, ud, ld; + int us, ls, ret; + uint16_t c; + uint32_t table[0x80]; + size_t inbytesleft, outbytesleft, pre_q_size, post_q_size; + struct xlat16_table xt; + struct quirk_replace_list *pre_q_list, *post_q_list; + iconv_t cd; + void *p; + + xt.data = NULL; + xt.size = 0; + + src[2] = NULL; + dst[3] = NULL; + + ret = my_iconv_init(); + if (ret) + return (xt); + + cd = my_iconv_open(search_quirk(tocode, fromcode, &pre_q_list, &pre_q_size), + search_quirk(fromcode, tocode, &post_q_list, &post_q_size)); + if (cd == (iconv_t) (-1)) + return (xt); + + if ((xt.data = malloc(0x200 * 0x80 * sizeof(uint32_t))) == NULL) + return (xt); + + p = xt.data; + + for (ls = 0 ; ls < 0x200 ; ls++) { + xt.idx[ls] = NULL; + for (us = 0 ; us < 0x80 ; us++) { + srcp = src; + dstp = dst; + + inbytesleft = 2; + outbytesleft = 3; + bzero(dst, outbytesleft); + + c = ((ls & 0x100 ? us | 0x80 : us) << 8) | (u_char)ls; + c = quirk_vendor2unix(c, pre_q_list, pre_q_size); + src[0] = (u_char)(c >> 8); + src[1] = (u_char)c; + + ret = my_iconv_char(cd, (const u_char **)&srcp, + &inbytesleft, &dstp, &outbytesleft); + if (ret == -1) { + table[us] = 0; + continue; + } + + ud = (u_char)dst[0]; + ld = (u_char)dst[1]; + + switch(outbytesleft) { + case 0: +#ifdef XLAT16_ACCEPT_3BYTE_CHR + table[us] = (ud << 8) | ld; + table[us] |= (u_char)dst[2] << 16; + table[us] |= XLAT16_IS_3BYTE_CHR; +#else + table[us] = 0; + continue; +#endif + break; + case 1: + table[us] = quirk_unix2vendor((ud << 8) | ld, + post_q_list, post_q_size); + if ((table[us] >> 8) == 0) + table[us] |= XLAT16_ACCEPT_NULL_OUT; + break; + case 2: + table[us] = ud; + if (lcase & KICONV_LOWER && ud != tolower(ud)) { + table[us] |= (u_char)tolower(ud) << 16; + table[us] |= XLAT16_HAS_LOWER_CASE; + } + if (lcase & KICONV_UPPER && ud != toupper(ud)) { + table[us] |= (u_char)toupper(ud) << 16; + table[us] |= XLAT16_HAS_UPPER_CASE; + } + break; + } + + switch(inbytesleft) { + case 0: + if ((ls & 0xff) == 0) + table[us] |= XLAT16_ACCEPT_NULL_IN; + break; + case 1: + c = ls > 0xff ? us | 0x80 : us; + if (lcase & KICONV_FROM_LOWER && c != tolower(c)) { + table[us] |= (u_char)tolower(c) << 16; + table[us] |= XLAT16_HAS_FROM_LOWER_CASE; + } + if (lcase & KICONV_FROM_UPPER && c != toupper(c)) { + table[us] |= (u_char)toupper(c) << 16; + table[us] |= XLAT16_HAS_FROM_UPPER_CASE; + } + break; + } + + if (table[us] == 0) + continue; + + /* + * store not NULL + */ + xt.idx[ls] = table; + } + if (xt.idx[ls]) { + memcpy(p, table, sizeof(table)); + p += sizeof(table); + } + } + my_iconv_close(cd); + + xt.size = p - xt.data; + xt.data = realloc(xt.data, xt.size); + return (xt); +} + +static int +my_iconv_init(void) +{ + void *iconv_lib; + + iconv_lib = dlopen("libiconv.so", RTLD_LAZY | RTLD_GLOBAL); + if (iconv_lib == NULL) { + warn("Unable to load iconv library: %s\n", dlerror()); + errno = ENOENT; + return (-1); + } + my_iconv_open = dlsym(iconv_lib, "iconv_open"); + my_iconv = dlsym(iconv_lib, "iconv"); + my_iconv_close = dlsym(iconv_lib, "iconv_close"); + + return (0); +} + +static size_t +my_iconv_char(iconv_t cd, const u_char **ibuf, size_t * ilen, u_char **obuf, + size_t * olen) +{ + const u_char *sp; + u_char *dp, ilocal[3], olocal[3]; + u_char c1, c2; + int ret; + size_t ir, or; + + sp = *ibuf; + dp = *obuf; + ir = *ilen; + + bzero(*obuf, *olen); + ret = my_iconv(cd, (const char **)&sp, ilen, (char **)&dp, olen); + c1 = (*obuf)[0]; + c2 = (*obuf)[1]; + + if (ret == -1) { + if (*ilen == ir - 1 && (*ibuf)[1] == '\0' && (c1 || c2)) + return (0); + else + return (-1); + } + + /* + * We must judge if inbuf is a single byte char or double byte char. + * Here, to judge, try first byte(*sp) conversion and compare. + */ + ir = 1; + or = 3; + + bzero(olocal, or); + memcpy(ilocal, *ibuf, sizeof(ilocal)); + sp = ilocal; + dp = olocal; + + if ((my_iconv(cd,(const char **)&sp, &ir, (char **)&dp, &or)) != -1) { + if (olocal[0] != c1) + return (ret); + + if (olocal[1] == c2 && (*ibuf)[1] == '\0') { + /* + * inbuf is a single byte char + */ + *ilen = 1; + *olen = or; + return (ret); + } + + switch(or) { + case 0: + case 1: + if (olocal[1] == c2) { + /* + * inbuf is a single byte char, + * so return false here. + */ + return (-1); + } else { + /* + * inbuf is a double byte char + */ + return (ret); + } + break; + case 2: + /* + * should compare second byte of inbuf + */ + break; + } + } else { + /* + * inbuf clould not be splitted, so inbuf is + * a double byte char. + */ + return (ret); + } + + /* + * try second byte(*(sp+1)) conversion, and compare + */ + ir = 1; + or = 3; + + bzero(olocal, or); + + sp = ilocal + 1; + dp = olocal; + + if ((my_iconv(cd,(const char **)&sp, &ir, (char **)&dp, &or)) != -1) { + if (olocal[0] == c2) + /* + * inbuf is a single byte char + */ + return (-1); + } + + return (ret); +} + +#else /* statically linked */ + +#include <errno.h> + +int +kiconv_add_xlat16_cspair(const char *tocode, const char *fromcode, int flag) +{ + errno = EINVAL; + return (-1); +} + +#endif /* PIC */ |