Imported Upstream version 0.9.8
[sven/exfat-utils.git] / libexfat / utf.c
1 /*
2         utf.c (13.09.09)
3         exFAT file system implementation library.
4
5         Copyright (C) 2010-2012  Andrew Nayenko
6
7         This program is free software: you can redistribute it and/or modify
8         it under the terms of the GNU General Public License as published by
9         the Free Software Foundation, either version 3 of the License, or
10         (at your option) any later version.
11
12         This program is distributed in the hope that it will be useful,
13         but WITHOUT ANY WARRANTY; without even the implied warranty of
14         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15         GNU General Public License for more details.
16
17         You should have received a copy of the GNU General Public License
18         along with this program.  If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "exfat.h"
22 #include <errno.h>
23
24 static char* wchar_to_utf8(char* output, wchar_t wc, size_t outsize)
25 {
26         if (wc <= 0x7f)
27         {
28                 if (outsize < 1)
29                         return NULL;
30                 *output++ = (char) wc;
31         }
32         else if (wc <= 0x7ff)
33         {
34                 if (outsize < 2)
35                         return NULL;
36                 *output++ = 0xc0 | (wc >> 6);
37                 *output++ = 0x80 | (wc & 0x3f);
38         }
39         else if (wc <= 0xffff)
40         {
41                 if (outsize < 3)
42                         return NULL;
43                 *output++ = 0xe0 | (wc >> 12);
44                 *output++ = 0x80 | ((wc >> 6) & 0x3f);
45                 *output++ = 0x80 | (wc & 0x3f);
46         }
47         else if (wc <= 0x1fffff)
48         {
49                 if (outsize < 4)
50                         return NULL;
51                 *output++ = 0xf0 | (wc >> 18);
52                 *output++ = 0x80 | ((wc >> 12) & 0x3f);
53                 *output++ = 0x80 | ((wc >> 6) & 0x3f);
54                 *output++ = 0x80 | (wc & 0x3f);
55         }
56         else if (wc <= 0x3ffffff)
57         {
58                 if (outsize < 5)
59                         return NULL;
60                 *output++ = 0xf8 | (wc >> 24);
61                 *output++ = 0x80 | ((wc >> 18) & 0x3f);
62                 *output++ = 0x80 | ((wc >> 12) & 0x3f);
63                 *output++ = 0x80 | ((wc >> 6) & 0x3f);
64                 *output++ = 0x80 | (wc & 0x3f);
65         }
66         else if (wc <= 0x7fffffff)
67         {
68                 if (outsize < 6)
69                         return NULL;
70                 *output++ = 0xfc | (wc >> 30);
71                 *output++ = 0x80 | ((wc >> 24) & 0x3f);
72                 *output++ = 0x80 | ((wc >> 18) & 0x3f);
73                 *output++ = 0x80 | ((wc >> 12) & 0x3f);
74                 *output++ = 0x80 | ((wc >> 6) & 0x3f);
75                 *output++ = 0x80 | (wc & 0x3f);
76         }
77         else
78                 return NULL;
79
80         return output;
81 }
82
83 static const le16_t* utf16_to_wchar(const le16_t* input, wchar_t* wc,
84                 size_t insize)
85 {
86         if ((le16_to_cpu(input[0]) & 0xfc00) == 0xd800)
87         {
88                 if (insize < 2 || (le16_to_cpu(input[1]) & 0xfc00) != 0xdc00)
89                         return NULL;
90                 *wc = ((wchar_t) (le16_to_cpu(input[0]) & 0x3ff) << 10);
91                 *wc |= (le16_to_cpu(input[1]) & 0x3ff);
92                 *wc += 0x10000;
93                 return input + 2;
94         }
95         else
96         {
97                 *wc = le16_to_cpu(*input);
98                 return input + 1;
99         }
100 }
101
102 int utf16_to_utf8(char* output, const le16_t* input, size_t outsize,
103                 size_t insize)
104 {
105         const le16_t* inp = input;
106         char* outp = output;
107         wchar_t wc;
108
109         while (inp - input < insize && le16_to_cpu(*inp))
110         {
111                 inp = utf16_to_wchar(inp, &wc, insize - (inp - input));
112                 if (inp == NULL)
113                 {
114                         exfat_error("illegal UTF-16 sequence");
115                         return -EILSEQ;
116                 }
117                 outp = wchar_to_utf8(outp, wc, outsize - (outp - output));
118                 if (outp == NULL)
119                 {
120                         exfat_error("name is too long");
121                         return -ENAMETOOLONG;
122                 }
123         }
124         *outp = '\0';
125         return 0;
126 }
127
128 static const char* utf8_to_wchar(const char* input, wchar_t* wc,
129                 size_t insize)
130 {
131         if ((input[0] & 0x80) == 0 && insize >= 1)
132         {
133                 *wc = (wchar_t) input[0];
134                 return input + 1;
135         }
136         if ((input[0] & 0xe0) == 0xc0 && insize >= 2)
137         {
138                 *wc = (((wchar_t) input[0] & 0x1f) << 6) |
139                        ((wchar_t) input[1] & 0x3f);
140                 return input + 2;
141         }
142         if ((input[0] & 0xf0) == 0xe0 && insize >= 3)
143         {
144                 *wc = (((wchar_t) input[0] & 0x0f) << 12) |
145                       (((wchar_t) input[1] & 0x3f) << 6) |
146                        ((wchar_t) input[2] & 0x3f);
147                 return input + 3;
148         }
149         if ((input[0] & 0xf8) == 0xf0 && insize >= 4)
150         {
151                 *wc = (((wchar_t) input[0] & 0x07) << 18) |
152                       (((wchar_t) input[1] & 0x3f) << 12) |
153                       (((wchar_t) input[2] & 0x3f) << 6) |
154                        ((wchar_t) input[3] & 0x3f);
155                 return input + 4;
156         }
157         if ((input[0] & 0xfc) == 0xf8 && insize >= 5)
158         {
159                 *wc = (((wchar_t) input[0] & 0x03) << 24) |
160                       (((wchar_t) input[1] & 0x3f) << 18) |
161                       (((wchar_t) input[2] & 0x3f) << 12) |
162                       (((wchar_t) input[3] & 0x3f) << 6) |
163                        ((wchar_t) input[4] & 0x3f);
164                 return input + 5;
165         }
166         if ((input[0] & 0xfe) == 0xfc && insize >= 6)
167         {
168                 *wc = (((wchar_t) input[0] & 0x01) << 30) |
169                       (((wchar_t) input[1] & 0x3f) << 24) |
170                       (((wchar_t) input[2] & 0x3f) << 18) |
171                       (((wchar_t) input[3] & 0x3f) << 12) |
172                       (((wchar_t) input[4] & 0x3f) << 6) |
173                        ((wchar_t) input[5] & 0x3f);
174                 return input + 6;
175         }
176         return NULL;
177 }
178
179 static le16_t* wchar_to_utf16(le16_t* output, wchar_t wc, size_t outsize)
180 {
181         if (wc <= 0xffff) /* if character is from BMP */
182         {
183                 if (outsize == 0)
184                         return NULL;
185                 output[0] = cpu_to_le16(wc);
186                 return output + 1;
187         }
188         if (outsize < 2)
189                 return NULL;
190         wc -= 0x10000;
191         output[0] = cpu_to_le16(0xd800 | ((wc >> 10) & 0x3ff));
192         output[1] = cpu_to_le16(0xdc00 | (wc & 0x3ff));
193         return output + 2;
194 }
195
196 int utf8_to_utf16(le16_t* output, const char* input, size_t outsize,
197                 size_t insize)
198 {
199         const char* inp = input;
200         le16_t* outp = output;
201         wchar_t wc;
202
203         while (inp - input < insize && *inp)
204         {
205                 inp = utf8_to_wchar(inp, &wc, insize - (inp - input));
206                 if (inp == NULL)
207                 {
208                         exfat_error("illegal UTF-8 sequence");
209                         return -EILSEQ;
210                 }
211                 outp = wchar_to_utf16(outp, wc, outsize - (outp - output));
212                 if (outp == NULL)
213                 {
214                         exfat_error("name is too long");
215                         return -ENAMETOOLONG;
216                 }
217         }
218         *outp = cpu_to_le16(0);
219         return 0;
220 }
221
222 size_t utf16_length(const le16_t* str)
223 {
224         size_t i = 0;
225
226         while (le16_to_cpu(str[i]))
227                 i++;
228         return i;
229 }