blob: fd16fe96410aa6786ade00f1cdb218bef5faa457 [file] [log] [blame]
bigbiff bigbiff9c754052013-01-09 09:09:08 -05001/*
2 utf.c (13.09.09)
3 exFAT file system implementation library.
4
bigbiff bigbiffca829c42013-01-28 08:14:25 -05005 Copyright (C) 2010-2013 Andrew Nayenko
bigbiff bigbiff9c754052013-01-09 09:09:08 -05006
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
24static 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
83static 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
102int 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
128static 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
179static 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
196int 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
222size_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}