projects/linux·blob master · refs

399 lines · 9.0 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * unicode.c
4 *
5 * PURPOSE
6 * Routines for converting between UTF-8 and OSTA Compressed Unicode.
7 * Also handles filename mangling
8 *
9 * DESCRIPTION
10 * OSTA Compressed Unicode is explained in the OSTA UDF specification.
11 * http://www.osta.org/
12 * UTF-8 is explained in the IETF RFC XXXX.
13 * ftp://ftp.internic.net/rfc/rfcxxxx.txt
14 *
15 */
16
17#include "udfdecl.h"
18
19#include <linux/hex.h>
20#include <linux/kernel.h>
21#include <linux/string.h> /* for memset */
22#include <linux/nls.h>
23#include <linux/crc-itu-t.h>
24#include <linux/slab.h>
25
26#include "udf_sb.h"
27
28#define PLANE_SIZE 0x10000
29#define UNICODE_MAX 0x10ffff
30#define SURROGATE_MASK 0xfffff800
31#define SURROGATE_PAIR 0x0000d800
32#define SURROGATE_LOW 0x00000400
33#define SURROGATE_CHAR_BITS 10
34#define SURROGATE_CHAR_MASK ((1 << SURROGATE_CHAR_BITS) - 1)
35
36#define ILLEGAL_CHAR_MARK '_'
37#define EXT_MARK '.'
38#define CRC_MARK '#'
39#define EXT_SIZE 5
40/* Number of chars we need to store generated CRC to make filename unique */
41#define CRC_LEN 5
42
43static unicode_t get_utf16_char(const uint8_t *str_i, int str_i_max_len,
44 int str_i_idx, int u_ch, unicode_t *ret)
45{
46 unicode_t c;
47 int start_idx = str_i_idx;
48
49 /* Expand OSTA compressed Unicode to Unicode */
50 c = str_i[str_i_idx++];
51 if (u_ch > 1)
52 c = (c << 8) | str_i[str_i_idx++];
53 if ((c & SURROGATE_MASK) == SURROGATE_PAIR) {
54 unicode_t next;
55
56 /* Trailing surrogate char */
57 if (str_i_idx >= str_i_max_len) {
58 c = UNICODE_MAX + 1;
59 goto out;
60 }
61
62 /* Low surrogate must follow the high one... */
63 if (c & SURROGATE_LOW) {
64 c = UNICODE_MAX + 1;
65 goto out;
66 }
67
68 WARN_ON_ONCE(u_ch != 2);
69 next = str_i[str_i_idx++] << 8;
70 next |= str_i[str_i_idx++];
71 if ((next & SURROGATE_MASK) != SURROGATE_PAIR ||
72 !(next & SURROGATE_LOW)) {
73 c = UNICODE_MAX + 1;
74 goto out;
75 }
76
77 c = PLANE_SIZE +
78 ((c & SURROGATE_CHAR_MASK) << SURROGATE_CHAR_BITS) +
79 (next & SURROGATE_CHAR_MASK);
80 }
81out:
82 *ret = c;
83 return str_i_idx - start_idx;
84}
85
86
87static int udf_name_conv_char(uint8_t *str_o, int str_o_max_len,
88 int *str_o_idx,
89 const uint8_t *str_i, int str_i_max_len,
90 int *str_i_idx,
91 int u_ch, int *needsCRC,
92 int (*conv_f)(wchar_t, unsigned char *, int),
93 int translate)
94{
95 unicode_t c;
96 int illChar = 0;
97 int len, gotch = 0;
98
99 while (!gotch && *str_i_idx < str_i_max_len) {
100 if (*str_o_idx >= str_o_max_len) {
101 *needsCRC = 1;
102 return gotch;
103 }
104
105 len = get_utf16_char(str_i, str_i_max_len, *str_i_idx, u_ch,
106 &c);
107 /* These chars cannot be converted. Replace them. */
108 if (c == 0 || c > UNICODE_MAX || (conv_f && c > MAX_WCHAR_T) ||
109 (translate && c == '/')) {
110 illChar = 1;
111 if (!translate)
112 gotch = 1;
113 } else if (illChar)
114 break;
115 else
116 gotch = 1;
117 *str_i_idx += len;
118 }
119 if (illChar) {
120 *needsCRC = 1;
121 c = ILLEGAL_CHAR_MARK;
122 gotch = 1;
123 }
124 if (gotch) {
125 if (conv_f) {
126 len = conv_f(c, &str_o[*str_o_idx],
127 str_o_max_len - *str_o_idx);
128 } else {
129 len = utf32_to_utf8(c, &str_o[*str_o_idx],
130 str_o_max_len - *str_o_idx);
131 if (len < 0)
132 len = -ENAMETOOLONG;
133 }
134 /* Valid character? */
135 if (len >= 0)
136 *str_o_idx += len;
137 else if (len == -ENAMETOOLONG) {
138 *needsCRC = 1;
139 gotch = 0;
140 } else {
141 str_o[(*str_o_idx)++] = ILLEGAL_CHAR_MARK;
142 *needsCRC = 1;
143 }
144 }
145 return gotch;
146}
147
148static int udf_name_from_CS0(struct super_block *sb,
149 uint8_t *str_o, int str_max_len,
150 const uint8_t *ocu, int ocu_len,
151 int translate)
152{
153 uint32_t c;
154 uint8_t cmp_id;
155 int idx, len;
156 int u_ch;
157 int needsCRC = 0;
158 int ext_i_len, ext_max_len;
159 int str_o_len = 0; /* Length of resulting output */
160 int ext_o_len = 0; /* Extension output length */
161 int ext_crc_len = 0; /* Extension output length if used with CRC */
162 int i_ext = -1; /* Extension position in input buffer */
163 int o_crc = 0; /* Rightmost possible output pos for CRC+ext */
164 unsigned short valueCRC;
165 uint8_t ext[EXT_SIZE * NLS_MAX_CHARSET_SIZE + 1];
166 uint8_t crc[CRC_LEN];
167 int (*conv_f)(wchar_t, unsigned char *, int);
168
169 if (str_max_len <= 0)
170 return 0;
171
172 if (ocu_len == 0) {
173 memset(str_o, 0, str_max_len);
174 return 0;
175 }
176
177 if (UDF_SB(sb)->s_nls_map)
178 conv_f = UDF_SB(sb)->s_nls_map->uni2char;
179 else
180 conv_f = NULL;
181
182 cmp_id = ocu[0];
183 if (cmp_id != 8 && cmp_id != 16) {
184 memset(str_o, 0, str_max_len);
185 pr_err("unknown compression code (%u)\n", cmp_id);
186 return -EINVAL;
187 }
188 u_ch = cmp_id >> 3;
189
190 ocu++;
191 ocu_len--;
192
193 if (ocu_len % u_ch) {
194 pr_err("incorrect filename length (%d)\n", ocu_len + 1);
195 return -EINVAL;
196 }
197
198 if (translate) {
199 /* Look for extension */
200 for (idx = ocu_len - u_ch, ext_i_len = 0;
201 (idx >= 0) && (ext_i_len < EXT_SIZE);
202 idx -= u_ch, ext_i_len++) {
203 c = ocu[idx];
204 if (u_ch > 1)
205 c = (c << 8) | ocu[idx + 1];
206
207 if (c == EXT_MARK) {
208 if (ext_i_len)
209 i_ext = idx;
210 break;
211 }
212 }
213 if (i_ext >= 0) {
214 /* Convert extension */
215 ext_max_len = min_t(int, sizeof(ext), str_max_len);
216 ext[ext_o_len++] = EXT_MARK;
217 idx = i_ext + u_ch;
218 while (udf_name_conv_char(ext, ext_max_len, &ext_o_len,
219 ocu, ocu_len, &idx,
220 u_ch, &needsCRC,
221 conv_f, translate)) {
222 if ((ext_o_len + CRC_LEN) < str_max_len)
223 ext_crc_len = ext_o_len;
224 }
225 }
226 }
227
228 idx = 0;
229 while (1) {
230 if (translate && (idx == i_ext)) {
231 if (str_o_len > (str_max_len - ext_o_len))
232 needsCRC = 1;
233 break;
234 }
235
236 if (!udf_name_conv_char(str_o, str_max_len, &str_o_len,
237 ocu, ocu_len, &idx,
238 u_ch, &needsCRC, conv_f, translate))
239 break;
240
241 if (translate &&
242 (str_o_len <= (str_max_len - ext_o_len - CRC_LEN)))
243 o_crc = str_o_len;
244 }
245
246 if (translate) {
247 if (str_o_len > 0 && str_o_len <= 2 && str_o[0] == '.' &&
248 (str_o_len == 1 || str_o[1] == '.'))
249 needsCRC = 1;
250 if (needsCRC) {
251 str_o_len = o_crc;
252 valueCRC = crc_itu_t(0, ocu, ocu_len);
253 crc[0] = CRC_MARK;
254 crc[1] = hex_asc_upper_hi(valueCRC >> 8);
255 crc[2] = hex_asc_upper_lo(valueCRC >> 8);
256 crc[3] = hex_asc_upper_hi(valueCRC);
257 crc[4] = hex_asc_upper_lo(valueCRC);
258 len = min_t(int, CRC_LEN, str_max_len - str_o_len);
259 memcpy(&str_o[str_o_len], crc, len);
260 str_o_len += len;
261 ext_o_len = ext_crc_len;
262 }
263 if (ext_o_len > 0) {
264 memcpy(&str_o[str_o_len], ext, ext_o_len);
265 str_o_len += ext_o_len;
266 }
267 }
268
269 return str_o_len;
270}
271
272static int udf_name_to_CS0(struct super_block *sb,
273 uint8_t *ocu, int ocu_max_len,
274 const uint8_t *str_i, int str_len)
275{
276 int i, len;
277 unsigned int max_val;
278 int u_len, u_ch;
279 unicode_t uni_char;
280 int (*conv_f)(const unsigned char *, int, wchar_t *);
281
282 if (ocu_max_len <= 0)
283 return 0;
284
285 if (UDF_SB(sb)->s_nls_map)
286 conv_f = UDF_SB(sb)->s_nls_map->char2uni;
287 else
288 conv_f = NULL;
289
290 memset(ocu, 0, ocu_max_len);
291 ocu[0] = 8;
292 max_val = 0xff;
293 u_ch = 1;
294
295try_again:
296 u_len = 1;
297 for (i = 0; i < str_len; i += len) {
298 /* Name didn't fit? */
299 if (u_len + u_ch > ocu_max_len)
300 return 0;
301 if (conv_f) {
302 wchar_t wchar;
303
304 len = conv_f(&str_i[i], str_len - i, &wchar);
305 if (len > 0)
306 uni_char = wchar;
307 } else {
308 len = utf8_to_utf32(&str_i[i], str_len - i,
309 &uni_char);
310 }
311 /* Invalid character, deal with it */
312 if (len <= 0 || uni_char > UNICODE_MAX) {
313 len = 1;
314 uni_char = '?';
315 }
316
317 if (uni_char > max_val) {
318 unicode_t c;
319
320 if (max_val == 0xff) {
321 max_val = 0xffff;
322 ocu[0] = 0x10;
323 u_ch = 2;
324 goto try_again;
325 }
326 /*
327 * Use UTF-16 encoding for chars outside we
328 * cannot encode directly.
329 */
330 if (u_len + 2 * u_ch > ocu_max_len)
331 return 0;
332
333 uni_char -= PLANE_SIZE;
334 c = SURROGATE_PAIR |
335 ((uni_char >> SURROGATE_CHAR_BITS) &
336 SURROGATE_CHAR_MASK);
337 ocu[u_len++] = (uint8_t)(c >> 8);
338 ocu[u_len++] = (uint8_t)(c & 0xff);
339 uni_char = SURROGATE_PAIR | SURROGATE_LOW |
340 (uni_char & SURROGATE_CHAR_MASK);
341 }
342
343 if (max_val == 0xffff)
344 ocu[u_len++] = (uint8_t)(uni_char >> 8);
345 ocu[u_len++] = (uint8_t)(uni_char & 0xff);
346 }
347
348 return u_len;
349}
350
351/*
352 * Convert CS0 dstring to output charset. Warning: This function may truncate
353 * input string if it is too long as it is used for informational strings only
354 * and it is better to truncate the string than to refuse mounting a media.
355 */
356int udf_dstrCS0toChar(struct super_block *sb, uint8_t *utf_o, int o_len,
357 const uint8_t *ocu_i, int i_len)
358{
359 int s_len = 0;
360
361 if (i_len > 0) {
362 s_len = ocu_i[i_len - 1];
363 if (s_len >= i_len) {
364 pr_warn("incorrect dstring lengths (%d/%d),"
365 " truncating\n", s_len, i_len);
366 s_len = i_len - 1;
367 /* 2-byte encoding? Need to round properly... */
368 if (ocu_i[0] == 16)
369 s_len -= (s_len - 1) & 2;
370 }
371 }
372
373 return udf_name_from_CS0(sb, utf_o, o_len, ocu_i, s_len, 0);
374}
375
376int udf_get_filename(struct super_block *sb, const uint8_t *sname, int slen,
377 uint8_t *dname, int dlen)
378{
379 int ret;
380
381 if (!slen)
382 return -EIO;
383
384 if (dlen <= 0)
385 return 0;
386
387 ret = udf_name_from_CS0(sb, dname, dlen, sname, slen, 1);
388 /* Zero length filename isn't valid... */
389 if (ret == 0)
390 ret = -EINVAL;
391 return ret;
392}
393
394int udf_put_filename(struct super_block *sb, const uint8_t *sname, int slen,
395 uint8_t *dname, int dlen)
396{
397 return udf_name_to_CS0(sb, dname, dlen, sname, slen);
398}
399