// SPDX-License-Identifier: GPL-2.0-only/* * unicode.c * * PURPOSE *	Routines for converting between UTF-8 and OSTA Compressed Unicode. *      Also handles filename mangling * * DESCRIPTION *	OSTA Compressed Unicode is explained in the OSTA UDF specification. *		http://www.osta.org/ *	UTF-8 is explained in the IETF RFC XXXX. *		ftp://ftp.internic.net/rfc/rfcxxxx.txt * */ #include "udfdecl.h" #include <linux/hex.h>#include <linux/kernel.h>#include <linux/string.h>	/* for memset */#include <linux/nls.h>#include <linux/crc-itu-t.h>#include <linux/slab.h> #include "udf_sb.h" #define PLANE_SIZE 0x10000#define UNICODE_MAX 0x10ffff#define SURROGATE_MASK 0xfffff800#define SURROGATE_PAIR 0x0000d800#define SURROGATE_LOW  0x00000400#define SURROGATE_CHAR_BITS 10#define SURROGATE_CHAR_MASK ((1 << SURROGATE_CHAR_BITS) - 1) #define ILLEGAL_CHAR_MARK	'_'#define EXT_MARK		'.'#define CRC_MARK		'#'#define EXT_SIZE		5/* Number of chars we need to store generated CRC to make filename unique */#define CRC_LEN			5 static unicode_t get_utf16_char(const uint8_t *str_i, int str_i_max_len,				int str_i_idx, int u_ch, unicode_t *ret){	unicode_t c;	int start_idx = str_i_idx; 	/* Expand OSTA compressed Unicode to Unicode */	c = str_i[str_i_idx++];	if (u_ch > 1)		c = (c << 8) | str_i[str_i_idx++];	if ((c & SURROGATE_MASK) == SURROGATE_PAIR) {		unicode_t next; 		/* Trailing surrogate char */		if (str_i_idx >= str_i_max_len) {			c = UNICODE_MAX + 1;			goto out;		} 		/* Low surrogate must follow the high one... */		if (c & SURROGATE_LOW) {			c = UNICODE_MAX + 1;			goto out;		} 		WARN_ON_ONCE(u_ch != 2);		next = str_i[str_i_idx++] << 8;		next |= str_i[str_i_idx++];		if ((next & SURROGATE_MASK) != SURROGATE_PAIR ||		    !(next & SURROGATE_LOW)) {			c = UNICODE_MAX + 1;			goto out;		} 		c = PLANE_SIZE +		    ((c & SURROGATE_CHAR_MASK) << SURROGATE_CHAR_BITS) +		    (next & SURROGATE_CHAR_MASK);	}out:	*ret = c;	return str_i_idx - start_idx;}  static int udf_name_conv_char(uint8_t *str_o, int str_o_max_len,			      int *str_o_idx,			      const uint8_t *str_i, int str_i_max_len,			      int *str_i_idx,			      int u_ch, int *needsCRC,			      int (*conv_f)(wchar_t, unsigned char *, int),			      int translate){	unicode_t c;	int illChar = 0;	int len, gotch = 0; 	while (!gotch && *str_i_idx < str_i_max_len) {		if (*str_o_idx >= str_o_max_len) {			*needsCRC = 1;			return gotch;		} 		len = get_utf16_char(str_i, str_i_max_len, *str_i_idx, u_ch,				     &c);		/* These chars cannot be converted. Replace them. */		if (c == 0 || c > UNICODE_MAX || (conv_f && c > MAX_WCHAR_T) ||		    (translate && c == '/')) {			illChar = 1;			if (!translate)				gotch = 1;		} else if (illChar)			break;		else			gotch = 1;		*str_i_idx += len;	}	if (illChar) {		*needsCRC = 1;		c = ILLEGAL_CHAR_MARK;		gotch = 1;	}	if (gotch) {		if (conv_f) {			len = conv_f(c, &str_o[*str_o_idx],				     str_o_max_len - *str_o_idx);		} else {			len = utf32_to_utf8(c, &str_o[*str_o_idx],					    str_o_max_len - *str_o_idx);			if (len < 0)				len = -ENAMETOOLONG;		}		/* Valid character? */		if (len >= 0)			*str_o_idx += len;		else if (len == -ENAMETOOLONG) {			*needsCRC = 1;			gotch = 0;		} else {			str_o[(*str_o_idx)++] = ILLEGAL_CHAR_MARK;			*needsCRC = 1;		}	}	return gotch;} static int udf_name_from_CS0(struct super_block *sb,			     uint8_t *str_o, int str_max_len,			     const uint8_t *ocu, int ocu_len,			     int translate){	uint32_t c;	uint8_t cmp_id;	int idx, len;	int u_ch;	int needsCRC = 0;	int ext_i_len, ext_max_len;	int str_o_len = 0;	/* Length of resulting output */	int ext_o_len = 0;	/* Extension output length */	int ext_crc_len = 0;	/* Extension output length if used with CRC */	int i_ext = -1;		/* Extension position in input buffer */	int o_crc = 0;		/* Rightmost possible output pos for CRC+ext */	unsigned short valueCRC;	uint8_t ext[EXT_SIZE * NLS_MAX_CHARSET_SIZE + 1];	uint8_t crc[CRC_LEN];	int (*conv_f)(wchar_t, unsigned char *, int); 	if (str_max_len <= 0)		return 0; 	if (ocu_len == 0) {		memset(str_o, 0, str_max_len);		return 0;	} 	if (UDF_SB(sb)->s_nls_map)		conv_f = UDF_SB(sb)->s_nls_map->uni2char;	else		conv_f = NULL; 	cmp_id = ocu[0];	if (cmp_id != 8 && cmp_id != 16) {		memset(str_o, 0, str_max_len);		pr_err("unknown compression code (%u)\n", cmp_id);		return -EINVAL;	}	u_ch = cmp_id >> 3; 	ocu++;	ocu_len--; 	if (ocu_len % u_ch) {		pr_err("incorrect filename length (%d)\n", ocu_len + 1);		return -EINVAL;	} 	if (translate) {		/* Look for extension */		for (idx = ocu_len - u_ch, ext_i_len = 0;		     (idx >= 0) && (ext_i_len < EXT_SIZE);		     idx -= u_ch, ext_i_len++) {			c = ocu[idx];			if (u_ch > 1)				c = (c << 8) | ocu[idx + 1]; 			if (c == EXT_MARK) {				if (ext_i_len)					i_ext = idx;				break;			}		}		if (i_ext >= 0) {			/* Convert extension */			ext_max_len = min_t(int, sizeof(ext), str_max_len);			ext[ext_o_len++] = EXT_MARK;			idx = i_ext + u_ch;			while (udf_name_conv_char(ext, ext_max_len, &ext_o_len,						  ocu, ocu_len, &idx,						  u_ch, &needsCRC,						  conv_f, translate)) {				if ((ext_o_len + CRC_LEN) < str_max_len)					ext_crc_len = ext_o_len;			}		}	} 	idx = 0;	while (1) {		if (translate && (idx == i_ext)) {			if (str_o_len > (str_max_len - ext_o_len))				needsCRC = 1;			break;		} 		if (!udf_name_conv_char(str_o, str_max_len, &str_o_len,					ocu, ocu_len, &idx,					u_ch, &needsCRC, conv_f, translate))			break; 		if (translate &&		    (str_o_len <= (str_max_len - ext_o_len - CRC_LEN)))			o_crc = str_o_len;	} 	if (translate) {		if (str_o_len > 0 && str_o_len <= 2 && str_o[0] == '.' &&		    (str_o_len == 1 || str_o[1] == '.'))			needsCRC = 1;		if (needsCRC) {			str_o_len = o_crc;			valueCRC = crc_itu_t(0, ocu, ocu_len);			crc[0] = CRC_MARK;			crc[1] = hex_asc_upper_hi(valueCRC >> 8);			crc[2] = hex_asc_upper_lo(valueCRC >> 8);			crc[3] = hex_asc_upper_hi(valueCRC);			crc[4] = hex_asc_upper_lo(valueCRC);			len = min_t(int, CRC_LEN, str_max_len - str_o_len);			memcpy(&str_o[str_o_len], crc, len);			str_o_len += len;			ext_o_len = ext_crc_len;		}		if (ext_o_len > 0) {			memcpy(&str_o[str_o_len], ext, ext_o_len);			str_o_len += ext_o_len;		}	} 	return str_o_len;} static int udf_name_to_CS0(struct super_block *sb,			   uint8_t *ocu, int ocu_max_len,			   const uint8_t *str_i, int str_len){	int i, len;	unsigned int max_val;	int u_len, u_ch;	unicode_t uni_char;	int (*conv_f)(const unsigned char *, int, wchar_t *); 	if (ocu_max_len <= 0)		return 0; 	if (UDF_SB(sb)->s_nls_map)		conv_f = UDF_SB(sb)->s_nls_map->char2uni;	else		conv_f = NULL; 	memset(ocu, 0, ocu_max_len);	ocu[0] = 8;	max_val = 0xff;	u_ch = 1; try_again:	u_len = 1;	for (i = 0; i < str_len; i += len) {		/* Name didn't fit? */		if (u_len + u_ch > ocu_max_len)			return 0;		if (conv_f) {			wchar_t wchar; 			len = conv_f(&str_i[i], str_len - i, &wchar);			if (len > 0)				uni_char = wchar;		} else {			len = utf8_to_utf32(&str_i[i], str_len - i,					    &uni_char);		}		/* Invalid character, deal with it */		if (len <= 0 || uni_char > UNICODE_MAX) {			len = 1;			uni_char = '?';		} 		if (uni_char > max_val) {			unicode_t c; 			if (max_val == 0xff) {				max_val = 0xffff;				ocu[0] = 0x10;				u_ch = 2;				goto try_again;			}			/*			 * Use UTF-16 encoding for chars outside we			 * cannot encode directly.			 */			if (u_len + 2 * u_ch > ocu_max_len)				return 0; 			uni_char -= PLANE_SIZE;			c = SURROGATE_PAIR |			    ((uni_char >> SURROGATE_CHAR_BITS) &			     SURROGATE_CHAR_MASK);			ocu[u_len++] = (uint8_t)(c >> 8);			ocu[u_len++] = (uint8_t)(c & 0xff);			uni_char = SURROGATE_PAIR | SURROGATE_LOW |					(uni_char & SURROGATE_CHAR_MASK);		} 		if (max_val == 0xffff)			ocu[u_len++] = (uint8_t)(uni_char >> 8);		ocu[u_len++] = (uint8_t)(uni_char & 0xff);	} 	return u_len;} /* * Convert CS0 dstring to output charset. Warning: This function may truncate * input string if it is too long as it is used for informational strings only * and it is better to truncate the string than to refuse mounting a media. */int udf_dstrCS0toChar(struct super_block *sb, uint8_t *utf_o, int o_len,		      const uint8_t *ocu_i, int i_len){	int s_len = 0; 	if (i_len > 0) {		s_len = ocu_i[i_len - 1];		if (s_len >= i_len) {			pr_warn("incorrect dstring lengths (%d/%d),"				" truncating\n", s_len, i_len);			s_len = i_len - 1;			/* 2-byte encoding? Need to round properly... */			if (ocu_i[0] == 16)				s_len -= (s_len - 1) & 2;		}	} 	return udf_name_from_CS0(sb, utf_o, o_len, ocu_i, s_len, 0);} int udf_get_filename(struct super_block *sb, const uint8_t *sname, int slen,		     uint8_t *dname, int dlen){	int ret; 	if (!slen)		return -EIO; 	if (dlen <= 0)		return 0; 	ret = udf_name_from_CS0(sb, dname, dlen, sname, slen, 1);	/* Zero length filename isn't valid... */	if (ret == 0)		ret = -EINVAL;	return ret;} int udf_put_filename(struct super_block *sb, const uint8_t *sname, int slen,		     uint8_t *dname, int dlen){	return udf_name_to_CS0(sb, dname, dlen, sname, slen);}