1/* Simple transformations functions.
2 Copyright (C) 1997-2016 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <http://www.gnu.org/licenses/>. */
19
20#include <byteswap.h>
21#include <dlfcn.h>
22#include <endian.h>
23#include <errno.h>
24#include <gconv.h>
25#include <stdint.h>
26#include <stdlib.h>
27#include <string.h>
28#include <wchar.h>
29#include <sys/param.h>
30#include <gconv_int.h>
31
32#define BUILTIN_ALIAS(s1, s2) /* nothing */
33#define BUILTIN_TRANSFORMATION(From, To, Cost, Name, Fct, BtowcFct, \
34 MinF, MaxF, MinT, MaxT) \
35 extern int Fct (struct __gconv_step *, struct __gconv_step_data *, \
36 const unsigned char **, const unsigned char *, \
37 unsigned char **, size_t *, int, int);
38#include "gconv_builtin.h"
39
40
41#ifndef EILSEQ
42# define EILSEQ EINVAL
43#endif
44
45
46/* Specialized conversion function for a single byte to INTERNAL, recognizing
47 only ASCII characters. */
48wint_t
49__gconv_btwoc_ascii (struct __gconv_step *step, unsigned char c)
50{
51 if (c < 0x80)
52 return c;
53 else
54 return WEOF;
55}
56
57
58/* Transform from the internal, UCS4-like format, to UCS4. The
59 difference between the internal ucs4 format and the real UCS4
60 format is, if any, the endianess. The Unicode/ISO 10646 says that
61 unless some higher protocol specifies it differently, the byte
62 order is big endian.*/
63#define DEFINE_INIT 0
64#define DEFINE_FINI 0
65#define MIN_NEEDED_FROM 4
66#define MIN_NEEDED_TO 4
67#define FROM_DIRECTION 1
68#define FROM_LOOP internal_ucs4_loop
69#define TO_LOOP internal_ucs4_loop /* This is not used. */
70#define FUNCTION_NAME __gconv_transform_internal_ucs4
71#define ONE_DIRECTION 0
72
73
74static inline int
75__attribute ((always_inline))
76internal_ucs4_loop (struct __gconv_step *step,
77 struct __gconv_step_data *step_data,
78 const unsigned char **inptrp, const unsigned char *inend,
79 unsigned char **outptrp, unsigned char *outend,
80 size_t *irreversible)
81{
82 const unsigned char *inptr = *inptrp;
83 unsigned char *outptr = *outptrp;
84 size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
85 int result;
86
87#if __BYTE_ORDER == __LITTLE_ENDIAN
88 /* Sigh, we have to do some real work. */
89 size_t cnt;
90 uint32_t *outptr32 = (uint32_t *) outptr;
91
92 for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
93 *outptr32++ = bswap_32 (*(const uint32_t *) inptr);
94
95 *inptrp = inptr;
96 *outptrp = (unsigned char *) outptr32;
97#elif __BYTE_ORDER == __BIG_ENDIAN
98 /* Simply copy the data. */
99 *inptrp = inptr + n_convert * 4;
100 *outptrp = __mempcpy (outptr, inptr, n_convert * 4);
101#else
102# error "This endianess is not supported."
103#endif
104
105 /* Determine the status. */
106 if (*inptrp == inend)
107 result = __GCONV_EMPTY_INPUT;
108 else if (*outptrp + 4 > outend)
109 result = __GCONV_FULL_OUTPUT;
110 else
111 result = __GCONV_INCOMPLETE_INPUT;
112
113 return result;
114}
115
116#if !_STRING_ARCH_unaligned
117static inline int
118__attribute ((always_inline))
119internal_ucs4_loop_unaligned (struct __gconv_step *step,
120 struct __gconv_step_data *step_data,
121 const unsigned char **inptrp,
122 const unsigned char *inend,
123 unsigned char **outptrp, unsigned char *outend,
124 size_t *irreversible)
125{
126 const unsigned char *inptr = *inptrp;
127 unsigned char *outptr = *outptrp;
128 size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
129 int result;
130
131# if __BYTE_ORDER == __LITTLE_ENDIAN
132 /* Sigh, we have to do some real work. */
133 size_t cnt;
134
135 for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4, outptr += 4)
136 {
137 outptr[0] = inptr[3];
138 outptr[1] = inptr[2];
139 outptr[2] = inptr[1];
140 outptr[3] = inptr[0];
141 }
142
143 *inptrp = inptr;
144 *outptrp = outptr;
145# elif __BYTE_ORDER == __BIG_ENDIAN
146 /* Simply copy the data. */
147 *inptrp = inptr + n_convert * 4;
148 *outptrp = __mempcpy (outptr, inptr, n_convert * 4);
149# else
150# error "This endianess is not supported."
151# endif
152
153 /* Determine the status. */
154 if (*inptrp == inend)
155 result = __GCONV_EMPTY_INPUT;
156 else if (*outptrp + 4 > outend)
157 result = __GCONV_FULL_OUTPUT;
158 else
159 result = __GCONV_INCOMPLETE_INPUT;
160
161 return result;
162}
163#endif
164
165
166static inline int
167__attribute ((always_inline))
168internal_ucs4_loop_single (struct __gconv_step *step,
169 struct __gconv_step_data *step_data,
170 const unsigned char **inptrp,
171 const unsigned char *inend,
172 unsigned char **outptrp, unsigned char *outend,
173 size_t *irreversible)
174{
175 mbstate_t *state = step_data->__statep;
176 size_t cnt = state->__count & 7;
177
178 while (*inptrp < inend && cnt < 4)
179 state->__value.__wchb[cnt++] = *(*inptrp)++;
180
181 if (__glibc_unlikely (cnt < 4))
182 {
183 /* Still not enough bytes. Store the ones in the input buffer. */
184 state->__count &= ~7;
185 state->__count |= cnt;
186
187 return __GCONV_INCOMPLETE_INPUT;
188 }
189
190#if __BYTE_ORDER == __LITTLE_ENDIAN
191 (*outptrp)[0] = state->__value.__wchb[3];
192 (*outptrp)[1] = state->__value.__wchb[2];
193 (*outptrp)[2] = state->__value.__wchb[1];
194 (*outptrp)[3] = state->__value.__wchb[0];
195
196#elif __BYTE_ORDER == __BIG_ENDIAN
197 /* XXX unaligned */
198 (*outptrp)[0] = state->__value.__wchb[0];
199 (*outptrp)[1] = state->__value.__wchb[1];
200 (*outptrp)[2] = state->__value.__wchb[2];
201 (*outptrp)[3] = state->__value.__wchb[3];
202#else
203# error "This endianess is not supported."
204#endif
205 *outptrp += 4;
206
207 /* Clear the state buffer. */
208 state->__count &= ~7;
209
210 return __GCONV_OK;
211}
212
213#include <iconv/skeleton.c>
214
215
216/* Transform from UCS4 to the internal, UCS4-like format. Unlike
217 for the other direction we have to check for correct values here. */
218#define DEFINE_INIT 0
219#define DEFINE_FINI 0
220#define MIN_NEEDED_FROM 4
221#define MIN_NEEDED_TO 4
222#define FROM_DIRECTION 1
223#define FROM_LOOP ucs4_internal_loop
224#define TO_LOOP ucs4_internal_loop /* This is not used. */
225#define FUNCTION_NAME __gconv_transform_ucs4_internal
226#define ONE_DIRECTION 0
227
228
229static inline int
230__attribute ((always_inline))
231ucs4_internal_loop (struct __gconv_step *step,
232 struct __gconv_step_data *step_data,
233 const unsigned char **inptrp, const unsigned char *inend,
234 unsigned char **outptrp, unsigned char *outend,
235 size_t *irreversible)
236{
237 int flags = step_data->__flags;
238 const unsigned char *inptr = *inptrp;
239 unsigned char *outptr = *outptrp;
240 size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
241 int result;
242 size_t cnt;
243
244 for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
245 {
246 uint32_t inval;
247
248#if __BYTE_ORDER == __LITTLE_ENDIAN
249 inval = bswap_32 (*(const uint32_t *) inptr);
250#else
251 inval = *(const uint32_t *) inptr;
252#endif
253
254 if (__glibc_unlikely (inval > 0x7fffffff))
255 {
256 /* The value is too large. We don't try transliteration here since
257 this is not an error because of the lack of possibilities to
258 represent the result. This is a genuine bug in the input since
259 UCS4 does not allow such values. */
260 if (irreversible == NULL)
261 /* We are transliterating, don't try to correct anything. */
262 return __GCONV_ILLEGAL_INPUT;
263
264 if (flags & __GCONV_IGNORE_ERRORS)
265 {
266 /* Just ignore this character. */
267 ++*irreversible;
268 continue;
269 }
270
271 *inptrp = inptr;
272 *outptrp = outptr;
273 return __GCONV_ILLEGAL_INPUT;
274 }
275
276 *((uint32_t *) outptr) = inval;
277 outptr += sizeof (uint32_t);
278 }
279
280 *inptrp = inptr;
281 *outptrp = outptr;
282
283 /* Determine the status. */
284 if (*inptrp == inend)
285 result = __GCONV_EMPTY_INPUT;
286 else if (*outptrp + 4 > outend)
287 result = __GCONV_FULL_OUTPUT;
288 else
289 result = __GCONV_INCOMPLETE_INPUT;
290
291 return result;
292}
293
294#if !_STRING_ARCH_unaligned
295static inline int
296__attribute ((always_inline))
297ucs4_internal_loop_unaligned (struct __gconv_step *step,
298 struct __gconv_step_data *step_data,
299 const unsigned char **inptrp,
300 const unsigned char *inend,
301 unsigned char **outptrp, unsigned char *outend,
302 size_t *irreversible)
303{
304 int flags = step_data->__flags;
305 const unsigned char *inptr = *inptrp;
306 unsigned char *outptr = *outptrp;
307 size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
308 int result;
309 size_t cnt;
310
311 for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
312 {
313 if (__glibc_unlikely (inptr[0] > 0x80))
314 {
315 /* The value is too large. We don't try transliteration here since
316 this is not an error because of the lack of possibilities to
317 represent the result. This is a genuine bug in the input since
318 UCS4 does not allow such values. */
319 if (irreversible == NULL)
320 /* We are transliterating, don't try to correct anything. */
321 return __GCONV_ILLEGAL_INPUT;
322
323 if (flags & __GCONV_IGNORE_ERRORS)
324 {
325 /* Just ignore this character. */
326 ++*irreversible;
327 continue;
328 }
329
330 *inptrp = inptr;
331 *outptrp = outptr;
332 return __GCONV_ILLEGAL_INPUT;
333 }
334
335# if __BYTE_ORDER == __LITTLE_ENDIAN
336 outptr[3] = inptr[0];
337 outptr[2] = inptr[1];
338 outptr[1] = inptr[2];
339 outptr[0] = inptr[3];
340# else
341 outptr[0] = inptr[0];
342 outptr[1] = inptr[1];
343 outptr[2] = inptr[2];
344 outptr[3] = inptr[3];
345# endif
346 outptr += 4;
347 }
348
349 *inptrp = inptr;
350 *outptrp = outptr;
351
352 /* Determine the status. */
353 if (*inptrp == inend)
354 result = __GCONV_EMPTY_INPUT;
355 else if (*outptrp + 4 > outend)
356 result = __GCONV_FULL_OUTPUT;
357 else
358 result = __GCONV_INCOMPLETE_INPUT;
359
360 return result;
361}
362#endif
363
364
365static inline int
366__attribute ((always_inline))
367ucs4_internal_loop_single (struct __gconv_step *step,
368 struct __gconv_step_data *step_data,
369 const unsigned char **inptrp,
370 const unsigned char *inend,
371 unsigned char **outptrp, unsigned char *outend,
372 size_t *irreversible)
373{
374 mbstate_t *state = step_data->__statep;
375 int flags = step_data->__flags;
376 size_t cnt = state->__count & 7;
377
378 while (*inptrp < inend && cnt < 4)
379 state->__value.__wchb[cnt++] = *(*inptrp)++;
380
381 if (__glibc_unlikely (cnt < 4))
382 {
383 /* Still not enough bytes. Store the ones in the input buffer. */
384 state->__count &= ~7;
385 state->__count |= cnt;
386
387 return __GCONV_INCOMPLETE_INPUT;
388 }
389
390 if (__builtin_expect (((unsigned char *) state->__value.__wchb)[0] > 0x80,
391 0))
392 {
393 /* The value is too large. We don't try transliteration here since
394 this is not an error because of the lack of possibilities to
395 represent the result. This is a genuine bug in the input since
396 UCS4 does not allow such values. */
397 if (!(flags & __GCONV_IGNORE_ERRORS))
398 {
399 *inptrp -= cnt - (state->__count & 7);
400 return __GCONV_ILLEGAL_INPUT;
401 }
402 }
403 else
404 {
405#if __BYTE_ORDER == __LITTLE_ENDIAN
406 (*outptrp)[0] = state->__value.__wchb[3];
407 (*outptrp)[1] = state->__value.__wchb[2];
408 (*outptrp)[2] = state->__value.__wchb[1];
409 (*outptrp)[3] = state->__value.__wchb[0];
410#elif __BYTE_ORDER == __BIG_ENDIAN
411 (*outptrp)[0] = state->__value.__wchb[0];
412 (*outptrp)[1] = state->__value.__wchb[1];
413 (*outptrp)[2] = state->__value.__wchb[2];
414 (*outptrp)[3] = state->__value.__wchb[3];
415#endif
416
417 *outptrp += 4;
418 }
419
420 /* Clear the state buffer. */
421 state->__count &= ~7;
422
423 return __GCONV_OK;
424}
425
426#include <iconv/skeleton.c>
427
428
429/* Similarly for the little endian form. */
430#define DEFINE_INIT 0
431#define DEFINE_FINI 0
432#define MIN_NEEDED_FROM 4
433#define MIN_NEEDED_TO 4
434#define FROM_DIRECTION 1
435#define FROM_LOOP internal_ucs4le_loop
436#define TO_LOOP internal_ucs4le_loop /* This is not used. */
437#define FUNCTION_NAME __gconv_transform_internal_ucs4le
438#define ONE_DIRECTION 0
439
440
441static inline int
442__attribute ((always_inline))
443internal_ucs4le_loop (struct __gconv_step *step,
444 struct __gconv_step_data *step_data,
445 const unsigned char **inptrp, const unsigned char *inend,
446 unsigned char **outptrp, unsigned char *outend,
447 size_t *irreversible)
448{
449 const unsigned char *inptr = *inptrp;
450 unsigned char *outptr = *outptrp;
451 size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
452 int result;
453
454#if __BYTE_ORDER == __BIG_ENDIAN
455 /* Sigh, we have to do some real work. */
456 size_t cnt;
457 uint32_t *outptr32 = (uint32_t *) outptr;
458
459 for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
460 *outptr32++ = bswap_32 (*(const uint32_t *) inptr);
461 outptr = (unsigned char *) outptr32;
462
463 *inptrp = inptr;
464 *outptrp = outptr;
465#elif __BYTE_ORDER == __LITTLE_ENDIAN
466 /* Simply copy the data. */
467 *inptrp = inptr + n_convert * 4;
468 *outptrp = __mempcpy (outptr, inptr, n_convert * 4);
469#else
470# error "This endianess is not supported."
471#endif
472
473 /* Determine the status. */
474 if (*inptrp == inend)
475 result = __GCONV_EMPTY_INPUT;
476 else if (*outptrp + 4 > outend)
477 result = __GCONV_FULL_OUTPUT;
478 else
479 result = __GCONV_INCOMPLETE_INPUT;
480
481 return result;
482}
483
484#if !_STRING_ARCH_unaligned
485static inline int
486__attribute ((always_inline))
487internal_ucs4le_loop_unaligned (struct __gconv_step *step,
488 struct __gconv_step_data *step_data,
489 const unsigned char **inptrp,
490 const unsigned char *inend,
491 unsigned char **outptrp, unsigned char *outend,
492 size_t *irreversible)
493{
494 const unsigned char *inptr = *inptrp;
495 unsigned char *outptr = *outptrp;
496 size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
497 int result;
498
499# if __BYTE_ORDER == __BIG_ENDIAN
500 /* Sigh, we have to do some real work. */
501 size_t cnt;
502
503 for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4, outptr += 4)
504 {
505 outptr[0] = inptr[3];
506 outptr[1] = inptr[2];
507 outptr[2] = inptr[1];
508 outptr[3] = inptr[0];
509 }
510
511 *inptrp = inptr;
512 *outptrp = outptr;
513# elif __BYTE_ORDER == __LITTLE_ENDIAN
514 /* Simply copy the data. */
515 *inptrp = inptr + n_convert * 4;
516 *outptrp = __mempcpy (outptr, inptr, n_convert * 4);
517# else
518# error "This endianess is not supported."
519# endif
520
521 /* Determine the status. */
522 if (*inptrp == inend)
523 result = __GCONV_EMPTY_INPUT;
524 else if (*inptrp + 4 > inend)
525 result = __GCONV_INCOMPLETE_INPUT;
526 else
527 {
528 assert (*outptrp + 4 > outend);
529 result = __GCONV_FULL_OUTPUT;
530 }
531
532 return result;
533}
534#endif
535
536
537static inline int
538__attribute ((always_inline))
539internal_ucs4le_loop_single (struct __gconv_step *step,
540 struct __gconv_step_data *step_data,
541 const unsigned char **inptrp,
542 const unsigned char *inend,
543 unsigned char **outptrp, unsigned char *outend,
544 size_t *irreversible)
545{
546 mbstate_t *state = step_data->__statep;
547 size_t cnt = state->__count & 7;
548
549 while (*inptrp < inend && cnt < 4)
550 state->__value.__wchb[cnt++] = *(*inptrp)++;
551
552 if (__glibc_unlikely (cnt < 4))
553 {
554 /* Still not enough bytes. Store the ones in the input buffer. */
555 state->__count &= ~7;
556 state->__count |= cnt;
557
558 return __GCONV_INCOMPLETE_INPUT;
559 }
560
561#if __BYTE_ORDER == __BIG_ENDIAN
562 (*outptrp)[0] = state->__value.__wchb[3];
563 (*outptrp)[1] = state->__value.__wchb[2];
564 (*outptrp)[2] = state->__value.__wchb[1];
565 (*outptrp)[3] = state->__value.__wchb[0];
566
567#else
568 /* XXX unaligned */
569 (*outptrp)[0] = state->__value.__wchb[0];
570 (*outptrp)[1] = state->__value.__wchb[1];
571 (*outptrp)[2] = state->__value.__wchb[2];
572 (*outptrp)[3] = state->__value.__wchb[3];
573
574#endif
575
576 *outptrp += 4;
577
578 /* Clear the state buffer. */
579 state->__count &= ~7;
580
581 return __GCONV_OK;
582}
583
584#include <iconv/skeleton.c>
585
586
587/* And finally from UCS4-LE to the internal encoding. */
588#define DEFINE_INIT 0
589#define DEFINE_FINI 0
590#define MIN_NEEDED_FROM 4
591#define MIN_NEEDED_TO 4
592#define FROM_DIRECTION 1
593#define FROM_LOOP ucs4le_internal_loop
594#define TO_LOOP ucs4le_internal_loop /* This is not used. */
595#define FUNCTION_NAME __gconv_transform_ucs4le_internal
596#define ONE_DIRECTION 0
597
598
599static inline int
600__attribute ((always_inline))
601ucs4le_internal_loop (struct __gconv_step *step,
602 struct __gconv_step_data *step_data,
603 const unsigned char **inptrp, const unsigned char *inend,
604 unsigned char **outptrp, unsigned char *outend,
605 size_t *irreversible)
606{
607 int flags = step_data->__flags;
608 const unsigned char *inptr = *inptrp;
609 unsigned char *outptr = *outptrp;
610 size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
611 int result;
612 size_t cnt;
613
614 for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
615 {
616 uint32_t inval;
617
618#if __BYTE_ORDER == __BIG_ENDIAN
619 inval = bswap_32 (*(const uint32_t *) inptr);
620#else
621 inval = *(const uint32_t *) inptr;
622#endif
623
624 if (__glibc_unlikely (inval > 0x7fffffff))
625 {
626 /* The value is too large. We don't try transliteration here since
627 this is not an error because of the lack of possibilities to
628 represent the result. This is a genuine bug in the input since
629 UCS4 does not allow such values. */
630 if (irreversible == NULL)
631 /* We are transliterating, don't try to correct anything. */
632 return __GCONV_ILLEGAL_INPUT;
633
634 if (flags & __GCONV_IGNORE_ERRORS)
635 {
636 /* Just ignore this character. */
637 ++*irreversible;
638 continue;
639 }
640
641 return __GCONV_ILLEGAL_INPUT;
642 }
643
644 *((uint32_t *) outptr) = inval;
645 outptr += sizeof (uint32_t);
646 }
647
648 *inptrp = inptr;
649 *outptrp = outptr;
650
651 /* Determine the status. */
652 if (*inptrp == inend)
653 result = __GCONV_EMPTY_INPUT;
654 else if (*inptrp + 4 > inend)
655 result = __GCONV_INCOMPLETE_INPUT;
656 else
657 {
658 assert (*outptrp + 4 > outend);
659 result = __GCONV_FULL_OUTPUT;
660 }
661
662 return result;
663}
664
665#if !_STRING_ARCH_unaligned
666static inline int
667__attribute ((always_inline))
668ucs4le_internal_loop_unaligned (struct __gconv_step *step,
669 struct __gconv_step_data *step_data,
670 const unsigned char **inptrp,
671 const unsigned char *inend,
672 unsigned char **outptrp, unsigned char *outend,
673 size_t *irreversible)
674{
675 int flags = step_data->__flags;
676 const unsigned char *inptr = *inptrp;
677 unsigned char *outptr = *outptrp;
678 size_t n_convert = MIN (inend - inptr, outend - outptr) / 4;
679 int result;
680 size_t cnt;
681
682 for (cnt = 0; cnt < n_convert; ++cnt, inptr += 4)
683 {
684 if (__glibc_unlikely (inptr[3] > 0x80))
685 {
686 /* The value is too large. We don't try transliteration here since
687 this is not an error because of the lack of possibilities to
688 represent the result. This is a genuine bug in the input since
689 UCS4 does not allow such values. */
690 if (irreversible == NULL)
691 /* We are transliterating, don't try to correct anything. */
692 return __GCONV_ILLEGAL_INPUT;
693
694 if (flags & __GCONV_IGNORE_ERRORS)
695 {
696 /* Just ignore this character. */
697 ++*irreversible;
698 continue;
699 }
700
701 *inptrp = inptr;
702 *outptrp = outptr;
703 return __GCONV_ILLEGAL_INPUT;
704 }
705
706# if __BYTE_ORDER == __BIG_ENDIAN
707 outptr[3] = inptr[0];
708 outptr[2] = inptr[1];
709 outptr[1] = inptr[2];
710 outptr[0] = inptr[3];
711# else
712 outptr[0] = inptr[0];
713 outptr[1] = inptr[1];
714 outptr[2] = inptr[2];
715 outptr[3] = inptr[3];
716# endif
717
718 outptr += 4;
719 }
720
721 *inptrp = inptr;
722 *outptrp = outptr;
723
724 /* Determine the status. */
725 if (*inptrp == inend)
726 result = __GCONV_EMPTY_INPUT;
727 else if (*inptrp + 4 > inend)
728 result = __GCONV_INCOMPLETE_INPUT;
729 else
730 {
731 assert (*outptrp + 4 > outend);
732 result = __GCONV_FULL_OUTPUT;
733 }
734
735 return result;
736}
737#endif
738
739
740static inline int
741__attribute ((always_inline))
742ucs4le_internal_loop_single (struct __gconv_step *step,
743 struct __gconv_step_data *step_data,
744 const unsigned char **inptrp,
745 const unsigned char *inend,
746 unsigned char **outptrp, unsigned char *outend,
747 size_t *irreversible)
748{
749 mbstate_t *state = step_data->__statep;
750 int flags = step_data->__flags;
751 size_t cnt = state->__count & 7;
752
753 while (*inptrp < inend && cnt < 4)
754 state->__value.__wchb[cnt++] = *(*inptrp)++;
755
756 if (__glibc_unlikely (cnt < 4))
757 {
758 /* Still not enough bytes. Store the ones in the input buffer. */
759 state->__count &= ~7;
760 state->__count |= cnt;
761
762 return __GCONV_INCOMPLETE_INPUT;
763 }
764
765 if (__builtin_expect (((unsigned char *) state->__value.__wchb)[3] > 0x80,
766 0))
767 {
768 /* The value is too large. We don't try transliteration here since
769 this is not an error because of the lack of possibilities to
770 represent the result. This is a genuine bug in the input since
771 UCS4 does not allow such values. */
772 if (!(flags & __GCONV_IGNORE_ERRORS))
773 return __GCONV_ILLEGAL_INPUT;
774 }
775 else
776 {
777#if __BYTE_ORDER == __BIG_ENDIAN
778 (*outptrp)[0] = state->__value.__wchb[3];
779 (*outptrp)[1] = state->__value.__wchb[2];
780 (*outptrp)[2] = state->__value.__wchb[1];
781 (*outptrp)[3] = state->__value.__wchb[0];
782#else
783 (*outptrp)[0] = state->__value.__wchb[0];
784 (*outptrp)[1] = state->__value.__wchb[1];
785 (*outptrp)[2] = state->__value.__wchb[2];
786 (*outptrp)[3] = state->__value.__wchb[3];
787#endif
788
789 *outptrp += 4;
790 }
791
792 /* Clear the state buffer. */
793 state->__count &= ~7;
794
795 return __GCONV_OK;
796}
797
798#include <iconv/skeleton.c>
799
800
801/* Convert from ISO 646-IRV to the internal (UCS4-like) format. */
802#define DEFINE_INIT 0
803#define DEFINE_FINI 0
804#define MIN_NEEDED_FROM 1
805#define MIN_NEEDED_TO 4
806#define FROM_DIRECTION 1
807#define FROM_LOOP ascii_internal_loop
808#define TO_LOOP ascii_internal_loop /* This is not used. */
809#define FUNCTION_NAME __gconv_transform_ascii_internal
810#define ONE_DIRECTION 1
811
812#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
813#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
814#define LOOPFCT FROM_LOOP
815#define BODY \
816 { \
817 if (__glibc_unlikely (*inptr > '\x7f')) \
818 { \
819 /* The value is too large. We don't try transliteration here since \
820 this is not an error because of the lack of possibilities to \
821 represent the result. This is a genuine bug in the input since \
822 ASCII does not allow such values. */ \
823 STANDARD_FROM_LOOP_ERR_HANDLER (1); \
824 } \
825 else \
826 { \
827 /* It's an one byte sequence. */ \
828 *((uint32_t *) outptr) = *inptr++; \
829 outptr += sizeof (uint32_t); \
830 } \
831 }
832#define LOOP_NEED_FLAGS
833#include <iconv/loop.c>
834#include <iconv/skeleton.c>
835
836
837/* Convert from the internal (UCS4-like) format to ISO 646-IRV. */
838#define DEFINE_INIT 0
839#define DEFINE_FINI 0
840#define MIN_NEEDED_FROM 4
841#define MIN_NEEDED_TO 1
842#define FROM_DIRECTION 1
843#define FROM_LOOP internal_ascii_loop
844#define TO_LOOP internal_ascii_loop /* This is not used. */
845#define FUNCTION_NAME __gconv_transform_internal_ascii
846#define ONE_DIRECTION 1
847
848#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
849#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
850#define LOOPFCT FROM_LOOP
851#define BODY \
852 { \
853 if (__glibc_unlikely (*((const uint32_t *) inptr) > 0x7f)) \
854 { \
855 UNICODE_TAG_HANDLER (*((const uint32_t *) inptr), 4); \
856 STANDARD_TO_LOOP_ERR_HANDLER (4); \
857 } \
858 else \
859 { \
860 /* It's an one byte sequence. */ \
861 *outptr++ = *((const uint32_t *) inptr); \
862 inptr += sizeof (uint32_t); \
863 } \
864 }
865#define LOOP_NEED_FLAGS
866#include <iconv/loop.c>
867#include <iconv/skeleton.c>
868
869
870/* Convert from the internal (UCS4-like) format to UTF-8. */
871#define DEFINE_INIT 0
872#define DEFINE_FINI 0
873#define MIN_NEEDED_FROM 4
874#define MIN_NEEDED_TO 1
875#define MAX_NEEDED_TO 6
876#define FROM_DIRECTION 1
877#define FROM_LOOP internal_utf8_loop
878#define TO_LOOP internal_utf8_loop /* This is not used. */
879#define FUNCTION_NAME __gconv_transform_internal_utf8
880#define ONE_DIRECTION 1
881
882#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
883#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
884#define MAX_NEEDED_OUTPUT MAX_NEEDED_TO
885#define LOOPFCT FROM_LOOP
886#define BODY \
887 { \
888 uint32_t wc = *((const uint32_t *) inptr); \
889 \
890 if (__glibc_likely (wc < 0x80)) \
891 /* It's an one byte sequence. */ \
892 *outptr++ = (unsigned char) wc; \
893 else if (__glibc_likely (wc <= 0x7fffffff)) \
894 { \
895 size_t step; \
896 unsigned char *start; \
897 \
898 for (step = 2; step < 6; ++step) \
899 if ((wc & (~(uint32_t)0 << (5 * step + 1))) == 0) \
900 break; \
901 \
902 if (__glibc_unlikely (outptr + step > outend)) \
903 { \
904 /* Too long. */ \
905 result = __GCONV_FULL_OUTPUT; \
906 break; \
907 } \
908 \
909 start = outptr; \
910 *outptr = (unsigned char) (~0xff >> step); \
911 outptr += step; \
912 do \
913 { \
914 start[--step] = 0x80 | (wc & 0x3f); \
915 wc >>= 6; \
916 } \
917 while (step > 1); \
918 start[0] |= wc; \
919 } \
920 else \
921 { \
922 STANDARD_TO_LOOP_ERR_HANDLER (4); \
923 } \
924 \
925 inptr += 4; \
926 }
927#define LOOP_NEED_FLAGS
928#include <iconv/loop.c>
929#include <iconv/skeleton.c>
930
931
932/* Convert from UTF-8 to the internal (UCS4-like) format. */
933#define DEFINE_INIT 0
934#define DEFINE_FINI 0
935#define MIN_NEEDED_FROM 1
936#define MAX_NEEDED_FROM 6
937#define MIN_NEEDED_TO 4
938#define FROM_DIRECTION 1
939#define FROM_LOOP utf8_internal_loop
940#define TO_LOOP utf8_internal_loop /* This is not used. */
941#define FUNCTION_NAME __gconv_transform_utf8_internal
942#define ONE_DIRECTION 1
943
944#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
945#define MAX_NEEDED_INPUT MAX_NEEDED_FROM
946#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
947#define LOOPFCT FROM_LOOP
948#define BODY \
949 { \
950 /* Next input byte. */ \
951 uint32_t ch = *inptr; \
952 \
953 if (__glibc_likely (ch < 0x80)) \
954 { \
955 /* One byte sequence. */ \
956 ++inptr; \
957 } \
958 else \
959 { \
960 uint_fast32_t cnt; \
961 uint_fast32_t i; \
962 \
963 if (ch >= 0xc2 && ch < 0xe0) \
964 { \
965 /* We expect two bytes. The first byte cannot be 0xc0 or 0xc1, \
966 otherwise the wide character could have been represented \
967 using a single byte. */ \
968 cnt = 2; \
969 ch &= 0x1f; \
970 } \
971 else if (__glibc_likely ((ch & 0xf0) == 0xe0)) \
972 { \
973 /* We expect three bytes. */ \
974 cnt = 3; \
975 ch &= 0x0f; \
976 } \
977 else if (__glibc_likely ((ch & 0xf8) == 0xf0)) \
978 { \
979 /* We expect four bytes. */ \
980 cnt = 4; \
981 ch &= 0x07; \
982 } \
983 else if (__glibc_likely ((ch & 0xfc) == 0xf8)) \
984 { \
985 /* We expect five bytes. */ \
986 cnt = 5; \
987 ch &= 0x03; \
988 } \
989 else if (__glibc_likely ((ch & 0xfe) == 0xfc)) \
990 { \
991 /* We expect six bytes. */ \
992 cnt = 6; \
993 ch &= 0x01; \
994 } \
995 else \
996 { \
997 /* Search the end of this ill-formed UTF-8 character. This \
998 is the next byte with (x & 0xc0) != 0x80. */ \
999 i = 0; \
1000 do \
1001 ++i; \
1002 while (inptr + i < inend \
1003 && (*(inptr + i) & 0xc0) == 0x80 \
1004 && i < 5); \
1005 \
1006 errout: \
1007 STANDARD_FROM_LOOP_ERR_HANDLER (i); \
1008 } \
1009 \
1010 if (__glibc_unlikely (inptr + cnt > inend)) \
1011 { \
1012 /* We don't have enough input. But before we report that check \
1013 that all the bytes are correct. */ \
1014 for (i = 1; inptr + i < inend; ++i) \
1015 if ((inptr[i] & 0xc0) != 0x80) \
1016 break; \
1017 \
1018 if (__glibc_likely (inptr + i == inend)) \
1019 { \
1020 result = __GCONV_INCOMPLETE_INPUT; \
1021 break; \
1022 } \
1023 \
1024 goto errout; \
1025 } \
1026 \
1027 /* Read the possible remaining bytes. */ \
1028 for (i = 1; i < cnt; ++i) \
1029 { \
1030 uint32_t byte = inptr[i]; \
1031 \
1032 if ((byte & 0xc0) != 0x80) \
1033 /* This is an illegal encoding. */ \
1034 break; \
1035 \
1036 ch <<= 6; \
1037 ch |= byte & 0x3f; \
1038 } \
1039 \
1040 /* If i < cnt, some trail byte was not >= 0x80, < 0xc0. \
1041 If cnt > 2 and ch < 2^(5*cnt-4), the wide character ch could \
1042 have been represented with fewer than cnt bytes. */ \
1043 if (i < cnt || (cnt > 2 && (ch >> (5 * cnt - 4)) == 0) \
1044 /* Do not accept UTF-16 surrogates. */ \
1045 || (ch >= 0xd800 && ch <= 0xdfff)) \
1046 { \
1047 /* This is an illegal encoding. */ \
1048 goto errout; \
1049 } \
1050 \
1051 inptr += cnt; \
1052 } \
1053 \
1054 /* Now adjust the pointers and store the result. */ \
1055 *((uint32_t *) outptr) = ch; \
1056 outptr += sizeof (uint32_t); \
1057 }
1058#define LOOP_NEED_FLAGS
1059
1060#define STORE_REST \
1061 { \
1062 /* We store the remaining bytes while converting them into the UCS4 \
1063 format. We can assume that the first byte in the buffer is \
1064 correct and that it requires a larger number of bytes than there \
1065 are in the input buffer. */ \
1066 wint_t ch = **inptrp; \
1067 size_t cnt, r; \
1068 \
1069 state->__count = inend - *inptrp; \
1070 \
1071 assert (ch != 0xc0 && ch != 0xc1); \
1072 if (ch >= 0xc2 && ch < 0xe0) \
1073 { \
1074 /* We expect two bytes. The first byte cannot be 0xc0 or \
1075 0xc1, otherwise the wide character could have been \
1076 represented using a single byte. */ \
1077 cnt = 2; \
1078 ch &= 0x1f; \
1079 } \
1080 else if (__glibc_likely ((ch & 0xf0) == 0xe0)) \
1081 { \
1082 /* We expect three bytes. */ \
1083 cnt = 3; \
1084 ch &= 0x0f; \
1085 } \
1086 else if (__glibc_likely ((ch & 0xf8) == 0xf0)) \
1087 { \
1088 /* We expect four bytes. */ \
1089 cnt = 4; \
1090 ch &= 0x07; \
1091 } \
1092 else if (__glibc_likely ((ch & 0xfc) == 0xf8)) \
1093 { \
1094 /* We expect five bytes. */ \
1095 cnt = 5; \
1096 ch &= 0x03; \
1097 } \
1098 else \
1099 { \
1100 /* We expect six bytes. */ \
1101 cnt = 6; \
1102 ch &= 0x01; \
1103 } \
1104 \
1105 /* The first byte is already consumed. */ \
1106 r = cnt - 1; \
1107 while (++(*inptrp) < inend) \
1108 { \
1109 ch <<= 6; \
1110 ch |= **inptrp & 0x3f; \
1111 --r; \
1112 } \
1113 \
1114 /* Shift for the so far missing bytes. */ \
1115 ch <<= r * 6; \
1116 \
1117 /* Store the number of bytes expected for the entire sequence. */ \
1118 state->__count |= cnt << 8; \
1119 \
1120 /* Store the value. */ \
1121 state->__value.__wch = ch; \
1122 }
1123
1124#define UNPACK_BYTES \
1125 { \
1126 static const unsigned char inmask[5] = { 0xc0, 0xe0, 0xf0, 0xf8, 0xfc }; \
1127 wint_t wch = state->__value.__wch; \
1128 size_t ntotal = state->__count >> 8; \
1129 \
1130 inlen = state->__count & 255; \
1131 \
1132 bytebuf[0] = inmask[ntotal - 2]; \
1133 \
1134 do \
1135 { \
1136 if (--ntotal < inlen) \
1137 bytebuf[ntotal] = 0x80 | (wch & 0x3f); \
1138 wch >>= 6; \
1139 } \
1140 while (ntotal > 1); \
1141 \
1142 bytebuf[0] |= wch; \
1143 }
1144
1145#define CLEAR_STATE \
1146 state->__count = 0
1147
1148
1149#include <iconv/loop.c>
1150#include <iconv/skeleton.c>
1151
1152
1153/* Convert from UCS2 to the internal (UCS4-like) format. */
1154#define DEFINE_INIT 0
1155#define DEFINE_FINI 0
1156#define MIN_NEEDED_FROM 2
1157#define MIN_NEEDED_TO 4
1158#define FROM_DIRECTION 1
1159#define FROM_LOOP ucs2_internal_loop
1160#define TO_LOOP ucs2_internal_loop /* This is not used. */
1161#define FUNCTION_NAME __gconv_transform_ucs2_internal
1162#define ONE_DIRECTION 1
1163
1164#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
1165#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
1166#define LOOPFCT FROM_LOOP
1167#define BODY \
1168 { \
1169 uint16_t u1 = get16 (inptr); \
1170 \
1171 if (__glibc_unlikely (u1 >= 0xd800 && u1 < 0xe000)) \
1172 { \
1173 /* Surrogate characters in UCS-2 input are not valid. Reject \
1174 them. (Catching this here is not security relevant.) */ \
1175 STANDARD_FROM_LOOP_ERR_HANDLER (2); \
1176 } \
1177 \
1178 *((uint32_t *) outptr) = u1; \
1179 outptr += sizeof (uint32_t); \
1180 inptr += 2; \
1181 }
1182#define LOOP_NEED_FLAGS
1183#include <iconv/loop.c>
1184#include <iconv/skeleton.c>
1185
1186
1187/* Convert from the internal (UCS4-like) format to UCS2. */
1188#define DEFINE_INIT 0
1189#define DEFINE_FINI 0
1190#define MIN_NEEDED_FROM 4
1191#define MIN_NEEDED_TO 2
1192#define FROM_DIRECTION 1
1193#define FROM_LOOP internal_ucs2_loop
1194#define TO_LOOP internal_ucs2_loop /* This is not used. */
1195#define FUNCTION_NAME __gconv_transform_internal_ucs2
1196#define ONE_DIRECTION 1
1197
1198#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
1199#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
1200#define LOOPFCT FROM_LOOP
1201#define BODY \
1202 { \
1203 uint32_t val = *((const uint32_t *) inptr); \
1204 \
1205 if (__glibc_unlikely (val >= 0x10000)) \
1206 { \
1207 UNICODE_TAG_HANDLER (val, 4); \
1208 STANDARD_TO_LOOP_ERR_HANDLER (4); \
1209 } \
1210 else if (__glibc_unlikely (val >= 0xd800 && val < 0xe000)) \
1211 { \
1212 /* Surrogate characters in UCS-4 input are not valid. \
1213 We must catch this, because the UCS-2 output might be \
1214 interpreted as UTF-16 by other programs. If we let \
1215 surrogates pass through, attackers could make a security \
1216 hole exploit by synthesizing any desired plane 1-16 \
1217 character. */ \
1218 result = __GCONV_ILLEGAL_INPUT; \
1219 if (! ignore_errors_p ()) \
1220 break; \
1221 inptr += 4; \
1222 ++*irreversible; \
1223 continue; \
1224 } \
1225 else \
1226 { \
1227 put16 (outptr, val); \
1228 outptr += sizeof (uint16_t); \
1229 inptr += 4; \
1230 } \
1231 }
1232#define LOOP_NEED_FLAGS
1233#include <iconv/loop.c>
1234#include <iconv/skeleton.c>
1235
1236
1237/* Convert from UCS2 in other endianness to the internal (UCS4-like) format. */
1238#define DEFINE_INIT 0
1239#define DEFINE_FINI 0
1240#define MIN_NEEDED_FROM 2
1241#define MIN_NEEDED_TO 4
1242#define FROM_DIRECTION 1
1243#define FROM_LOOP ucs2reverse_internal_loop
1244#define TO_LOOP ucs2reverse_internal_loop/* This is not used.*/
1245#define FUNCTION_NAME __gconv_transform_ucs2reverse_internal
1246#define ONE_DIRECTION 1
1247
1248#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
1249#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
1250#define LOOPFCT FROM_LOOP
1251#define BODY \
1252 { \
1253 uint16_t u1 = bswap_16 (get16 (inptr)); \
1254 \
1255 if (__glibc_unlikely (u1 >= 0xd800 && u1 < 0xe000)) \
1256 { \
1257 /* Surrogate characters in UCS-2 input are not valid. Reject \
1258 them. (Catching this here is not security relevant.) */ \
1259 if (! ignore_errors_p ()) \
1260 { \
1261 result = __GCONV_ILLEGAL_INPUT; \
1262 break; \
1263 } \
1264 inptr += 2; \
1265 ++*irreversible; \
1266 continue; \
1267 } \
1268 \
1269 *((uint32_t *) outptr) = u1; \
1270 outptr += sizeof (uint32_t); \
1271 inptr += 2; \
1272 }
1273#define LOOP_NEED_FLAGS
1274#include <iconv/loop.c>
1275#include <iconv/skeleton.c>
1276
1277
1278/* Convert from the internal (UCS4-like) format to UCS2 in other endianness. */
1279#define DEFINE_INIT 0
1280#define DEFINE_FINI 0
1281#define MIN_NEEDED_FROM 4
1282#define MIN_NEEDED_TO 2
1283#define FROM_DIRECTION 1
1284#define FROM_LOOP internal_ucs2reverse_loop
1285#define TO_LOOP internal_ucs2reverse_loop/* This is not used.*/
1286#define FUNCTION_NAME __gconv_transform_internal_ucs2reverse
1287#define ONE_DIRECTION 1
1288
1289#define MIN_NEEDED_INPUT MIN_NEEDED_FROM
1290#define MIN_NEEDED_OUTPUT MIN_NEEDED_TO
1291#define LOOPFCT FROM_LOOP
1292#define BODY \
1293 { \
1294 uint32_t val = *((const uint32_t *) inptr); \
1295 if (__glibc_unlikely (val >= 0x10000)) \
1296 { \
1297 UNICODE_TAG_HANDLER (val, 4); \
1298 STANDARD_TO_LOOP_ERR_HANDLER (4); \
1299 } \
1300 else if (__glibc_unlikely (val >= 0xd800 && val < 0xe000)) \
1301 { \
1302 /* Surrogate characters in UCS-4 input are not valid. \
1303 We must catch this, because the UCS-2 output might be \
1304 interpreted as UTF-16 by other programs. If we let \
1305 surrogates pass through, attackers could make a security \
1306 hole exploit by synthesizing any desired plane 1-16 \
1307 character. */ \
1308 if (! ignore_errors_p ()) \
1309 { \
1310 result = __GCONV_ILLEGAL_INPUT; \
1311 break; \
1312 } \
1313 inptr += 4; \
1314 ++*irreversible; \
1315 continue; \
1316 } \
1317 else \
1318 { \
1319 put16 (outptr, bswap_16 (val)); \
1320 outptr += sizeof (uint16_t); \
1321 inptr += 4; \
1322 } \
1323 }
1324#define LOOP_NEED_FLAGS
1325#include <iconv/loop.c>
1326#include <iconv/skeleton.c>
1327