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 */ 445