1/*
2 * Copyright (c) 2004, 2006, 2007, 2008 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 *
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 *
17 * 3. Neither the name of the Institute nor the names of its contributors
18 *    may be used to endorse or promote products derived from this software
19 *    without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34#include <config.h>
35#include "windlocl.h"
36
37static int
38utf8toutf32(const unsigned char **pp, uint32_t *out)
39{
40    const unsigned char *p = *pp;
41    unsigned c = *p;
42
43    if (c & 0x80) {
44	if ((c & 0xE0) == 0xC0) {
45	    const unsigned c2 = *++p;
46	    if ((c2 & 0xC0) == 0x80) {
47		*out =  ((c  & 0x1F) << 6)
48		    | (c2 & 0x3F);
49	    } else {
50		return WIND_ERR_INVALID_UTF8;
51	    }
52	} else if ((c & 0xF0) == 0xE0) {
53	    const unsigned c2 = *++p;
54	    if ((c2 & 0xC0) == 0x80) {
55		const unsigned c3 = *++p;
56		if ((c3 & 0xC0) == 0x80) {
57		    *out =   ((c  & 0x0F) << 12)
58			| ((c2 & 0x3F) << 6)
59			|  (c3 & 0x3F);
60		} else {
61		    return WIND_ERR_INVALID_UTF8;
62		}
63	    } else {
64		return WIND_ERR_INVALID_UTF8;
65	    }
66	} else if ((c & 0xF8) == 0xF0) {
67	    const unsigned c2 = *++p;
68	    if ((c2 & 0xC0) == 0x80) {
69		const unsigned c3 = *++p;
70		if ((c3 & 0xC0) == 0x80) {
71		    const unsigned c4 = *++p;
72		    if ((c4 & 0xC0) == 0x80) {
73			*out =   ((c  & 0x07) << 18)
74			    | ((c2 & 0x3F) << 12)
75			    | ((c3 & 0x3F) <<  6)
76			    |  (c4 & 0x3F);
77		    } else {
78			return WIND_ERR_INVALID_UTF8;
79		    }
80		} else {
81		    return WIND_ERR_INVALID_UTF8;
82		}
83	    } else {
84		return WIND_ERR_INVALID_UTF8;
85	    }
86	} else {
87	    return WIND_ERR_INVALID_UTF8;
88	}
89    } else {
90	*out = c;
91    }
92
93    *pp = p;
94
95    return 0;
96}
97
98/**
99 * Convert an UTF-8 string to an UCS4 string.
100 *
101 * @param in an UTF-8 string to convert.
102 * @param out the resulting UCS4 strint, must be at least
103 * wind_utf8ucs4_length() long.  If out is NULL, the function will
104 * calculate the needed space for the out variable (just like
105 * wind_utf8ucs4_length()).
106 * @param out_len before processing out_len should be the length of
107 * the out variable, after processing it will be the length of the out
108 * string.
109 *
110 * @return returns 0 on success, an wind error code otherwise
111 * @ingroup wind
112 */
113
114int
115wind_utf8ucs4(const char *in, uint32_t *out, size_t *out_len)
116{
117    const unsigned char *p;
118    size_t o = 0;
119    int ret;
120
121    for (p = (const unsigned char *)in; *p != '\0'; ++p) {
122	uint32_t u;
123
124	ret = utf8toutf32(&p, &u);
125	if (ret)
126	    return ret;
127
128	if (out) {
129	    if (o >= *out_len)
130		return WIND_ERR_OVERRUN;
131	    out[o] = u;
132	}
133	o++;
134    }
135    *out_len = o;
136    return 0;
137}
138
139/**
140 * Calculate the length of from converting a UTF-8 string to a UCS4
141 * string.
142 *
143 * @param in an UTF-8 string to convert.
144 * @param out_len the length of the resulting UCS4 string.
145 *
146 * @return returns 0 on success, an wind error code otherwise
147 * @ingroup wind
148 */
149
150int
151wind_utf8ucs4_length(const char *in, size_t *out_len)
152{
153    return wind_utf8ucs4(in, NULL, out_len);
154}
155
156static const char first_char[4] =
157    { 0x00, 0xC0, 0xE0, 0xF0 };
158
159/**
160 * Convert an UCS4 string to a UTF-8 string.
161 *
162 * @param in an UCS4 string to convert.
163 * @param in_len the length input array.
164
165 * @param out the resulting UTF-8 strint, must be at least
166 * wind_ucs4utf8_length() + 1 long (the extra char for the NUL).  If
167 * out is NULL, the function will calculate the needed space for the
168 * out variable (just like wind_ucs4utf8_length()).
169
170 * @param out_len before processing out_len should be the length of
171 * the out variable, after processing it will be the length of the out
172 * string.
173 *
174 * @return returns 0 on success, an wind error code otherwise
175 * @ingroup wind
176 */
177
178int
179wind_ucs4utf8(const uint32_t *in, size_t in_len, char *out, size_t *out_len)
180{
181    uint32_t ch;
182    size_t i, len, o;
183
184    for (o = 0, i = 0; i < in_len; i++) {
185	ch = in[i];
186
187	if (ch < 0x80) {
188	    len = 1;
189	} else if (ch < 0x800) {
190	    len = 2;
191	} else if (ch < 0x10000) {
192	    len = 3;
193	} else if (ch <= 0x10FFFF) {
194	    len = 4;
195	} else
196	    return WIND_ERR_INVALID_UTF32;
197
198	o += len;
199
200	if (out) {
201	    if (o >= *out_len)
202		return WIND_ERR_OVERRUN;
203
204	    switch(len) {
205	    case 4:
206		out[3] = (ch | 0x80) & 0xbf;
207		ch = ch >> 6;
208	    case 3:
209		out[2] = (ch | 0x80) & 0xbf;
210		ch = ch >> 6;
211	    case 2:
212		out[1] = (ch | 0x80) & 0xbf;
213		ch = ch >> 6;
214	    case 1:
215		out[0] = ch | first_char[len - 1];
216	    }
217	}
218	out += len;
219    }
220    if (out) {
221	if (o + 1 >= *out_len)
222	    return WIND_ERR_OVERRUN;
223	*out = '\0';
224    }
225    *out_len = o;
226    return 0;
227}
228
229/**
230 * Calculate the length of from converting a UCS4 string to an UTF-8 string.
231 *
232 * @param in an UCS4 string to convert.
233 * @param in_len the length of UCS4 string to convert.
234 * @param out_len the length of the resulting UTF-8 string.
235 *
236 * @return returns 0 on success, an wind error code otherwise
237 * @ingroup wind
238 */
239
240int
241wind_ucs4utf8_length(const uint32_t *in, size_t in_len, size_t *out_len)
242{
243    return wind_ucs4utf8(in, in_len, NULL, out_len);
244}
245
246/**
247 * Read in an UCS2 from a buffer.
248 *
249 * @param ptr The input buffer to read from.
250 * @param len the length of the input buffer.
251 * @param flags Flags to control the behavior of the function.
252 * @param out the output UCS2, the array must be at least out/2 long.
253 * @param out_len the output length
254 *
255 * @return returns 0 on success, an wind error code otherwise.
256 * @ingroup wind
257 */
258
259int
260wind_ucs2read(const void *ptr, size_t len, unsigned int *flags,
261	      uint16_t *out, size_t *out_len)
262{
263    const unsigned char *p = ptr;
264    int little = ((*flags) & WIND_RW_LE);
265    size_t olen = *out_len;
266
267    /** if len is zero, flags are unchanged */
268    if (len == 0) {
269	*out_len = 0;
270	return 0;
271    }
272
273    /** if len is odd, WIND_ERR_LENGTH_NOT_MOD2 is returned */
274    if (len & 1)
275	return WIND_ERR_LENGTH_NOT_MOD2;
276
277    /**
278     * If the flags WIND_RW_BOM is set, check for BOM. If not BOM is
279     * found, check is LE/BE flag is already and use that otherwise
280     * fail with WIND_ERR_NO_BOM. When done, clear WIND_RW_BOM and
281     * the LE/BE flag and set the resulting LE/BE flag.
282     */
283    if ((*flags) & WIND_RW_BOM) {
284	uint16_t bom = (p[0] << 8) + p[1];
285	if (bom == 0xfffe || bom == 0xfeff) {
286	    little = (bom == 0xfffe);
287	    p += 2;
288	    len -= 2;
289	} else if (((*flags) & (WIND_RW_LE|WIND_RW_BE)) != 0) {
290	    /* little already set */
291	} else
292	    return WIND_ERR_NO_BOM;
293	*flags = ((*flags) & ~(WIND_RW_BOM|WIND_RW_LE|WIND_RW_BE));
294	*flags |= little ? WIND_RW_LE : WIND_RW_BE;
295    }
296
297    while (len) {
298	if (olen < 1)
299	    return WIND_ERR_OVERRUN;
300	if (little)
301	    *out = (p[1] << 8) + p[0];
302	else
303	    *out = (p[0] << 8) + p[1];
304	out++; p += 2; len -= 2; olen--;
305    }
306    *out_len -= olen;
307    return 0;
308}
309
310/**
311 * Write an UCS2 string to a buffer.
312 *
313 * @param in The input UCS2 string.
314 * @param in_len the length of the input buffer.
315 * @param flags Flags to control the behavior of the function.
316 * @param ptr The input buffer to write to, the array must be at least
317 * (in + 1) * 2 bytes long.
318 * @param out_len the output length
319 *
320 * @return returns 0 on success, an wind error code otherwise.
321 * @ingroup wind
322 */
323
324int
325wind_ucs2write(const uint16_t *in, size_t in_len, unsigned int *flags,
326	       void *ptr, size_t *out_len)
327{
328    unsigned char *p = ptr;
329    size_t len = *out_len;
330
331    /** If in buffer is not of length be mod 2, WIND_ERR_LENGTH_NOT_MOD2 is returned*/
332    if (len & 1)
333	return WIND_ERR_LENGTH_NOT_MOD2;
334
335    /** On zero input length, flags are preserved */
336    if (in_len == 0) {
337	*out_len = 0;
338	return 0;
339    }
340    /** If flags have WIND_RW_BOM set, the byte order mark is written
341     * first to the output data */
342    if ((*flags) & WIND_RW_BOM) {
343	uint16_t bom = 0xfffe;
344
345	if (len < 2)
346	    return WIND_ERR_OVERRUN;
347
348	if ((*flags) & WIND_RW_LE) {
349	    p[0] = (bom     ) & 0xff;
350	    p[1] = (bom >> 8) & 0xff;
351	} else {
352	    p[1] = (bom     ) & 0xff;
353	    p[0] = (bom >> 8) & 0xff;
354	}
355	len -= 2;
356    }
357
358    while (in_len) {
359	/** If the output wont fit into out_len, WIND_ERR_OVERRUN is returned */
360	if (len < 2)
361	    return WIND_ERR_OVERRUN;
362	if ((*flags) & WIND_RW_LE) {
363	    p[0] = (in[0]     ) & 0xff;
364	    p[1] = (in[0] >> 8) & 0xff;
365	} else {
366	    p[1] = (in[0]     ) & 0xff;
367	    p[0] = (in[0] >> 8) & 0xff;
368	}
369	len -= 2;
370	in_len--;
371	p += 2;
372	in++;
373    }
374    *out_len -= len;
375    return 0;
376}
377
378
379/**
380 * Convert an UTF-8 string to an UCS2 string.
381 *
382 * @param in an UTF-8 string to convert.
383 * @param out the resulting UCS2 strint, must be at least
384 * wind_utf8ucs2_length() long.  If out is NULL, the function will
385 * calculate the needed space for the out variable (just like
386 * wind_utf8ucs2_length()).
387 * @param out_len before processing out_len should be the length of
388 * the out variable, after processing it will be the length of the out
389 * string.
390 *
391 * @return returns 0 on success, an wind error code otherwise
392 * @ingroup wind
393 */
394
395int
396wind_utf8ucs2(const char *in, uint16_t *out, size_t *out_len)
397{
398    const unsigned char *p;
399    size_t o = 0;
400    int ret;
401
402    for (p = (const unsigned char *)in; *p != '\0'; ++p) {
403	uint32_t u;
404
405	ret = utf8toutf32(&p, &u);
406	if (ret)
407	    return ret;
408
409	if (u & 0xffff0000)
410	    return WIND_ERR_NOT_UTF16;
411
412	if (out) {
413	    if (o >= *out_len)
414		return WIND_ERR_OVERRUN;
415	    out[o] = u;
416	}
417	o++;
418    }
419    *out_len = o;
420    return 0;
421}
422
423/**
424 * Calculate the length of from converting a UTF-8 string to a UCS2
425 * string.
426 *
427 * @param in an UTF-8 string to convert.
428 * @param out_len the length of the resulting UCS4 string.
429 *
430 * @return returns 0 on success, an wind error code otherwise
431 * @ingroup wind
432 */
433
434int
435wind_utf8ucs2_length(const char *in, size_t *out_len)
436{
437    return wind_utf8ucs2(in, NULL, out_len);
438}
439
440/**
441 * Convert an UCS2 string to a UTF-8 string.
442 *
443 * @param in an UCS2 string to convert.
444 * @param in_len the length of the in UCS2 string.
445 * @param out the resulting UTF-8 strint, must be at least
446 * wind_ucs2utf8_length() long.  If out is NULL, the function will
447 * calculate the needed space for the out variable (just like
448 * wind_ucs2utf8_length()).
449 * @param out_len before processing out_len should be the length of
450 * the out variable, after processing it will be the length of the out
451 * string.
452 *
453 * @return returns 0 on success, an wind error code otherwise
454 * @ingroup wind
455 */
456
457int
458wind_ucs2utf8(const uint16_t *in, size_t in_len, char *out, size_t *out_len)
459{
460    uint16_t ch;
461    size_t i, len, o;
462
463    for (o = 0, i = 0; i < in_len; i++) {
464	ch = in[i];
465
466	if (ch < 0x80) {
467	    len = 1;
468	} else if (ch < 0x800) {
469	    len = 2;
470	} else
471	    len = 3;
472
473	o += len;
474
475	if (out) {
476	    if (o >= *out_len)
477		return WIND_ERR_OVERRUN;
478
479	    switch(len) {
480	    case 3:
481		out[2] = (ch | 0x80) & 0xbf;
482		ch = ch >> 6;
483	    case 2:
484		out[1] = (ch | 0x80) & 0xbf;
485		ch = ch >> 6;
486	    case 1:
487		out[0] = ch | first_char[len - 1];
488	    }
489	    out += len;
490	}
491    }
492    if (out) {
493	if (o >= *out_len)
494	    return WIND_ERR_OVERRUN;
495	*out = '\0';
496    }
497    *out_len = o;
498    return 0;
499}
500
501/**
502 * Calculate the length of from converting a UCS2 string to an UTF-8 string.
503 *
504 * @param in an UCS2 string to convert.
505 * @param in_len an UCS2 string length to convert.
506 * @param out_len the length of the resulting UTF-8 string.
507 *
508 * @return returns 0 on success, an wind error code otherwise
509 * @ingroup wind
510 */
511
512int
513wind_ucs2utf8_length(const uint16_t *in, size_t in_len, size_t *out_len)
514{
515    return wind_ucs2utf8(in, in_len, NULL, out_len);
516}
517