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