1/*
2**********************************************************************
3*   Copyright (C) 2002-2011, International Business Machines
4*   Corporation and others.  All Rights Reserved.
5**********************************************************************
6*   file name:  ucnv_u7.c
7*   encoding:   US-ASCII
8*   tab size:   8 (not used)
9*   indentation:4
10*
11*   created on: 2002jul01
12*   created by: Markus W. Scherer
13*
14*   UTF-7 converter implementation. Used to be in ucnv_utf.c.
15*/
16
17#include "unicode/utypes.h"
18
19#if !UCONFIG_NO_CONVERSION
20
21#include "unicode/ucnv.h"
22#include "ucnv_bld.h"
23#include "ucnv_cnv.h"
24#include "uassert.h"
25
26/* UTF-7 -------------------------------------------------------------------- */
27
28/*
29 * UTF-7 is a stateful encoding of Unicode.
30 * It is defined in RFC 2152. (http://www.ietf.org/rfc/rfc2152.txt)
31 * It was intended for use in Internet email systems, using in its bytewise
32 * encoding only a subset of 7-bit US-ASCII.
33 * UTF-7 is deprecated in favor of UTF-8/16/32 and SCSU, but still
34 * occasionally used.
35 *
36 * For converting Unicode to UTF-7, the RFC allows to encode some US-ASCII
37 * characters directly or in base64. Especially, the characters in set O
38 * as defined in the RFC (see below) may be encoded directly but are not
39 * allowed in, e.g., email headers.
40 * By default, the ICU UTF-7 converter encodes set O directly.
41 * By choosing the option "version=1", set O will be escaped instead.
42 * For example:
43 *     utf7Converter=ucnv_open("UTF-7,version=1");
44 *
45 * For details about email headers see RFC 2047.
46 */
47
48/*
49 * Tests for US-ASCII characters belonging to character classes
50 * defined in UTF-7.
51 *
52 * Set D (directly encoded characters) consists of the following
53 * characters: the upper and lower case letters A through Z
54 * and a through z, the 10 digits 0-9, and the following nine special
55 * characters (note that "+" and "=" are omitted):
56 *     '(),-./:?
57 *
58 * Set O (optional direct characters) consists of the following
59 * characters (note that "\" and "~" are omitted):
60 *     !"#$%&*;<=>@[]^_`{|}
61 *
62 * According to the rules in RFC 2152, the byte values for the following
63 * US-ASCII characters are not used in UTF-7 and are therefore illegal:
64 * - all C0 control codes except for CR LF TAB
65 * - BACKSLASH
66 * - TILDE
67 * - DEL
68 * - all codes beyond US-ASCII, i.e. all >127
69 */
70#define inSetD(c) \
71    ((uint8_t)((c)-97)<26 || (uint8_t)((c)-65)<26 || /* letters */ \
72     (uint8_t)((c)-48)<10 ||    /* digits */ \
73     (uint8_t)((c)-39)<3 ||     /* '() */ \
74     (uint8_t)((c)-44)<4 ||     /* ,-./ */ \
75     (c)==58 || (c)==63         /* :? */ \
76    )
77
78#define inSetO(c) \
79    ((uint8_t)((c)-33)<6 ||         /* !"#$%& */ \
80     (uint8_t)((c)-59)<4 ||         /* ;<=> */ \
81     (uint8_t)((c)-93)<4 ||         /* ]^_` */ \
82     (uint8_t)((c)-123)<3 ||        /* {|} */ \
83     (c)==42 || (c)==64 || (c)==91  /* *@[ */ \
84    )
85
86#define isCRLFTAB(c) ((c)==13 || (c)==10 || (c)==9)
87#define isCRLFSPTAB(c) ((c)==32 || (c)==13 || (c)==10 || (c)==9)
88
89#define PLUS  43
90#define MINUS 45
91#define BACKSLASH 92
92#define TILDE 126
93
94/* legal byte values: all US-ASCII graphic characters from space to before tilde, and CR LF TAB */
95#define isLegalUTF7(c) (((uint8_t)((c)-32)<94 && (c)!=BACKSLASH) || isCRLFTAB(c))
96
97/* encode directly sets D and O and CR LF SP TAB */
98static const UBool encodeDirectlyMaximum[128]={
99 /* 0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f */
100    0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0,
101    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
102
103    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1,
104    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
105
106    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
107    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1,
108
109    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
110    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0
111};
112
113/* encode directly set D and CR LF SP TAB but not set O */
114static const UBool encodeDirectlyRestricted[128]={
115 /* 0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f */
116    0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0,
117    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
118
119    1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1,
120    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
121
122    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
123    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
124
125    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
126    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0
127};
128
129static const uint8_t
130toBase64[64]={
131    /* A-Z */
132    65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
133    78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
134    /* a-z */
135    97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
136    110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
137    /* 0-9 */
138    48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
139    /* +/ */
140    43, 47
141};
142
143static const int8_t
144fromBase64[128]={
145    /* C0 controls, -1 for legal ones (CR LF TAB), -3 for illegal ones */
146    -3, -3, -3, -3, -3, -3, -3, -3, -3, -1, -1, -3, -3, -1, -3, -3,
147    -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,
148
149    /* general punctuation with + and / and a special value (-2) for - */
150    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -2, -1, 63,
151    /* digits */
152    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
153
154    /* A-Z */
155    -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
156    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -3, -1, -1, -1,
157
158    /* a-z */
159    -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
160    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -3, -3
161};
162
163/*
164 * converter status values:
165 *
166 * toUnicodeStatus:
167 *     24 inDirectMode (boolean)
168 * 23..16 base64Counter (-1..7)
169 * 15..0  bits (up to 14 bits incoming base64)
170 *
171 * fromUnicodeStatus:
172 * 31..28 version (0: set O direct  1: set O escaped)
173 *     24 inDirectMode (boolean)
174 * 23..16 base64Counter (0..2)
175 *  7..0  bits (6 bits outgoing base64)
176 *
177 */
178
179static void
180_UTF7Reset(UConverter *cnv, UConverterResetChoice choice) {
181    if(choice<=UCNV_RESET_TO_UNICODE) {
182        /* reset toUnicode */
183        cnv->toUnicodeStatus=0x1000000; /* inDirectMode=TRUE */
184        cnv->toULength=0;
185    }
186    if(choice!=UCNV_RESET_TO_UNICODE) {
187        /* reset fromUnicode */
188        cnv->fromUnicodeStatus=(cnv->fromUnicodeStatus&0xf0000000)|0x1000000; /* keep version, inDirectMode=TRUE */
189    }
190}
191
192static void
193_UTF7Open(UConverter *cnv,
194          UConverterLoadArgs *pArgs,
195          UErrorCode *pErrorCode) {
196    if(UCNV_GET_VERSION(cnv)<=1) {
197        /* TODO(markus): Should just use cnv->options rather than copying the version number. */
198        cnv->fromUnicodeStatus=UCNV_GET_VERSION(cnv)<<28;
199        _UTF7Reset(cnv, UCNV_RESET_BOTH);
200    } else {
201        *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
202    }
203}
204
205static void
206_UTF7ToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
207                          UErrorCode *pErrorCode) {
208    UConverter *cnv;
209    const uint8_t *source, *sourceLimit;
210    UChar *target;
211    const UChar *targetLimit;
212    int32_t *offsets;
213
214    uint8_t *bytes;
215    uint8_t byteIndex;
216
217    int32_t length, targetCapacity;
218
219    /* UTF-7 state */
220    uint16_t bits;
221    int8_t base64Counter;
222    UBool inDirectMode;
223
224    int8_t base64Value;
225
226    int32_t sourceIndex, nextSourceIndex;
227
228    uint8_t b;
229    /* set up the local pointers */
230    cnv=pArgs->converter;
231
232    source=(const uint8_t *)pArgs->source;
233    sourceLimit=(const uint8_t *)pArgs->sourceLimit;
234    target=pArgs->target;
235    targetLimit=pArgs->targetLimit;
236    offsets=pArgs->offsets;
237    /* get the state machine state */
238    {
239        uint32_t status=cnv->toUnicodeStatus;
240        inDirectMode=(UBool)((status>>24)&1);
241        base64Counter=(int8_t)(status>>16);
242        bits=(uint16_t)status;
243    }
244    bytes=cnv->toUBytes;
245    byteIndex=cnv->toULength;
246
247    /* sourceIndex=-1 if the current character began in the previous buffer */
248    sourceIndex=byteIndex==0 ? 0 : -1;
249    nextSourceIndex=0;
250
251    if(inDirectMode) {
252directMode:
253        /*
254         * In Direct Mode, most US-ASCII characters are encoded directly, i.e.,
255         * with their US-ASCII byte values.
256         * Backslash and Tilde and most control characters are not allowed in UTF-7.
257         * A plus sign starts Unicode (or "escape") Mode.
258         *
259         * In Direct Mode, only the sourceIndex is used.
260         */
261        byteIndex=0;
262        length=(int32_t)(sourceLimit-source);
263        targetCapacity=(int32_t)(targetLimit-target);
264        if(length>targetCapacity) {
265            length=targetCapacity;
266        }
267        while(length>0) {
268            b=*source++;
269            if(!isLegalUTF7(b)) {
270                /* illegal */
271                bytes[0]=b;
272                byteIndex=1;
273                *pErrorCode=U_ILLEGAL_CHAR_FOUND;
274                break;
275            } else if(b!=PLUS) {
276                /* write directly encoded character */
277                *target++=b;
278                if(offsets!=NULL) {
279                    *offsets++=sourceIndex++;
280                }
281            } else /* PLUS */ {
282                /* switch to Unicode mode */
283                nextSourceIndex=++sourceIndex;
284                inDirectMode=FALSE;
285                byteIndex=0;
286                bits=0;
287                base64Counter=-1;
288                goto unicodeMode;
289            }
290            --length;
291        }
292        if(source<sourceLimit && target>=targetLimit) {
293            /* target is full */
294            *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
295        }
296    } else {
297unicodeMode:
298        /*
299         * In Unicode (or "escape") Mode, UTF-16BE is base64-encoded.
300         * The base64 sequence ends with any character that is not in the base64 alphabet.
301         * A terminating minus sign is consumed.
302         *
303         * In Unicode Mode, the sourceIndex has the index to the start of the current
304         * base64 bytes, while nextSourceIndex is precisely parallel to source,
305         * keeping the index to the following byte.
306         * Note that in 2 out of 3 cases, UChars overlap within a base64 byte.
307         */
308        while(source<sourceLimit) {
309            if(target<targetLimit) {
310                bytes[byteIndex++]=b=*source++;
311                ++nextSourceIndex;
312                base64Value = -3; /* initialize as illegal */
313                if(b>=126 || (base64Value=fromBase64[b])==-3 || base64Value==-1) {
314                    /* either
315                     * base64Value==-1 for any legal character except base64 and minus sign, or
316                     * base64Value==-3 for illegal characters:
317                     * 1. In either case, leave Unicode mode.
318                     * 2.1. If we ended with an incomplete UChar or none after the +, then
319                     *      generate an error for the preceding erroneous sequence and deal with
320                     *      the current (possibly illegal) character next time through.
321                     * 2.2. Else the current char comes after a complete UChar, which was already
322                     *      pushed to the output buf, so:
323                     * 2.2.1. If the current char is legal, just save it for processing next time.
324                     *        It may be for example, a plus which we need to deal with in direct mode.
325                     * 2.2.2. Else if the current char is illegal, we might as well deal with it here.
326                     */
327                    inDirectMode=TRUE;
328                    if(base64Counter==-1) {
329                        /* illegal: + immediately followed by something other than base64 or minus sign */
330                        /* include the plus sign in the reported sequence, but not the subsequent char */
331                        --source;
332                        bytes[0]=PLUS;
333                        byteIndex=1;
334                        *pErrorCode=U_ILLEGAL_CHAR_FOUND;
335                        break;
336                    } else if(bits!=0) {
337                        /* bits are illegally left over, a UChar is incomplete */
338                        /* don't include current char (legal or illegal) in error seq */
339                        --source;
340                        --byteIndex;
341                        *pErrorCode=U_ILLEGAL_CHAR_FOUND;
342                        break;
343                    } else {
344                        /* previous UChar was complete */
345                        if(base64Value==-3) {
346                            /* current character is illegal, deal with it here */
347                            *pErrorCode=U_ILLEGAL_CHAR_FOUND;
348                            break;
349                        } else {
350                            /* un-read the current character in case it is a plus sign */
351                            --source;
352                            sourceIndex=nextSourceIndex-1;
353                            goto directMode;
354                        }
355                    }
356                } else if(base64Value>=0) {
357                    /* collect base64 bytes into UChars */
358                    switch(base64Counter) {
359                    case -1: /* -1 is immediately after the + */
360                    case 0:
361                        bits=base64Value;
362                        base64Counter=1;
363                        break;
364                    case 1:
365                    case 3:
366                    case 4:
367                    case 6:
368                        bits=(uint16_t)((bits<<6)|base64Value);
369                        ++base64Counter;
370                        break;
371                    case 2:
372                        *target++=(UChar)((bits<<4)|(base64Value>>2));
373                        if(offsets!=NULL) {
374                            *offsets++=sourceIndex;
375                            sourceIndex=nextSourceIndex-1;
376                        }
377                        bytes[0]=b; /* keep this byte in case an error occurs */
378                        byteIndex=1;
379                        bits=(uint16_t)(base64Value&3);
380                        base64Counter=3;
381                        break;
382                    case 5:
383                        *target++=(UChar)((bits<<2)|(base64Value>>4));
384                        if(offsets!=NULL) {
385                            *offsets++=sourceIndex;
386                            sourceIndex=nextSourceIndex-1;
387                        }
388                        bytes[0]=b; /* keep this byte in case an error occurs */
389                        byteIndex=1;
390                        bits=(uint16_t)(base64Value&15);
391                        base64Counter=6;
392                        break;
393                    case 7:
394                        *target++=(UChar)((bits<<6)|base64Value);
395                        if(offsets!=NULL) {
396                            *offsets++=sourceIndex;
397                            sourceIndex=nextSourceIndex;
398                        }
399                        byteIndex=0;
400                        bits=0;
401                        base64Counter=0;
402                        break;
403                    default:
404                        /* will never occur */
405                        break;
406                    }
407                } else /*base64Value==-2*/ {
408                    /* minus sign terminates the base64 sequence */
409                    inDirectMode=TRUE;
410                    if(base64Counter==-1) {
411                        /* +- i.e. a minus immediately following a plus */
412                        *target++=PLUS;
413                        if(offsets!=NULL) {
414                            *offsets++=sourceIndex-1;
415                        }
416                    } else {
417                        /* absorb the minus and leave the Unicode Mode */
418                        if(bits!=0) {
419                            /* bits are illegally left over, a UChar is incomplete */
420                            *pErrorCode=U_ILLEGAL_CHAR_FOUND;
421                            break;
422                        }
423                    }
424                    sourceIndex=nextSourceIndex;
425                    goto directMode;
426                }
427            } else {
428                /* target is full */
429                *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
430                break;
431            }
432        }
433    }
434
435    if(U_SUCCESS(*pErrorCode) && pArgs->flush && source==sourceLimit && bits==0) {
436        /*
437         * if we are in Unicode mode, then the byteIndex might not be 0,
438         * but that is ok if bits==0
439         * -> we set byteIndex=0 at the end of the stream to avoid a truncated error
440         * (not true for IMAP-mailbox-name where we must end in direct mode)
441         */
442        byteIndex=0;
443    }
444
445    /* set the converter state back into UConverter */
446    cnv->toUnicodeStatus=((uint32_t)inDirectMode<<24)|((uint32_t)((uint8_t)base64Counter)<<16)|(uint32_t)bits;
447    cnv->toULength=byteIndex;
448
449    /* write back the updated pointers */
450    pArgs->source=(const char *)source;
451    pArgs->target=target;
452    pArgs->offsets=offsets;
453    return;
454}
455
456static void
457_UTF7FromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
458                            UErrorCode *pErrorCode) {
459    UConverter *cnv;
460    const UChar *source, *sourceLimit;
461    uint8_t *target, *targetLimit;
462    int32_t *offsets;
463
464    int32_t length, targetCapacity, sourceIndex;
465    UChar c;
466
467    /* UTF-7 state */
468    const UBool *encodeDirectly;
469    uint8_t bits;
470    int8_t base64Counter;
471    UBool inDirectMode;
472
473    /* set up the local pointers */
474    cnv=pArgs->converter;
475
476    /* set up the local pointers */
477    source=pArgs->source;
478    sourceLimit=pArgs->sourceLimit;
479    target=(uint8_t *)pArgs->target;
480    targetLimit=(uint8_t *)pArgs->targetLimit;
481    offsets=pArgs->offsets;
482
483    /* get the state machine state */
484    {
485        uint32_t status=cnv->fromUnicodeStatus;
486        encodeDirectly= status<0x10000000 ? encodeDirectlyMaximum : encodeDirectlyRestricted;
487        inDirectMode=(UBool)((status>>24)&1);
488        base64Counter=(int8_t)(status>>16);
489        bits=(uint8_t)status;
490        U_ASSERT(bits<=sizeof(toBase64)/sizeof(toBase64[0]));
491    }
492
493    /* UTF-7 always encodes UTF-16 code units, therefore we need only a simple sourceIndex */
494    sourceIndex=0;
495
496    if(inDirectMode) {
497directMode:
498        length=(int32_t)(sourceLimit-source);
499        targetCapacity=(int32_t)(targetLimit-target);
500        if(length>targetCapacity) {
501            length=targetCapacity;
502        }
503        while(length>0) {
504            c=*source++;
505            /* currently always encode CR LF SP TAB directly */
506            if(c<=127 && encodeDirectly[c]) {
507                /* encode directly */
508                *target++=(uint8_t)c;
509                if(offsets!=NULL) {
510                    *offsets++=sourceIndex++;
511                }
512            } else if(c==PLUS) {
513                /* output +- for + */
514                *target++=PLUS;
515                if(target<targetLimit) {
516                    *target++=MINUS;
517                    if(offsets!=NULL) {
518                        *offsets++=sourceIndex;
519                        *offsets++=sourceIndex++;
520                    }
521                    /* realign length and targetCapacity */
522                    goto directMode;
523                } else {
524                    if(offsets!=NULL) {
525                        *offsets++=sourceIndex++;
526                    }
527                    cnv->charErrorBuffer[0]=MINUS;
528                    cnv->charErrorBufferLength=1;
529                    *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
530                    break;
531                }
532            } else {
533                /* un-read this character and switch to Unicode Mode */
534                --source;
535                *target++=PLUS;
536                if(offsets!=NULL) {
537                    *offsets++=sourceIndex;
538                }
539                inDirectMode=FALSE;
540                base64Counter=0;
541                goto unicodeMode;
542            }
543            --length;
544        }
545        if(source<sourceLimit && target>=targetLimit) {
546            /* target is full */
547            *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
548        }
549    } else {
550unicodeMode:
551        while(source<sourceLimit) {
552            if(target<targetLimit) {
553                c=*source++;
554                if(c<=127 && encodeDirectly[c]) {
555                    /* encode directly */
556                    inDirectMode=TRUE;
557
558                    /* trick: back out this character to make this easier */
559                    --source;
560
561                    /* terminate the base64 sequence */
562                    if(base64Counter!=0) {
563                        /* write remaining bits for the previous character */
564                        *target++=toBase64[bits];
565                        if(offsets!=NULL) {
566                            *offsets++=sourceIndex-1;
567                        }
568                    }
569                    if(fromBase64[c]!=-1) {
570                        /* need to terminate with a minus */
571                        if(target<targetLimit) {
572                            *target++=MINUS;
573                            if(offsets!=NULL) {
574                                *offsets++=sourceIndex-1;
575                            }
576                        } else {
577                            cnv->charErrorBuffer[0]=MINUS;
578                            cnv->charErrorBufferLength=1;
579                            *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
580                            break;
581                        }
582                    }
583                    goto directMode;
584                } else {
585                    /*
586                     * base64 this character:
587                     * Output 2 or 3 base64 bytes for the remaining bits of the previous character
588                     * and the bits of this character, each implicitly in UTF-16BE.
589                     *
590                     * Here, bits is an 8-bit variable because only 6 bits need to be kept from one
591                     * character to the next. The actual 2 or 4 bits are shifted to the left edge
592                     * of the 6-bits field 5..0 to make the termination of the base64 sequence easier.
593                     */
594                    switch(base64Counter) {
595                    case 0:
596                        *target++=toBase64[c>>10];
597                        if(target<targetLimit) {
598                            *target++=toBase64[(c>>4)&0x3f];
599                            if(offsets!=NULL) {
600                                *offsets++=sourceIndex;
601                                *offsets++=sourceIndex++;
602                            }
603                        } else {
604                            if(offsets!=NULL) {
605                                *offsets++=sourceIndex++;
606                            }
607                            cnv->charErrorBuffer[0]=toBase64[(c>>4)&0x3f];
608                            cnv->charErrorBufferLength=1;
609                            *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
610                        }
611                        bits=(uint8_t)((c&15)<<2);
612                        base64Counter=1;
613                        break;
614                    case 1:
615                        *target++=toBase64[bits|(c>>14)];
616                        if(target<targetLimit) {
617                            *target++=toBase64[(c>>8)&0x3f];
618                            if(target<targetLimit) {
619                                *target++=toBase64[(c>>2)&0x3f];
620                                if(offsets!=NULL) {
621                                    *offsets++=sourceIndex;
622                                    *offsets++=sourceIndex;
623                                    *offsets++=sourceIndex++;
624                                }
625                            } else {
626                                if(offsets!=NULL) {
627                                    *offsets++=sourceIndex;
628                                    *offsets++=sourceIndex++;
629                                }
630                                cnv->charErrorBuffer[0]=toBase64[(c>>2)&0x3f];
631                                cnv->charErrorBufferLength=1;
632                                *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
633                            }
634                        } else {
635                            if(offsets!=NULL) {
636                                *offsets++=sourceIndex++;
637                            }
638                            cnv->charErrorBuffer[0]=toBase64[(c>>8)&0x3f];
639                            cnv->charErrorBuffer[1]=toBase64[(c>>2)&0x3f];
640                            cnv->charErrorBufferLength=2;
641                            *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
642                        }
643                        bits=(uint8_t)((c&3)<<4);
644                        base64Counter=2;
645                        break;
646                    case 2:
647                        *target++=toBase64[bits|(c>>12)];
648                        if(target<targetLimit) {
649                            *target++=toBase64[(c>>6)&0x3f];
650                            if(target<targetLimit) {
651                                *target++=toBase64[c&0x3f];
652                                if(offsets!=NULL) {
653                                    *offsets++=sourceIndex;
654                                    *offsets++=sourceIndex;
655                                    *offsets++=sourceIndex++;
656                                }
657                            } else {
658                                if(offsets!=NULL) {
659                                    *offsets++=sourceIndex;
660                                    *offsets++=sourceIndex++;
661                                }
662                                cnv->charErrorBuffer[0]=toBase64[c&0x3f];
663                                cnv->charErrorBufferLength=1;
664                                *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
665                            }
666                        } else {
667                            if(offsets!=NULL) {
668                                *offsets++=sourceIndex++;
669                            }
670                            cnv->charErrorBuffer[0]=toBase64[(c>>6)&0x3f];
671                            cnv->charErrorBuffer[1]=toBase64[c&0x3f];
672                            cnv->charErrorBufferLength=2;
673                            *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
674                        }
675                        bits=0;
676                        base64Counter=0;
677                        break;
678                    default:
679                        /* will never occur */
680                        break;
681                    }
682                }
683            } else {
684                /* target is full */
685                *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
686                break;
687            }
688        }
689    }
690
691    if(pArgs->flush && source>=sourceLimit) {
692        /* flush remaining bits to the target */
693        if(!inDirectMode) {
694            if (base64Counter!=0) {
695                if(target<targetLimit) {
696                    *target++=toBase64[bits];
697                    if(offsets!=NULL) {
698                        *offsets++=sourceIndex-1;
699                    }
700                } else {
701                    cnv->charErrorBuffer[cnv->charErrorBufferLength++]=toBase64[bits];
702                    *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
703                }
704            }
705            /* Add final MINUS to terminate unicodeMode */
706            if(target<targetLimit) {
707                *target++=MINUS;
708                if(offsets!=NULL) {
709                    *offsets++=sourceIndex-1;
710                }
711            } else {
712                cnv->charErrorBuffer[cnv->charErrorBufferLength++]=MINUS;
713                *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
714            }
715        }
716        /* reset the state for the next conversion */
717        cnv->fromUnicodeStatus=(cnv->fromUnicodeStatus&0xf0000000)|0x1000000; /* keep version, inDirectMode=TRUE */
718    } else {
719        /* set the converter state back into UConverter */
720        cnv->fromUnicodeStatus=
721            (cnv->fromUnicodeStatus&0xf0000000)|    /* keep version*/
722            ((uint32_t)inDirectMode<<24)|((uint32_t)base64Counter<<16)|(uint32_t)bits;
723    }
724
725    /* write back the updated pointers */
726    pArgs->source=source;
727    pArgs->target=(char *)target;
728    pArgs->offsets=offsets;
729    return;
730}
731
732static const char *
733_UTF7GetName(const UConverter *cnv) {
734    switch(cnv->fromUnicodeStatus>>28) {
735    case 1:
736        return "UTF-7,version=1";
737    default:
738        return "UTF-7";
739    }
740}
741
742static const UConverterImpl _UTF7Impl={
743    UCNV_UTF7,
744
745    NULL,
746    NULL,
747
748    _UTF7Open,
749    NULL,
750    _UTF7Reset,
751
752    _UTF7ToUnicodeWithOffsets,
753    _UTF7ToUnicodeWithOffsets,
754    _UTF7FromUnicodeWithOffsets,
755    _UTF7FromUnicodeWithOffsets,
756    NULL,
757
758    NULL,
759    _UTF7GetName,
760    NULL, /* we don't need writeSub() because we never call a callback at fromUnicode() */
761    NULL,
762    ucnv_getCompleteUnicodeSet
763};
764
765static const UConverterStaticData _UTF7StaticData={
766    sizeof(UConverterStaticData),
767    "UTF-7",
768    0, /* TODO CCSID for UTF-7 */
769    UCNV_IBM, UCNV_UTF7,
770    1, 4,
771    { 0x3f, 0, 0, 0 }, 1, /* the subchar is not used */
772    FALSE, FALSE,
773    0,
774    0,
775    { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
776};
777
778const UConverterSharedData _UTF7Data={
779    sizeof(UConverterSharedData), ~((uint32_t)0),
780    NULL, NULL, &_UTF7StaticData, FALSE, &_UTF7Impl,
781    0
782};
783
784/* IMAP mailbox name encoding ----------------------------------------------- */
785
786/*
787 * RFC 2060: INTERNET MESSAGE ACCESS PROTOCOL - VERSION 4rev1
788 * http://www.ietf.org/rfc/rfc2060.txt
789 *
790 * 5.1.3.  Mailbox International Naming Convention
791 *
792 * By convention, international mailbox names are specified using a
793 * modified version of the UTF-7 encoding described in [UTF-7].  The
794 * purpose of these modifications is to correct the following problems
795 * with UTF-7:
796 *
797 *    1) UTF-7 uses the "+" character for shifting; this conflicts with
798 *       the common use of "+" in mailbox names, in particular USENET
799 *       newsgroup names.
800 *
801 *    2) UTF-7's encoding is BASE64 which uses the "/" character; this
802 *       conflicts with the use of "/" as a popular hierarchy delimiter.
803 *
804 *    3) UTF-7 prohibits the unencoded usage of "\"; this conflicts with
805 *       the use of "\" as a popular hierarchy delimiter.
806 *
807 *    4) UTF-7 prohibits the unencoded usage of "~"; this conflicts with
808 *       the use of "~" in some servers as a home directory indicator.
809 *
810 *    5) UTF-7 permits multiple alternate forms to represent the same
811 *       string; in particular, printable US-ASCII chararacters can be
812 *       represented in encoded form.
813 *
814 * In modified UTF-7, printable US-ASCII characters except for "&"
815 * represent themselves; that is, characters with octet values 0x20-0x25
816 * and 0x27-0x7e.  The character "&" (0x26) is represented by the two-
817 * octet sequence "&-".
818 *
819 * All other characters (octet values 0x00-0x1f, 0x7f-0xff, and all
820 * Unicode 16-bit octets) are represented in modified BASE64, with a
821 * further modification from [UTF-7] that "," is used instead of "/".
822 * Modified BASE64 MUST NOT be used to represent any printing US-ASCII
823 * character which can represent itself.
824 *
825 * "&" is used to shift to modified BASE64 and "-" to shift back to US-
826 * ASCII.  All names start in US-ASCII, and MUST end in US-ASCII (that
827 * is, a name that ends with a Unicode 16-bit octet MUST end with a "-
828 * ").
829 *
830 * For example, here is a mailbox name which mixes English, Japanese,
831 * and Chinese text: ~peter/mail/&ZeVnLIqe-/&U,BTFw-
832 */
833
834/*
835 * Tests for US-ASCII characters belonging to character classes
836 * defined in UTF-7.
837 *
838 * Set D (directly encoded characters) consists of the following
839 * characters: the upper and lower case letters A through Z
840 * and a through z, the 10 digits 0-9, and the following nine special
841 * characters (note that "+" and "=" are omitted):
842 *     '(),-./:?
843 *
844 * Set O (optional direct characters) consists of the following
845 * characters (note that "\" and "~" are omitted):
846 *     !"#$%&*;<=>@[]^_`{|}
847 *
848 * According to the rules in RFC 2152, the byte values for the following
849 * US-ASCII characters are not used in UTF-7 and are therefore illegal:
850 * - all C0 control codes except for CR LF TAB
851 * - BACKSLASH
852 * - TILDE
853 * - DEL
854 * - all codes beyond US-ASCII, i.e. all >127
855 */
856
857/* uses '&' not '+' to start a base64 sequence */
858#define AMPERSAND 0x26
859#define COMMA 0x2c
860#define SLASH 0x2f
861
862/* legal byte values: all US-ASCII graphic characters 0x20..0x7e */
863#define isLegalIMAP(c) (0x20<=(c) && (c)<=0x7e)
864
865/* direct-encode all of printable ASCII 0x20..0x7e except '&' 0x26 */
866#define inSetDIMAP(c) (isLegalIMAP(c) && c!=AMPERSAND)
867
868#define TO_BASE64_IMAP(n) ((n)<63 ? toBase64[n] : COMMA)
869#define FROM_BASE64_IMAP(c) ((c)==COMMA ? 63 : (c)==SLASH ? -1 : fromBase64[c])
870
871/*
872 * converter status values:
873 *
874 * toUnicodeStatus:
875 *     24 inDirectMode (boolean)
876 * 23..16 base64Counter (-1..7)
877 * 15..0  bits (up to 14 bits incoming base64)
878 *
879 * fromUnicodeStatus:
880 *     24 inDirectMode (boolean)
881 * 23..16 base64Counter (0..2)
882 *  7..0  bits (6 bits outgoing base64)
883 *
884 * ignore bits 31..25
885 */
886
887static void
888_IMAPToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
889                          UErrorCode *pErrorCode) {
890    UConverter *cnv;
891    const uint8_t *source, *sourceLimit;
892    UChar *target;
893    const UChar *targetLimit;
894    int32_t *offsets;
895
896    uint8_t *bytes;
897    uint8_t byteIndex;
898
899    int32_t length, targetCapacity;
900
901    /* UTF-7 state */
902    uint16_t bits;
903    int8_t base64Counter;
904    UBool inDirectMode;
905
906    int8_t base64Value;
907
908    int32_t sourceIndex, nextSourceIndex;
909
910    UChar c;
911    uint8_t b;
912
913    /* set up the local pointers */
914    cnv=pArgs->converter;
915
916    source=(const uint8_t *)pArgs->source;
917    sourceLimit=(const uint8_t *)pArgs->sourceLimit;
918    target=pArgs->target;
919    targetLimit=pArgs->targetLimit;
920    offsets=pArgs->offsets;
921    /* get the state machine state */
922    {
923        uint32_t status=cnv->toUnicodeStatus;
924        inDirectMode=(UBool)((status>>24)&1);
925        base64Counter=(int8_t)(status>>16);
926        bits=(uint16_t)status;
927    }
928    bytes=cnv->toUBytes;
929    byteIndex=cnv->toULength;
930
931    /* sourceIndex=-1 if the current character began in the previous buffer */
932    sourceIndex=byteIndex==0 ? 0 : -1;
933    nextSourceIndex=0;
934
935    if(inDirectMode) {
936directMode:
937        /*
938         * In Direct Mode, US-ASCII characters are encoded directly, i.e.,
939         * with their US-ASCII byte values.
940         * An ampersand starts Unicode (or "escape") Mode.
941         *
942         * In Direct Mode, only the sourceIndex is used.
943         */
944        byteIndex=0;
945        length=(int32_t)(sourceLimit-source);
946        targetCapacity=(int32_t)(targetLimit-target);
947        if(length>targetCapacity) {
948            length=targetCapacity;
949        }
950        while(length>0) {
951            b=*source++;
952            if(!isLegalIMAP(b)) {
953                /* illegal */
954                bytes[0]=b;
955                byteIndex=1;
956                *pErrorCode=U_ILLEGAL_CHAR_FOUND;
957                break;
958            } else if(b!=AMPERSAND) {
959                /* write directly encoded character */
960                *target++=b;
961                if(offsets!=NULL) {
962                    *offsets++=sourceIndex++;
963                }
964            } else /* AMPERSAND */ {
965                /* switch to Unicode mode */
966                nextSourceIndex=++sourceIndex;
967                inDirectMode=FALSE;
968                byteIndex=0;
969                bits=0;
970                base64Counter=-1;
971                goto unicodeMode;
972            }
973            --length;
974        }
975        if(source<sourceLimit && target>=targetLimit) {
976            /* target is full */
977            *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
978        }
979    } else {
980unicodeMode:
981        /*
982         * In Unicode (or "escape") Mode, UTF-16BE is base64-encoded.
983         * The base64 sequence ends with any character that is not in the base64 alphabet.
984         * A terminating minus sign is consumed.
985         * US-ASCII must not be base64-ed.
986         *
987         * In Unicode Mode, the sourceIndex has the index to the start of the current
988         * base64 bytes, while nextSourceIndex is precisely parallel to source,
989         * keeping the index to the following byte.
990         * Note that in 2 out of 3 cases, UChars overlap within a base64 byte.
991         */
992        while(source<sourceLimit) {
993            if(target<targetLimit) {
994                bytes[byteIndex++]=b=*source++;
995                ++nextSourceIndex;
996                if(b>0x7e) {
997                    /* illegal - test other illegal US-ASCII values by base64Value==-3 */
998                    inDirectMode=TRUE;
999                    *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1000                    break;
1001                } else if((base64Value=FROM_BASE64_IMAP(b))>=0) {
1002                    /* collect base64 bytes into UChars */
1003                    switch(base64Counter) {
1004                    case -1: /* -1 is immediately after the & */
1005                    case 0:
1006                        bits=base64Value;
1007                        base64Counter=1;
1008                        break;
1009                    case 1:
1010                    case 3:
1011                    case 4:
1012                    case 6:
1013                        bits=(uint16_t)((bits<<6)|base64Value);
1014                        ++base64Counter;
1015                        break;
1016                    case 2:
1017                        c=(UChar)((bits<<4)|(base64Value>>2));
1018                        if(isLegalIMAP(c)) {
1019                            /* illegal */
1020                            inDirectMode=TRUE;
1021                            *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1022                            goto endloop;
1023                        }
1024                        *target++=c;
1025                        if(offsets!=NULL) {
1026                            *offsets++=sourceIndex;
1027                            sourceIndex=nextSourceIndex-1;
1028                        }
1029                        bytes[0]=b; /* keep this byte in case an error occurs */
1030                        byteIndex=1;
1031                        bits=(uint16_t)(base64Value&3);
1032                        base64Counter=3;
1033                        break;
1034                    case 5:
1035                        c=(UChar)((bits<<2)|(base64Value>>4));
1036                        if(isLegalIMAP(c)) {
1037                            /* illegal */
1038                            inDirectMode=TRUE;
1039                            *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1040                            goto endloop;
1041                        }
1042                        *target++=c;
1043                        if(offsets!=NULL) {
1044                            *offsets++=sourceIndex;
1045                            sourceIndex=nextSourceIndex-1;
1046                        }
1047                        bytes[0]=b; /* keep this byte in case an error occurs */
1048                        byteIndex=1;
1049                        bits=(uint16_t)(base64Value&15);
1050                        base64Counter=6;
1051                        break;
1052                    case 7:
1053                        c=(UChar)((bits<<6)|base64Value);
1054                        if(isLegalIMAP(c)) {
1055                            /* illegal */
1056                            inDirectMode=TRUE;
1057                            *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1058                            goto endloop;
1059                        }
1060                        *target++=c;
1061                        if(offsets!=NULL) {
1062                            *offsets++=sourceIndex;
1063                            sourceIndex=nextSourceIndex;
1064                        }
1065                        byteIndex=0;
1066                        bits=0;
1067                        base64Counter=0;
1068                        break;
1069                    default:
1070                        /* will never occur */
1071                        break;
1072                    }
1073                } else if(base64Value==-2) {
1074                    /* minus sign terminates the base64 sequence */
1075                    inDirectMode=TRUE;
1076                    if(base64Counter==-1) {
1077                        /* &- i.e. a minus immediately following an ampersand */
1078                        *target++=AMPERSAND;
1079                        if(offsets!=NULL) {
1080                            *offsets++=sourceIndex-1;
1081                        }
1082                    } else {
1083                        /* absorb the minus and leave the Unicode Mode */
1084                        if(bits!=0 || (base64Counter!=0 && base64Counter!=3 && base64Counter!=6)) {
1085                            /* bits are illegally left over, a UChar is incomplete */
1086                            /* base64Counter other than 0, 3, 6 means non-minimal zero-padding, also illegal */
1087                            *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1088                            break;
1089                        }
1090                    }
1091                    sourceIndex=nextSourceIndex;
1092                    goto directMode;
1093                } else {
1094                    if(base64Counter==-1) {
1095                        /* illegal: & immediately followed by something other than base64 or minus sign */
1096                        /* include the ampersand in the reported sequence */
1097                        --sourceIndex;
1098                        bytes[0]=AMPERSAND;
1099                        bytes[1]=b;
1100                        byteIndex=2;
1101                    }
1102                    /* base64Value==-1 for characters that are illegal only in Unicode mode */
1103                    /* base64Value==-3 for illegal characters */
1104                    /* illegal */
1105                    inDirectMode=TRUE;
1106                    *pErrorCode=U_ILLEGAL_CHAR_FOUND;
1107                    break;
1108                }
1109            } else {
1110                /* target is full */
1111                *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1112                break;
1113            }
1114        }
1115    }
1116endloop:
1117
1118    /*
1119     * the end of the input stream and detection of truncated input
1120     * are handled by the framework, but here we must check if we are in Unicode
1121     * mode and byteIndex==0 because we must end in direct mode
1122     *
1123     * conditions:
1124     *   successful
1125     *   in Unicode mode and byteIndex==0
1126     *   end of input and no truncated input
1127     */
1128    if( U_SUCCESS(*pErrorCode) &&
1129        !inDirectMode && byteIndex==0 &&
1130        pArgs->flush && source>=sourceLimit
1131    ) {
1132        if(base64Counter==-1) {
1133            /* & at the very end of the input */
1134            /* make the ampersand the reported sequence */
1135            bytes[0]=AMPERSAND;
1136            byteIndex=1;
1137        }
1138        /* else if(base64Counter!=-1) byteIndex remains 0 because there is no particular byte sequence */
1139
1140        inDirectMode=TRUE; /* avoid looping */
1141        *pErrorCode=U_TRUNCATED_CHAR_FOUND;
1142    }
1143
1144    /* set the converter state back into UConverter */
1145    cnv->toUnicodeStatus=((uint32_t)inDirectMode<<24)|((uint32_t)((uint8_t)base64Counter)<<16)|(uint32_t)bits;
1146    cnv->toULength=byteIndex;
1147
1148    /* write back the updated pointers */
1149    pArgs->source=(const char *)source;
1150    pArgs->target=target;
1151    pArgs->offsets=offsets;
1152    return;
1153}
1154
1155static void
1156_IMAPFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
1157                            UErrorCode *pErrorCode) {
1158    UConverter *cnv;
1159    const UChar *source, *sourceLimit;
1160    uint8_t *target, *targetLimit;
1161    int32_t *offsets;
1162
1163    int32_t length, targetCapacity, sourceIndex;
1164    UChar c;
1165    uint8_t b;
1166
1167    /* UTF-7 state */
1168    uint8_t bits;
1169    int8_t base64Counter;
1170    UBool inDirectMode;
1171
1172    /* set up the local pointers */
1173    cnv=pArgs->converter;
1174
1175    /* set up the local pointers */
1176    source=pArgs->source;
1177    sourceLimit=pArgs->sourceLimit;
1178    target=(uint8_t *)pArgs->target;
1179    targetLimit=(uint8_t *)pArgs->targetLimit;
1180    offsets=pArgs->offsets;
1181
1182    /* get the state machine state */
1183    {
1184        uint32_t status=cnv->fromUnicodeStatus;
1185        inDirectMode=(UBool)((status>>24)&1);
1186        base64Counter=(int8_t)(status>>16);
1187        bits=(uint8_t)status;
1188    }
1189
1190    /* UTF-7 always encodes UTF-16 code units, therefore we need only a simple sourceIndex */
1191    sourceIndex=0;
1192
1193    if(inDirectMode) {
1194directMode:
1195        length=(int32_t)(sourceLimit-source);
1196        targetCapacity=(int32_t)(targetLimit-target);
1197        if(length>targetCapacity) {
1198            length=targetCapacity;
1199        }
1200        while(length>0) {
1201            c=*source++;
1202            /* encode 0x20..0x7e except '&' directly */
1203            if(inSetDIMAP(c)) {
1204                /* encode directly */
1205                *target++=(uint8_t)c;
1206                if(offsets!=NULL) {
1207                    *offsets++=sourceIndex++;
1208                }
1209            } else if(c==AMPERSAND) {
1210                /* output &- for & */
1211                *target++=AMPERSAND;
1212                if(target<targetLimit) {
1213                    *target++=MINUS;
1214                    if(offsets!=NULL) {
1215                        *offsets++=sourceIndex;
1216                        *offsets++=sourceIndex++;
1217                    }
1218                    /* realign length and targetCapacity */
1219                    goto directMode;
1220                } else {
1221                    if(offsets!=NULL) {
1222                        *offsets++=sourceIndex++;
1223                    }
1224                    cnv->charErrorBuffer[0]=MINUS;
1225                    cnv->charErrorBufferLength=1;
1226                    *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1227                    break;
1228                }
1229            } else {
1230                /* un-read this character and switch to Unicode Mode */
1231                --source;
1232                *target++=AMPERSAND;
1233                if(offsets!=NULL) {
1234                    *offsets++=sourceIndex;
1235                }
1236                inDirectMode=FALSE;
1237                base64Counter=0;
1238                goto unicodeMode;
1239            }
1240            --length;
1241        }
1242        if(source<sourceLimit && target>=targetLimit) {
1243            /* target is full */
1244            *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1245        }
1246    } else {
1247unicodeMode:
1248        while(source<sourceLimit) {
1249            if(target<targetLimit) {
1250                c=*source++;
1251                if(isLegalIMAP(c)) {
1252                    /* encode directly */
1253                    inDirectMode=TRUE;
1254
1255                    /* trick: back out this character to make this easier */
1256                    --source;
1257
1258                    /* terminate the base64 sequence */
1259                    if(base64Counter!=0) {
1260                        /* write remaining bits for the previous character */
1261                        *target++=TO_BASE64_IMAP(bits);
1262                        if(offsets!=NULL) {
1263                            *offsets++=sourceIndex-1;
1264                        }
1265                    }
1266                    /* need to terminate with a minus */
1267                    if(target<targetLimit) {
1268                        *target++=MINUS;
1269                        if(offsets!=NULL) {
1270                            *offsets++=sourceIndex-1;
1271                        }
1272                    } else {
1273                        cnv->charErrorBuffer[0]=MINUS;
1274                        cnv->charErrorBufferLength=1;
1275                        *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1276                        break;
1277                    }
1278                    goto directMode;
1279                } else {
1280                    /*
1281                     * base64 this character:
1282                     * Output 2 or 3 base64 bytes for the remaining bits of the previous character
1283                     * and the bits of this character, each implicitly in UTF-16BE.
1284                     *
1285                     * Here, bits is an 8-bit variable because only 6 bits need to be kept from one
1286                     * character to the next. The actual 2 or 4 bits are shifted to the left edge
1287                     * of the 6-bits field 5..0 to make the termination of the base64 sequence easier.
1288                     */
1289                    switch(base64Counter) {
1290                    case 0:
1291                        b=(uint8_t)(c>>10);
1292                        *target++=TO_BASE64_IMAP(b);
1293                        if(target<targetLimit) {
1294                            b=(uint8_t)((c>>4)&0x3f);
1295                            *target++=TO_BASE64_IMAP(b);
1296                            if(offsets!=NULL) {
1297                                *offsets++=sourceIndex;
1298                                *offsets++=sourceIndex++;
1299                            }
1300                        } else {
1301                            if(offsets!=NULL) {
1302                                *offsets++=sourceIndex++;
1303                            }
1304                            b=(uint8_t)((c>>4)&0x3f);
1305                            cnv->charErrorBuffer[0]=TO_BASE64_IMAP(b);
1306                            cnv->charErrorBufferLength=1;
1307                            *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1308                        }
1309                        bits=(uint8_t)((c&15)<<2);
1310                        base64Counter=1;
1311                        break;
1312                    case 1:
1313                        b=(uint8_t)(bits|(c>>14));
1314                        *target++=TO_BASE64_IMAP(b);
1315                        if(target<targetLimit) {
1316                            b=(uint8_t)((c>>8)&0x3f);
1317                            *target++=TO_BASE64_IMAP(b);
1318                            if(target<targetLimit) {
1319                                b=(uint8_t)((c>>2)&0x3f);
1320                                *target++=TO_BASE64_IMAP(b);
1321                                if(offsets!=NULL) {
1322                                    *offsets++=sourceIndex;
1323                                    *offsets++=sourceIndex;
1324                                    *offsets++=sourceIndex++;
1325                                }
1326                            } else {
1327                                if(offsets!=NULL) {
1328                                    *offsets++=sourceIndex;
1329                                    *offsets++=sourceIndex++;
1330                                }
1331                                b=(uint8_t)((c>>2)&0x3f);
1332                                cnv->charErrorBuffer[0]=TO_BASE64_IMAP(b);
1333                                cnv->charErrorBufferLength=1;
1334                                *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1335                            }
1336                        } else {
1337                            if(offsets!=NULL) {
1338                                *offsets++=sourceIndex++;
1339                            }
1340                            b=(uint8_t)((c>>8)&0x3f);
1341                            cnv->charErrorBuffer[0]=TO_BASE64_IMAP(b);
1342                            b=(uint8_t)((c>>2)&0x3f);
1343                            cnv->charErrorBuffer[1]=TO_BASE64_IMAP(b);
1344                            cnv->charErrorBufferLength=2;
1345                            *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1346                        }
1347                        bits=(uint8_t)((c&3)<<4);
1348                        base64Counter=2;
1349                        break;
1350                    case 2:
1351                        b=(uint8_t)(bits|(c>>12));
1352                        *target++=TO_BASE64_IMAP(b);
1353                        if(target<targetLimit) {
1354                            b=(uint8_t)((c>>6)&0x3f);
1355                            *target++=TO_BASE64_IMAP(b);
1356                            if(target<targetLimit) {
1357                                b=(uint8_t)(c&0x3f);
1358                                *target++=TO_BASE64_IMAP(b);
1359                                if(offsets!=NULL) {
1360                                    *offsets++=sourceIndex;
1361                                    *offsets++=sourceIndex;
1362                                    *offsets++=sourceIndex++;
1363                                }
1364                            } else {
1365                                if(offsets!=NULL) {
1366                                    *offsets++=sourceIndex;
1367                                    *offsets++=sourceIndex++;
1368                                }
1369                                b=(uint8_t)(c&0x3f);
1370                                cnv->charErrorBuffer[0]=TO_BASE64_IMAP(b);
1371                                cnv->charErrorBufferLength=1;
1372                                *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1373                            }
1374                        } else {
1375                            if(offsets!=NULL) {
1376                                *offsets++=sourceIndex++;
1377                            }
1378                            b=(uint8_t)((c>>6)&0x3f);
1379                            cnv->charErrorBuffer[0]=TO_BASE64_IMAP(b);
1380                            b=(uint8_t)(c&0x3f);
1381                            cnv->charErrorBuffer[1]=TO_BASE64_IMAP(b);
1382                            cnv->charErrorBufferLength=2;
1383                            *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1384                        }
1385                        bits=0;
1386                        base64Counter=0;
1387                        break;
1388                    default:
1389                        /* will never occur */
1390                        break;
1391                    }
1392                }
1393            } else {
1394                /* target is full */
1395                *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1396                break;
1397            }
1398        }
1399    }
1400
1401    if(pArgs->flush && source>=sourceLimit) {
1402        /* flush remaining bits to the target */
1403        if(!inDirectMode) {
1404            if(base64Counter!=0) {
1405                if(target<targetLimit) {
1406                    *target++=TO_BASE64_IMAP(bits);
1407                    if(offsets!=NULL) {
1408                        *offsets++=sourceIndex-1;
1409                    }
1410                } else {
1411                    cnv->charErrorBuffer[cnv->charErrorBufferLength++]=TO_BASE64_IMAP(bits);
1412                    *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1413                }
1414            }
1415            /* need to terminate with a minus */
1416            if(target<targetLimit) {
1417                *target++=MINUS;
1418                if(offsets!=NULL) {
1419                    *offsets++=sourceIndex-1;
1420                }
1421            } else {
1422                cnv->charErrorBuffer[cnv->charErrorBufferLength++]=MINUS;
1423                *pErrorCode=U_BUFFER_OVERFLOW_ERROR;
1424            }
1425        }
1426        /* reset the state for the next conversion */
1427        cnv->fromUnicodeStatus=(cnv->fromUnicodeStatus&0xf0000000)|0x1000000; /* keep version, inDirectMode=TRUE */
1428    } else {
1429        /* set the converter state back into UConverter */
1430        cnv->fromUnicodeStatus=
1431            (cnv->fromUnicodeStatus&0xf0000000)|    /* keep version*/
1432            ((uint32_t)inDirectMode<<24)|((uint32_t)base64Counter<<16)|(uint32_t)bits;
1433    }
1434
1435    /* write back the updated pointers */
1436    pArgs->source=source;
1437    pArgs->target=(char *)target;
1438    pArgs->offsets=offsets;
1439    return;
1440}
1441
1442static const UConverterImpl _IMAPImpl={
1443    UCNV_IMAP_MAILBOX,
1444
1445    NULL,
1446    NULL,
1447
1448    _UTF7Open,
1449    NULL,
1450    _UTF7Reset,
1451
1452    _IMAPToUnicodeWithOffsets,
1453    _IMAPToUnicodeWithOffsets,
1454    _IMAPFromUnicodeWithOffsets,
1455    _IMAPFromUnicodeWithOffsets,
1456    NULL,
1457
1458    NULL,
1459    NULL,
1460    NULL, /* we don't need writeSub() because we never call a callback at fromUnicode() */
1461    NULL,
1462    ucnv_getCompleteUnicodeSet
1463};
1464
1465static const UConverterStaticData _IMAPStaticData={
1466    sizeof(UConverterStaticData),
1467    "IMAP-mailbox-name",
1468    0, /* TODO CCSID for IMAP-mailbox-name */
1469    UCNV_IBM, UCNV_IMAP_MAILBOX,
1470    1, 4,
1471    { 0x3f, 0, 0, 0 }, 1, /* the subchar is not used */
1472    FALSE, FALSE,
1473    0,
1474    0,
1475    { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } /* reserved */
1476};
1477
1478const UConverterSharedData _IMAPData={
1479    sizeof(UConverterSharedData), ~((uint32_t)0),
1480    NULL, NULL, &_IMAPStaticData, FALSE, &_IMAPImpl,
1481    0
1482};
1483
1484#endif
1485