1 /*
2 * Copyright (c) 2003-2004, Artem B. Bityuckiy
3 * Copyright (c) 1999,2000, Konstantin Chuguev. 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 #include "cesbi.h"
27
28 #if defined (ICONV_TO_UCS_CES_TABLE) \
29 || defined (ICONV_FROM_UCS_CES_TABLE)
30
31 #include <_ansi.h>
32 #include <newlib.h>
33 #include <sys/types.h>
34 #include <string.h>
35 #include <stdlib.h>
36 #include <unistd.h>
37 #include <fcntl.h>
38 #include <sys/iconvnls.h>
39 #include "../lib/endian.h"
40 #include "../lib/local.h"
41 #include "../lib/ucsconv.h"
42 #include "../ccs/ccs.h"
43
44 /*
45 * Table-based CES converter is implemented here. Table-based CES converter
46 * deals with encodings with "null" CES, like KOI8-R. In this case it is
47 * possible to implement one generic algorithm which works with different
48 * CCS tables.
49 *
50 * Table-based CES converter deals with CCS tables placed into iconv/ccs
51 * subdirectory. First, converter tries to find needed CCS table among
52 * linked-in tables. If not found, it tries to load it from external file
53 * (only if corespondent capability was enabled in Newlib configuration).
54 *
55 * 16 bit encodings are assumed to be Big Endian.
56 */
57
58 static ucs2_t
59 find_code_size (ucs2_t code, const __uint16_t *tblp);
60
61 static __inline ucs2_t
62 find_code_speed (ucs2_t code, const __uint16_t *tblp);
63
64 static __inline ucs2_t
65 find_code_speed_8bit (ucs2_t code, const unsigned char *tblp);
66
67 #ifdef _ICONV_ENABLE_EXTERNAL_CCS
68 static const iconv_ccs_desc_t *
69 load_file (const char *name, int direction);
70 #endif
71
72 /*
73 * Interface data and functions implementation.
74 */
75 static size_t
table_close(void * data)76 table_close (
77 void *data)
78 {
79 const iconv_ccs_desc_t *ccsp = (iconv_ccs_desc_t *)data;
80
81 if (ccsp->type == TABLE_EXTERNAL)
82 free ((void *)ccsp->tbl);
83
84 free((void *)ccsp);
85 return 0;
86 }
87
88 #if defined (ICONV_FROM_UCS_CES_TABLE)
89 static void *
table_init_from_ucs(const char * encoding)90 table_init_from_ucs (
91 const char *encoding)
92 {
93 int i;
94 const iconv_ccs_t *biccsp = NULL;
95 iconv_ccs_desc_t *ccsp;
96
97 for (i = 0; _iconv_ccs[i] != NULL; i++)
98 if (strcmp (_iconv_ccs[i]->name, encoding) == 0)
99 {
100 biccsp = _iconv_ccs[i];
101 break;
102 }
103
104 if (biccsp != NULL)
105 {
106 if (biccsp->from_ucs == NULL
107 || (ccsp = (iconv_ccs_desc_t *)
108 malloc (sizeof (iconv_ccs_desc_t))) == NULL)
109 return NULL;
110
111 ccsp->type = TABLE_BUILTIN;
112 ccsp->bits = biccsp->bits;
113 ccsp->optimization = biccsp->from_ucs_type;
114 ccsp->tbl = biccsp->from_ucs;
115
116 return (void *)ccsp;
117 }
118
119 #ifdef _ICONV_ENABLE_EXTERNAL_CCS
120 return (void *)load_file (encoding, 1);
121 #else
122 return NULL;
123 #endif
124 }
125
126 static size_t
table_convert_from_ucs(void * data,ucs4_t in,unsigned char ** outbuf,size_t * outbytesleft)127 table_convert_from_ucs (void *data,
128 ucs4_t in,
129 unsigned char **outbuf,
130 size_t *outbytesleft)
131 {
132 const iconv_ccs_desc_t *ccsp = (iconv_ccs_desc_t *)data;
133 ucs2_t code;
134
135 if (in > 0xFFFF || in == INVALC)
136 return (size_t)ICONV_CES_INVALID_CHARACTER;
137
138 if (ccsp->bits == TABLE_8BIT)
139 {
140 code = find_code_speed_8bit ((ucs2_t)in,
141 (const unsigned char *)ccsp->tbl);
142 if (code == INVALC)
143 return (size_t)ICONV_CES_INVALID_CHARACTER;
144 **outbuf = (unsigned char)code;
145 *outbuf += 1;
146 *outbytesleft -= 1;
147 return 1;
148 }
149 else if (ccsp->optimization == TABLE_SPEED_OPTIMIZED)
150 code = find_code_speed ((ucs2_t)in, ccsp->tbl);
151 else
152 code = find_code_size ((ucs2_t)in, ccsp->tbl);
153
154 if (code == INVALC)
155 return (size_t)ICONV_CES_INVALID_CHARACTER;
156
157 if (*outbytesleft < 2)
158 return (size_t)ICONV_CES_NOSPACE;
159
160 /* We can't store whole word since **outbuf may be not 2-byte aligned */
161 **outbuf = (unsigned char)((ucs2_t)code >> 8);
162 *(*outbuf + 1) = (unsigned char)code;
163 *outbuf += 2;
164 *outbytesleft -= 2;
165 return 2;
166 }
167 #endif /* ICONV_FROM_UCS_CES_TABLE */
168
169 #if defined (ICONV_TO_UCS_CES_TABLE)
170 static void *
table_init_to_ucs(const char * encoding)171 table_init_to_ucs (
172 const char *encoding)
173 {
174 int i;
175 const iconv_ccs_t *biccsp = NULL;
176 iconv_ccs_desc_t *ccsp;
177
178 for (i = 0; _iconv_ccs[i] != NULL; i++)
179 if (strcmp (_iconv_ccs[i]->name, encoding) == 0)
180 {
181 biccsp = _iconv_ccs[i];
182 break;
183 }
184
185 if (biccsp != NULL)
186 {
187 if (biccsp->to_ucs == NULL
188 || (ccsp = (iconv_ccs_desc_t *)
189 malloc (sizeof (iconv_ccs_desc_t))) == NULL)
190 return NULL;
191
192 ccsp->type = TABLE_BUILTIN;
193 ccsp->bits = biccsp->bits;
194 ccsp->optimization = biccsp->to_ucs_type;
195 ccsp->tbl = biccsp->to_ucs;
196
197 return (void *)ccsp;
198 }
199
200 #ifdef _ICONV_ENABLE_EXTERNAL_CCS
201 return (void *)load_file (encoding, 0);
202 #else
203 return NULL;
204 #endif
205 }
206
207 static ucs4_t
table_convert_to_ucs(void * data,const unsigned char ** inbuf,size_t * inbytesleft)208 table_convert_to_ucs (void *data,
209 const unsigned char **inbuf,
210 size_t *inbytesleft)
211 {
212 const iconv_ccs_desc_t *ccsp = (iconv_ccs_desc_t *)data;
213 ucs2_t ucs;
214
215 if (ccsp->bits == TABLE_8BIT)
216 {
217 if (*inbytesleft < 1)
218 return (ucs4_t)ICONV_CES_BAD_SEQUENCE;
219
220 ucs = (ucs2_t)ccsp->tbl[**inbuf];
221
222 if (ucs == INVALC)
223 return (ucs4_t)ICONV_CES_INVALID_CHARACTER;
224
225 *inbytesleft -= 1;
226 *inbuf += 1;
227 return (ucs4_t)ucs;
228 }
229
230 if (*inbytesleft < 2)
231 return (ucs4_t)ICONV_CES_BAD_SEQUENCE;
232
233 if (ccsp->optimization == TABLE_SIZE_OPTIMIZED)
234 ucs = find_code_size((ucs2_t)**inbuf << 8 | (ucs2_t)*(*inbuf + 1),
235 ccsp->tbl);
236 else
237 ucs = find_code_speed((ucs2_t)**inbuf << 8 | (ucs2_t)*(*inbuf + 1),
238 ccsp->tbl);
239
240 if (ucs == INVALC)
241 return (ucs4_t)ICONV_CES_INVALID_CHARACTER;
242
243 *inbuf += 2;
244 *inbytesleft -= 2;
245 return (ucs4_t)ucs;
246 }
247 #endif /* ICONV_TO_UCS_CES_TABLE */
248
249 static int
table_get_mb_cur_max(void * data)250 table_get_mb_cur_max (void *data)
251 {
252 return ((iconv_ccs_desc_t *)data)->bits/8;
253 }
254
255
256 #if defined (ICONV_TO_UCS_CES_TABLE)
257 const iconv_to_ucs_ces_handlers_t
258 _iconv_to_ucs_ces_handlers_table =
259 {
260 table_init_to_ucs,
261 table_close,
262 table_get_mb_cur_max,
263 NULL,
264 NULL,
265 NULL,
266 table_convert_to_ucs
267 };
268 #endif /* ICONV_FROM_UCS_CES_TABLE */
269
270 #if defined (ICONV_FROM_UCS_CES_TABLE)
271 const iconv_from_ucs_ces_handlers_t
272 _iconv_from_ucs_ces_handlers_table =
273 {
274 table_init_from_ucs,
275 table_close,
276 table_get_mb_cur_max,
277 NULL,
278 NULL,
279 NULL,
280 table_convert_from_ucs
281 };
282 #endif /* ICONV_TO_UCS_CES_TABLE */
283
284 /*
285 * Supplementary functions.
286 */
287
288 /*
289 * find_code_speed - find code in 16 bit speed-optimized table.
290 *
291 * PARAMETERS:
292 * ucs2_t code - code whose mapping to find.
293 * const __uint16_t *tblp - table pointer.
294 *
295 * RETURN:
296 * Code that corresponds to 'code'.
297 */
298 static __inline ucs2_t
find_code_speed(ucs2_t code,const __uint16_t * tblp)299 find_code_speed (ucs2_t code,
300 const __uint16_t *tblp)
301 {
302 __uint16_t idx = tblp[code >> 8];
303
304 if (idx == INVBLK)
305 return (ucs2_t)INVALC;
306
307 return (ucs2_t)tblp[(code & 0x00FF) + idx];
308 }
309
310 /*
311 * find_code_speed_8bit - find code in 8 bit speed-optimized table.
312 *
313 * PARAMETERS:
314 * ucs2_t code - code whose mapping to find.
315 * const __uint16_t *tblp - table pointer.
316 *
317 * RETURN:
318 * Code that corresponds to 'code'.
319 */
320 static __inline ucs2_t
find_code_speed_8bit(ucs2_t code,const unsigned char * tblp)321 find_code_speed_8bit (ucs2_t code,
322 const unsigned char *tblp)
323 {
324 __uint16_t idx;
325 unsigned char ccs;
326
327 if (code == ((ucs2_t *)tblp)[0])
328 return (ucs2_t)0xFF;
329
330 idx = ((ucs2_t *)tblp)[1 + (code >> 8)];
331
332 if (idx == INVBLK)
333 return (ucs2_t)INVALC;
334
335 ccs = tblp[(code & 0x00FF) + idx];
336
337 return ccs == 0xFF ? (ucs2_t)INVALC : (ucs2_t)ccs;
338 }
339
340 /* Left range boundary */
341 #define RANGE_LEFT(n) (tblp[FIRST_RANGE_INDEX + (n)*3 + 0])
342 /* Right range boundary */
343 #define RANGE_RIGHT(n) (tblp[FIRST_RANGE_INDEX + (n)*3 + 1])
344 /* Range offset */
345 #define RANGE_INDEX(n) (tblp[FIRST_RANGE_INDEX + (n)*3 + 2])
346 /* Un-ranged offset */
347 #define UNRANGED_INDEX(n) (tblp[FIRST_UNRANGED_INDEX_INDEX] + (n)*2)
348
349 /*
350 * find_code_size - find code in 16 bit size-optimized table.
351 *
352 * PARAMETERS:
353 * ucs2_t code - code whose mapping to find.
354 * const __uint16_t *tblp - table pointer.
355 *
356 * RETURN:
357 * Code that corresponds to 'code'.
358 */
359 static ucs2_t
find_code_size(ucs2_t code,const __uint16_t * tblp)360 find_code_size (ucs2_t code,
361 const __uint16_t *tblp)
362 {
363 int first, last, cur, center;
364
365 if (tblp[RANGES_NUM_INDEX] > 0)
366 {
367 first = 0;
368 last = tblp[RANGES_NUM_INDEX] - 1;
369
370 do
371 {
372 center = (last - first)/2;
373 cur = center + first;
374
375 if (code > RANGE_RIGHT (cur))
376 first = cur;
377 else if (code < RANGE_LEFT (cur))
378 last = cur;
379 else
380 return (ucs2_t)tblp[RANGE_INDEX (cur) + code - RANGE_LEFT (cur)];
381 } while (center > 0);
382
383 if (last - first == 1)
384 {
385 if (code >= RANGE_LEFT (first) && code <= RANGE_RIGHT (first))
386 return (ucs2_t)tblp[RANGE_INDEX (first)
387 + code - RANGE_LEFT (first)];
388 if (code >= RANGE_LEFT (last) && code <= RANGE_RIGHT (last))
389 return (ucs2_t)tblp[RANGE_INDEX (last)
390 + code - RANGE_LEFT (last)];
391 }
392 }
393
394 if (tblp[UNRANGED_NUM_INDEX] > 0)
395 {
396 first = 0;
397 last = tblp[UNRANGED_NUM_INDEX] - 1;
398
399 do
400 {
401 __uint16_t c;
402
403 center = (last - first)/2;
404 cur = center + first;
405 c = tblp[UNRANGED_INDEX (cur)];
406
407 if (code > c)
408 first = cur;
409 else if (code < c)
410 last = cur;
411 else
412 return (ucs2_t)tblp[UNRANGED_INDEX (cur) + 1];
413 } while (center > 0);
414
415 if (last - first == 1)
416 {
417 if (code == tblp[UNRANGED_INDEX (first)])
418 return (ucs2_t)tblp[UNRANGED_INDEX (first) + 1];
419 if (code == tblp[UNRANGED_INDEX (last)])
420 return (ucs2_t)tblp[UNRANGED_INDEX (last) + 1];
421 }
422 }
423
424 return (ucs2_t)INVALC;
425 }
426
427 #ifdef _ICONV_ENABLE_EXTERNAL_CCS
428
429 #define _16BIT_ELT(offset) \
430 ICONV_BETOHS(*((__uint16_t *)(buf + (offset))))
431 #define _32BIT_ELT(offset) \
432 ICONV_BETOHL(*((__uint32_t *)(buf + (offset))))
433
434 /*
435 * load_file - load conversion table from external file and initialize
436 * iconv_ccs_desc_t object.
437 *
438 * PARAMETERS:
439 * const char *name - encoding name.
440 * int direction - conversion direction.
441 *
442 * DESCRIPTION:
443 * Loads conversion table of appropriate endianess from external file
444 * and initializes 'iconv_ccs_desc_t' table description structure.
445 * If 'direction' is 0 - load "To UCS" table, else load "From UCS"
446 * table.
447 *
448 * RETURN:
449 * iconv_ccs_desc_t * pointer is success, NULL if failure.
450 */
451 static const iconv_ccs_desc_t *
load_file(const char * name,int direction)452 load_file (
453 const char *name,
454 int direction)
455 {
456 FILE *file;
457 char *buf;
458 size_t tbllen;
459 size_t hdrlen;
460 off_t off;
461 off_t cur = 0;
462 const char *fname;
463 iconv_ccs_desc_t *ccsp = NULL;
464 size_t nmlen = strlen(name);
465 /* Since CCS table name length can vary - it is aligned (by adding extra
466 * bytes to it's end) to 4-byte boundary. */
467 int alignment = nmlen & 3 ? 4 - (nmlen & 3) : 0;
468
469 hdrlen = nmlen + EXTTABLE_HEADER_LEN + alignment;
470
471 if ((fname = _iconv_nls_construct_filename (name, ICONV_SUBDIR,
472 ICONV_DATA_EXT)) == NULL)
473 return NULL;
474
475 if ((file = fopen (fname, "rb")) == NULL)
476 goto error1;
477
478 if ((buf = malloc (hdrlen)) == NULL)
479 goto error2;
480
481 if (fread ((void *) buf, 1, hdrlen, file) != hdrlen)
482 goto error3;
483
484 cur += hdrlen;
485
486 if (_16BIT_ELT (EXTTABLE_VERSION_OFF) != TABLE_VERSION_1
487 || _32BIT_ELT (EXTTABLE_CCSNAME_LEN_OFF) != nmlen
488 || strncmp (buf + EXTTABLE_CCSNAME_OFF, name, nmlen) != 0)
489 goto error3; /* Bad file */
490
491 if ((ccsp = (iconv_ccs_desc_t *)
492 calloc (1, sizeof (iconv_ccs_desc_t))) == NULL)
493 goto error3;
494
495 ccsp->bits = _16BIT_ELT (EXTTABLE_BITS_OFF);
496 ccsp->type = TABLE_EXTERNAL;
497
498 /* Add 4-byte alignment to name length */
499 nmlen += alignment;
500
501 if (ccsp->bits == TABLE_8BIT)
502 {
503 if (direction == 0) /* Load "To UCS" table */
504 {
505 off = (off_t)_32BIT_ELT (nmlen + EXTTABLE_TO_SPEED_OFF);
506 tbllen = _32BIT_ELT (nmlen + EXTTABLE_TO_SPEED_LEN_OFF);
507 }
508 else /* Load "From UCS" table */
509 {
510 off = (off_t)_32BIT_ELT (nmlen + EXTTABLE_FROM_SPEED_OFF);
511 tbllen = _32BIT_ELT (nmlen + EXTTABLE_FROM_SPEED_LEN_OFF);
512 }
513 }
514 else if (ccsp->bits == TABLE_16BIT)
515 {
516 if (direction == 0) /* Load "To UCS" table */
517 {
518 #ifdef TABLE_USE_SIZE_OPTIMIZATION
519 off = (off_t)_32BIT_ELT (nmlen + EXTTABLE_TO_SIZE_OFF);
520 tbllen = _32BIT_ELT (nmlen + EXTTABLE_TO_SIZE_LEN_OFF);
521 #else
522 off = (off_t)_32BIT_ELT (nmlen + EXTTABLE_TO_SPEED_OFF);
523 tbllen = _32BIT_ELT (nmlen + EXTTABLE_TO_SPEED_LEN_OFF);
524 #endif
525 }
526 else /* Load "From UCS" table */
527 {
528 #ifdef TABLE_USE_SIZE_OPTIMIZATION
529 off = (off_t)_32BIT_ELT (nmlen + EXTTABLE_FROM_SIZE_OFF);
530 tbllen = _32BIT_ELT (nmlen + EXTTABLE_FROM_SIZE_LEN_OFF);
531 #else
532 off = (off_t)_32BIT_ELT (nmlen + EXTTABLE_FROM_SPEED_OFF);
533 tbllen = _32BIT_ELT (nmlen + EXTTABLE_FROM_SPEED_LEN_OFF);
534 #endif
535 }
536 #ifdef TABLE_USE_SIZE_OPTIMIZATION
537 ccsp->optimization = TABLE_SIZE_OPTIMIZED;
538 #else
539 ccsp->optimization = TABLE_SPEED_OPTIMIZED;
540 #endif
541 }
542 else
543 goto error4; /* Bad file */
544
545 if (off == EXTTABLE_NO_TABLE)
546 goto error4; /* No correspondent table in file */
547
548 if ((ccsp->tbl = (ucs2_t *)malloc (tbllen)) == NULL)
549 goto error4;
550
551 while (cur < off) {
552 if (getc(file) == EOF)
553 goto error5;
554 cur++;
555 }
556 if (fread ((void *) ccsp->tbl, 1, tbllen, file) != tbllen)
557 goto error5;
558
559 goto normal_exit;
560
561 error5:
562 free ((void *)ccsp->tbl);
563 ccsp->tbl = NULL;
564 error4:
565 free ((void *)ccsp);
566 ccsp = NULL;
567 error3:
568 normal_exit:
569 free ((void *)buf);
570 error2:
571 if (fclose (file) == EOF)
572 {
573 if (ccsp != NULL)
574 {
575 if (ccsp->tbl != NULL)
576 free ((void *)ccsp->tbl);
577 free ((void *)ccsp);
578 }
579 ccsp = NULL;
580 }
581 error1:
582 free ((void *)fname);
583 return ccsp;
584 }
585 #endif
586
587 #endif /* ICONV_TO_UCS_CES_TABLE || ICONV_FROM_UCS_CES_TABLE */
588
589
