[linux.git] / fs / udf / unicode.c

/*
 * 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
 *
 * COPYRIGHT
 *	This file is distributed under the terms of the GNU General Public
 *	License (GPL). Copies of the GPL can be obtained from:
 *		ftp://prep.ai.mit.edu/pub/gnu/GPL
 *	Each contributing author retains all rights to their own work.
 */

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