lib/libkiconv/xlat16_iconv.c

   1 /*-
   2  * Copyright (c) 2003, 2005 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$
  27  */
  28
  29 /*
  30  * kiconv(3) requires shared linked, and reduce module size
  31  * when statically linked.
  32  */
  33
  34 #ifdef PIC
  35
  36 #include <sys/types.h>
  37 #include <sys/iconv.h>
  38 #include <sys/sysctl.h>
  39
  40 #include <ctype.h>
  41 #include <dlfcn.h>
  42 #include <err.h>
  43 #include <errno.h>
  44 #include <locale.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48 #include <wctype.h>
  49
  50 #include "quirks.h"
  51
  52 typedef void *iconv_t;
  53
  54 struct xlat16_table {
  55         uint32_t *      idx[0x200];
  56         void *          data;
  57         size_t          size;
  58 };
  59
  60 static struct xlat16_table kiconv_xlat16_open(const char *, const char *, int);
  61 static int chklocale(int, const char *);
  62
  63 static int my_iconv_init(void);
  64 static iconv_t (*my_iconv_open)(const char *, const char *);
  65 static size_t (*my_iconv)(iconv_t, const char **, size_t *, char **, size_t *);
  66 static int (*my_iconv_close)(iconv_t);
  67 static size_t my_iconv_char(iconv_t, const u_char **, size_t *, u_char **, size_t *);
  68
  69 int
  70 kiconv_add_xlat16_cspair(const char *tocode, const char *fromcode, int flag)
  71 {
  72         int error;
  73         size_t idxsize;
  74         struct xlat16_table xt;
  75         void *data;
  76         char *p;
  77
  78         if (kiconv_lookupcs(tocode, fromcode) == 0)
  79                 return (0);
  80
  81         if (flag & KICONV_WCTYPE)
  82                 xt = kiconv_xlat16_open(fromcode, fromcode, flag);
  83         else
  84                 xt = kiconv_xlat16_open(tocode, fromcode, flag);
  85         if (xt.size == 0)
  86                 return (-1);
  87
  88         idxsize = sizeof(xt.idx);
  89
  90         if ((idxsize + xt.size) > ICONV_CSMAXDATALEN) {
  91                 errno = E2BIG;
  92                 return (-1);
  93         }
  94
  95         if ((data = malloc(idxsize + xt.size)) != NULL) {
  96                 p = data;
  97                 memcpy(p, xt.idx, idxsize);
  98                 p += idxsize;
  99                 memcpy(p, xt.data, xt.size);
 100                 error = kiconv_add_xlat16_table(tocode, fromcode, data,
 101                     (int)(idxsize + xt.size));
 102                 return (error);
 103         }
 104
 105         return (-1);
 106 }
 107
 108 int
 109 kiconv_add_xlat16_cspairs(const char *foreigncode, const char *localcode)
 110 {
 111         int error, locale;
 112
 113         error = kiconv_add_xlat16_cspair(foreigncode, localcode,
 114             KICONV_FROM_LOWER | KICONV_FROM_UPPER);
 115         if (error)
 116                 return (error);
 117         error = kiconv_add_xlat16_cspair(localcode, foreigncode,
 118             KICONV_LOWER | KICONV_UPPER);
 119         if (error)
 120                 return (error);
 121         locale = chklocale(LC_CTYPE, localcode);
 122         if (locale == 0) {
 123                 error = kiconv_add_xlat16_cspair(KICONV_WCTYPE_NAME, localcode,
 124                     KICONV_WCTYPE);
 125                 if (error)
 126                         return (error);
 127         }
 128
 129         return (0);
 130 }
 131
 132 static struct xlat16_table
 133 kiconv_xlat16_open(const char *tocode, const char *fromcode, int lcase)
 134 {
 135         u_char src[3], dst[4], *srcp, *dstp, ud, ld;
 136         int us, ls, ret;
 137         uint16_t c;
 138         uint32_t table[0x80];
 139         size_t inbytesleft, outbytesleft, pre_q_size, post_q_size;
 140         struct xlat16_table xt;
 141         struct quirk_replace_list *pre_q_list, *post_q_list;
 142         iconv_t cd;
 143         char *p;
 144
 145         xt.data = NULL;
 146         xt.size = 0;
 147
 148         src[2] = '\0';
 149         dst[3] = '\0';
 150
 151         ret = my_iconv_init();
 152         if (ret)
 153                 return (xt);
 154
 155         cd = my_iconv_open(search_quirk(tocode, fromcode, &pre_q_list, &pre_q_size),
 156             search_quirk(fromcode, tocode, &post_q_list, &post_q_size));
 157         if (cd == (iconv_t) (-1))
 158                 return (xt);
 159
 160         if ((xt.data = malloc(0x200 * 0x80 * sizeof(uint32_t))) == NULL)
 161                 return (xt);
 162
 163         p = xt.data;
 164
 165         for (ls = 0 ; ls < 0x200 ; ls++) {
 166                 xt.idx[ls] = NULL;
 167                 for (us = 0 ; us < 0x80 ; us++) {
 168                         srcp = src;
 169                         dstp = dst;
 170
 171                         inbytesleft = 2;
 172                         outbytesleft = 3;
 173                         bzero(dst, outbytesleft);
 174
 175                         c = ((ls & 0x100 ? us | 0x80 : us) << 8) | (u_char)ls;
 176
 177                         if (lcase & KICONV_WCTYPE) {
 178                                 if ((c & 0xff) == 0)
 179                                         c >>= 8;
 180                                 if (iswupper(c)) {
 181                                         c = towlower(c);
 182                                         if ((c & 0xff00) == 0)
 183                                                 c <<= 8;
 184                                         table[us] = c | XLAT16_HAS_LOWER_CASE;
 185                                 } else if (iswlower(c)) {
 186                                         c = towupper(c);
 187                                         if ((c & 0xff00) == 0)
 188                                                 c <<= 8;
 189                                         table[us] = c | XLAT16_HAS_UPPER_CASE;
 190                                 } else
 191                                         table[us] = 0;
 192                                 /*
 193                                  * store not NULL
 194                                  */
 195                                 if (table[us])
 196                                         xt.idx[ls] = table;
 197
 198                                 continue;
 199                         }
 200
 201                         c = quirk_vendor2unix(c, pre_q_list, pre_q_size);
 202                         src[0] = (u_char)(c >> 8);
 203                         src[1] = (u_char)c;
 204
 205                         ret = my_iconv_char(cd, (const u_char **)&srcp,
 206                             &inbytesleft, &dstp, &outbytesleft);
 207                         if (ret == -1) {
 208                                 table[us] = 0;
 209                                 continue;
 210                         }
 211
 212                         ud = (u_char)dst[0];
 213                         ld = (u_char)dst[1];
 214
 215                         switch(outbytesleft) {
 216                         case 0:
 217 #ifdef XLAT16_ACCEPT_3BYTE_CHR
 218                                 table[us] = (ud << 8) | ld;
 219                                 table[us] |= (u_char)dst[2] << 16;
 220                                 table[us] |= XLAT16_IS_3BYTE_CHR;
 221 #else
 222                                 table[us] = 0;
 223                                 continue;
 224 #endif
 225                                 break;
 226                         case 1:
 227                                 table[us] = quirk_unix2vendor((ud << 8) | ld,
 228                                     post_q_list, post_q_size);
 229                                 if ((table[us] >> 8) == 0)
 230                                         table[us] |= XLAT16_ACCEPT_NULL_OUT;
 231                                 break;
 232                         case 2:
 233                                 table[us] = ud;
 234                                 if (lcase & KICONV_LOWER && ud != tolower(ud)) {
 235                                         table[us] |= (u_char)tolower(ud) << 16;
 236                                         table[us] |= XLAT16_HAS_LOWER_CASE;
 237                                 }
 238                                 if (lcase & KICONV_UPPER && ud != toupper(ud)) {
 239                                         table[us] |= (u_char)toupper(ud) << 16;
 240                                         table[us] |= XLAT16_HAS_UPPER_CASE;
 241                                 }
 242                                 break;
 243                         }
 244
 245                         switch(inbytesleft) {
 246                         case 0:
 247                                 if ((ls & 0xff) == 0)
 248                                         table[us] |= XLAT16_ACCEPT_NULL_IN;
 249                                 break;
 250                         case 1:
 251                                 c = ls > 0xff ? us | 0x80 : us;
 252                                 if (lcase & KICONV_FROM_LOWER && c != tolower(c)) {
 253                                         table[us] |= (u_char)tolower(c) << 16;
 254                                         table[us] |= XLAT16_HAS_FROM_LOWER_CASE;
 255                                 }
 256                                 if (lcase & KICONV_FROM_UPPER && c != toupper(c)) {
 257                                         table[us] |= (u_char)toupper(c) << 16;
 258                                         table[us] |= XLAT16_HAS_FROM_UPPER_CASE;
 259                                 }
 260                                 break;
 261                         }
 262
 263                         if (table[us] == 0)
 264                                 continue;
 265
 266                         /*
 267                          * store not NULL
 268                          */
 269                         xt.idx[ls] = table;
 270                 }
 271                 if (xt.idx[ls]) {
 272                         memcpy(p, table, sizeof(table));
 273                         p += sizeof(table);
 274                 }
 275         }
 276         my_iconv_close(cd);
 277
 278         xt.size = p - (char *)xt.data;
 279         xt.data = realloc(xt.data, xt.size);
 280         return (xt);
 281 }
 282
 283 static int
 284 chklocale(int category, const char *code)
 285 {
 286         char *p;
 287         int error = -1;
 288
 289         p = strchr(setlocale(category, NULL), '.');
 290         if (p++) {
 291                 error = strcasecmp(code, p);
 292                 if (error) {
 293                         /* XXX - can't avoid calling quirk here... */
 294                         error = strcasecmp(code, kiconv_quirkcs(p,
 295                             KICONV_VENDOR_MICSFT));
 296                 }
 297         }
 298         return (error);
 299 }
 300
 301 static int
 302 my_iconv_init(void)
 303 {
 304         void *iconv_lib;
 305
 306         iconv_lib = dlopen("libiconv.so", RTLD_LAZY | RTLD_GLOBAL);
 307         if (iconv_lib == NULL) {
 308                 warn("Unable to load iconv library: %s\n", dlerror());
 309                 errno = ENOENT;
 310                 return (-1);
 311         }
 312         my_iconv_open = dlsym(iconv_lib, "iconv_open");
 313         my_iconv = dlsym(iconv_lib, "iconv");
 314         my_iconv_close = dlsym(iconv_lib, "iconv_close");
 315
 316         return (0);
 317 }
 318
 319 static size_t
 320 my_iconv_char(iconv_t cd, const u_char **ibuf, size_t * ilen, u_char **obuf,
 321         size_t * olen)
 322 {
 323         const u_char *sp;
 324         u_char *dp, ilocal[3], olocal[3];
 325         u_char c1, c2;
 326         int ret;
 327         size_t ir, or;
 328
 329         sp = *ibuf;
 330         dp = *obuf;
 331         ir = *ilen;
 332
 333         bzero(*obuf, *olen);
 334         ret = my_iconv(cd, (const char **)&sp, ilen, (char **)&dp, olen);
 335         c1 = (*obuf)[0];
 336         c2 = (*obuf)[1];
 337
 338         if (ret == -1) {
 339                 if (*ilen == ir - 1 && (*ibuf)[1] == '\0' && (c1 || c2))
 340                         return (0);
 341                 else
 342                         return (-1);
 343         }
 344
 345         /*
 346          * We must judge if inbuf is a single byte char or double byte char.
 347          * Here, to judge, try first byte(*sp) conversion and compare.
 348          */
 349         ir = 1;
 350         or = 3;
 351
 352         bzero(olocal, or);
 353         memcpy(ilocal, *ibuf, sizeof(ilocal));
 354         sp = ilocal;
 355         dp = olocal;
 356
 357         if ((my_iconv(cd,(const char **)&sp, &ir, (char **)&dp, &or)) != -1) {
 358                 if (olocal[0] != c1)
 359                         return (ret);
 360
 361                 if (olocal[1] == c2 && (*ibuf)[1] == '\0') {
 362                         /*
 363                          * inbuf is a single byte char
 364                          */
 365                         *ilen = 1;
 366                         *olen = or;
 367                         return (ret);
 368                 }
 369
 370                 switch(or) {
 371                 case 0:
 372                 case 1:
 373                         if (olocal[1] == c2) {
 374                                 /*
 375                                  * inbuf is a single byte char,
 376                                  * so return false here.
 377                                  */
 378                                 return (-1);
 379                         } else {
 380                                 /*
 381                                  * inbuf is a double byte char
 382                                  */
 383                                 return (ret);
 384                         }
 385                         break;
 386                 case 2:
 387                         /*
 388                          * should compare second byte of inbuf
 389                          */
 390                         break;
 391                 }
 392         } else {
 393                 /*
 394                  * inbuf clould not be splitted, so inbuf is
 395                  * a double byte char.
 396                  */
 397                 return (ret);
 398         }
 399
 400         /*
 401          * try second byte(*(sp+1)) conversion, and compare
 402          */
 403         ir = 1;
 404         or = 3;
 405
 406         bzero(olocal, or);
 407
 408         sp = ilocal + 1;
 409         dp = olocal;
 410
 411         if ((my_iconv(cd,(const char **)&sp, &ir, (char **)&dp, &or)) != -1) {
 412                 if (olocal[0] == c2)
 413                         /*
 414                          * inbuf is a single byte char
 415                          */
 416                         return (-1);
 417         }
 418
 419         return (ret);
 420 }
 421
 422 #else /* statically linked */
 423
 424 #include <sys/types.h>
 425 #include <sys/iconv.h>
 426 #include <errno.h>
 427
 428 int
 429 kiconv_add_xlat16_cspair(const char *tocode __unused, const char *fromcode __unused,
 430     int flag __unused)
 431 {
 432
 433         errno = EINVAL;
 434         return (-1);
 435 }
 436
 437 int
 438 kiconv_add_xlat16_cspairs(const char *tocode __unused, const char *fromcode __unused)
 439 {
 440         errno = EINVAL;
 441         return (-1);
 442 }
 443
 444 #endif /* PIC */