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