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