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

// SPDX-License-Identifier: GPL-2.0
/*
 *  linux/fs/hfsplus/unicode.c
 *
 * Copyright (C) 2001
 * Brad Boyer ([email protected])
 * (C) 2003 Ardis Technologies <[email protected]>
 *
 * Handler routines for unicode strings
 */

#include <linux/types.h>
#include <linux/nls.h>
#include "hfsplus_fs.h"
#include "hfsplus_raw.h"

/* Fold the case of a unicode char, given the 16 bit value */
/* Returns folded char, or 0 if ignorable */
static inline u16 case_fold(u16 c)
{
	u16 tmp;

	tmp = hfsplus_case_fold_table[c >> 8];
	if (tmp)
		tmp = hfsplus_case_fold_table[tmp + (c & 0xff)];
	else
		tmp = c;
	return tmp;
}

/* Compare unicode strings, return values like normal strcmp */
int hfsplus_strcasecmp(const struct hfsplus_unistr *s1,
		       const struct hfsplus_unistr *s2)
{
	u16 len1, len2, c1, c2;
	const hfsplus_unichr *p1, *p2;

	len1 = be16_to_cpu(s1->length);
	len2 = be16_to_cpu(s2->length);
	p1 = s1->unicode;
	p2 = s2->unicode;

	while (1) {
		c1 = c2 = 0;

		while (len1 && !c1) {
			c1 = case_fold(be16_to_cpu(*p1));
			p1++;
			len1--;
		}
		while (len2 && !c2) {
			c2 = case_fold(be16_to_cpu(*p2));
			p2++;
			len2--;
		}

		if (c1 != c2)
			return (c1 < c2) ? -1 : 1;
		if (!c1 && !c2)
			return 0;
	}
}

/* Compare names as a sequence of 16-bit unsigned integers */
int hfsplus_strcmp(const struct hfsplus_unistr *s1,
		   const struct hfsplus_unistr *s2)
{
	u16 len1, len2, c1, c2;
	const hfsplus_unichr *p1, *p2;
	int len;

	len1 = be16_to_cpu(s1->length);
	len2 = be16_to_cpu(s2->length);
	p1 = s1->unicode;
	p2 = s2->unicode;

	for (len = min(len1, len2); len > 0; len--) {
		c1 = be16_to_cpu(*p1);
		c2 = be16_to_cpu(*p2);
		if (c1 != c2)
			return c1 < c2 ? -1 : 1;
		p1++;
		p2++;
	}

	return len1 < len2 ? -1 :
	       len1 > len2 ? 1 : 0;
}


#define Hangul_SBase	0xac00
#define Hangul_LBase	0x1100
#define Hangul_VBase	0x1161
#define Hangul_TBase	0x11a7
#define Hangul_SCount	11172
#define Hangul_LCount	19
#define Hangul_VCount	21
#define Hangul_TCount	28
#define Hangul_NCount	(Hangul_VCount * Hangul_TCount)


static u16 *hfsplus_compose_lookup(u16 *p, u16 cc)
{
	int i, s, e;

	s = 1;
	e = p[1];
	if (!e || cc < p[s * 2] || cc > p[e * 2])
		return NULL;
	do {
		i = (s + e) / 2;
		if (cc > p[i * 2])
			s = i + 1;
		else if (cc < p[i * 2])
			e = i - 1;
		else
			return hfsplus_compose_table + p[i * 2 + 1];
	} while (s <= e);
	return NULL;
}

int hfsplus_uni2asc(struct super_block *sb,
		const struct hfsplus_unistr *ustr,
		char *astr, int *len_p)
{
	const hfsplus_unichr *ip;
	struct nls_table *nls = HFSPLUS_SB(sb)->nls;
	u8 *op;
	u16 cc, c0, c1;
	u16 *ce1, *ce2;
	int i, len, ustrlen, res, compose;

	op = astr;
	ip = ustr->unicode;
	ustrlen = be16_to_cpu(ustr->length);
	len = *len_p;
	ce1 = NULL;
	compose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);

	while (ustrlen > 0) {
		c0 = be16_to_cpu(*ip++);
		ustrlen--;
		/* search for single decomposed char */
		if (likely(compose))
			ce1 = hfsplus_compose_lookup(hfsplus_compose_table, c0);
		if (ce1)
			cc = ce1[0];
		else
			cc = 0;
		if (cc) {
			/* start of a possibly decomposed Hangul char */
			if (cc != 0xffff)
				goto done;
			if (!ustrlen)
				goto same;
			c1 = be16_to_cpu(*ip) - Hangul_VBase;
			if (c1 < Hangul_VCount) {
				/* compose the Hangul char */
				cc = (c0 - Hangul_LBase) * Hangul_VCount;
				cc = (cc + c1) * Hangul_TCount;
				cc += Hangul_SBase;
				ip++;
				ustrlen--;
				if (!ustrlen)
					goto done;
				c1 = be16_to_cpu(*ip) - Hangul_TBase;
				if (c1 > 0 && c1 < Hangul_TCount) {
					cc += c1;
					ip++;
					ustrlen--;
				}
				goto done;
			}
		}
		while (1) {
			/* main loop for common case of not composed chars */
			if (!ustrlen)
				goto same;
			c1 = be16_to_cpu(*ip);
			if (likely(compose))
				ce1 = hfsplus_compose_lookup(
					hfsplus_compose_table, c1);
			if (ce1)
				break;
			switch (c0) {
			case 0:
				c0 = 0x2400;
				break;
			case '/':
				c0 = ':';
				break;
			}
			res = nls->uni2char(c0, op, len);
			if (res < 0) {
				if (res == -ENAMETOOLONG)
					goto out;
				*op = '?';
				res = 1;
			}
			op += res;
			len -= res;
			c0 = c1;
			ip++;
			ustrlen--;
		}
		ce2 = hfsplus_compose_lookup(ce1, c0);
		if (ce2) {
			i = 1;
			while (i < ustrlen) {
				ce1 = hfsplus_compose_lookup(ce2,
					be16_to_cpu(ip[i]));
				if (!ce1)
					break;
				i++;
				ce2 = ce1;
			}
			cc = ce2[0];
			if (cc) {
				ip += i;
				ustrlen -= i;
				goto done;
			}
		}
same:
		switch (c0) {
		case 0:
			cc = 0x2400;
			break;
		case '/':
			cc = ':';
			break;
		default:
			cc = c0;
		}
done:
		res = nls->uni2char(cc, op, len);
		if (res < 0) {
			if (res == -ENAMETOOLONG)
				goto out;
			*op = '?';
			res = 1;
		}
		op += res;
		len -= res;
	}
	res = 0;
out:
	*len_p = (char *)op - astr;
	return res;
}

/*
 * Convert one or more ASCII characters into a single unicode character.
 * Returns the number of ASCII characters corresponding to the unicode char.
 */
static inline int asc2unichar(struct super_block *sb, const char *astr, int len,
			      wchar_t *uc)
{
	int size = HFSPLUS_SB(sb)->nls->char2uni(astr, len, uc);
	if (size <= 0) {
		*uc = '?';
		size = 1;
	}
	switch (*uc) {
	case 0x2400:
		*uc = 0;
		break;
	case ':':
		*uc = '/';
		break;
	}
	return size;
}

/* Decomposes a non-Hangul unicode character. */
static u16 *hfsplus_decompose_nonhangul(wchar_t uc, int *size)
{
	int off;

	off = hfsplus_decompose_table[(uc >> 12) & 0xf];
	if (off == 0 || off == 0xffff)
		return NULL;

	off = hfsplus_decompose_table[off + ((uc >> 8) & 0xf)];
	if (!off)
		return NULL;

	off = hfsplus_decompose_table[off + ((uc >> 4) & 0xf)];
	if (!off)
		return NULL;

	off = hfsplus_decompose_table[off + (uc & 0xf)];
	*size = off & 3;
	if (*size == 0)
		return NULL;
	return hfsplus_decompose_table + (off / 4);
}

/*
 * Try to decompose a unicode character as Hangul. Return 0 if @uc is not
 * precomposed Hangul, otherwise return the length of the decomposition.
 *
 * This function was adapted from sample code from the Unicode Standard
 * Annex #15: Unicode Normalization Forms, version 3.2.0.
 *
 * Copyright (C) 1991-2018 Unicode, Inc.  All rights reserved.  Distributed
 * under the Terms of Use in http://www.unicode.org/copyright.html.
 */
static int hfsplus_try_decompose_hangul(wchar_t uc, u16 *result)
{
	int index;
	int l, v, t;

	index = uc - Hangul_SBase;
	if (index < 0 || index >= Hangul_SCount)
		return 0;

	l = Hangul_LBase + index / Hangul_NCount;
	v = Hangul_VBase + (index % Hangul_NCount) / Hangul_TCount;
	t = Hangul_TBase + index % Hangul_TCount;

	result[0] = l;
	result[1] = v;
	if (t != Hangul_TBase) {
		result[2] = t;
		return 3;
	}
	return 2;
}

/* Decomposes a single unicode character. */
static u16 *decompose_unichar(wchar_t uc, int *size, u16 *hangul_buffer)
{
	u16 *result;

	/* Hangul is handled separately */
	result = hangul_buffer;
	*size = hfsplus_try_decompose_hangul(uc, result);
	if (*size == 0)
		result = hfsplus_decompose_nonhangul(uc, size);
	return result;
}

int hfsplus_asc2uni(struct super_block *sb,
		    struct hfsplus_unistr *ustr, int max_unistr_len,
		    const char *astr, int len)
{
	int size, dsize, decompose;
	u16 *dstr, outlen = 0;
	wchar_t c;
	u16 dhangul[3];

	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
	while (outlen < max_unistr_len && len > 0) {
		size = asc2unichar(sb, astr, len, &c);

		if (decompose)
			dstr = decompose_unichar(c, &dsize, dhangul);
		else
			dstr = NULL;
		if (dstr) {
			if (outlen + dsize > max_unistr_len)
				break;
			do {
				ustr->unicode[outlen++] = cpu_to_be16(*dstr++);
			} while (--dsize > 0);
		} else
			ustr->unicode[outlen++] = cpu_to_be16(c);

		astr += size;
		len -= size;
	}
	ustr->length = cpu_to_be16(outlen);
	if (len > 0)
		return -ENAMETOOLONG;
	return 0;
}

/*
 * Hash a string to an integer as appropriate for the HFS+ filesystem.
 * Composed unicode characters are decomposed and case-folding is performed
 * if the appropriate bits are (un)set on the superblock.
 */
int hfsplus_hash_dentry(const struct dentry *dentry, struct qstr *str)
{
	struct super_block *sb = dentry->d_sb;
	const char *astr;
	const u16 *dstr;
	int casefold, decompose, size, len;
	unsigned long hash;
	wchar_t c;
	u16 c2;
	u16 dhangul[3];

	casefold = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);
	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
	hash = init_name_hash(dentry);
	astr = str->name;
	len = str->len;
	while (len > 0) {
		int dsize;
		size = asc2unichar(sb, astr, len, &c);
		astr += size;
		len -= size;

		if (decompose)
			dstr = decompose_unichar(c, &dsize, dhangul);
		else
			dstr = NULL;
		if (dstr) {
			do {
				c2 = *dstr++;
				if (casefold)
					c2 = case_fold(c2);
				if (!casefold || c2)
					hash = partial_name_hash(c2, hash);
			} while (--dsize > 0);
		} else {
			c2 = c;
			if (casefold)
				c2 = case_fold(c2);
			if (!casefold || c2)
				hash = partial_name_hash(c2, hash);
		}
	}
	str->hash = end_name_hash(hash);

	return 0;
}

/*
 * Compare strings with HFS+ filename ordering.
 * Composed unicode characters are decomposed and case-folding is performed
 * if the appropriate bits are (un)set on the superblock.
 */
int hfsplus_compare_dentry(const struct dentry *dentry,
		unsigned int len, const char *str, const struct qstr *name)
{
	struct super_block *sb = dentry->d_sb;
	int casefold, decompose, size;
	int dsize1, dsize2, len1, len2;
	const u16 *dstr1, *dstr2;
	const char *astr1, *astr2;
	u16 c1, c2;
	wchar_t c;
	u16 dhangul_1[3], dhangul_2[3];

	casefold = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);
	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
	astr1 = str;
	len1 = len;
	astr2 = name->name;
	len2 = name->len;
	dsize1 = dsize2 = 0;
	dstr1 = dstr2 = NULL;

	while (len1 > 0 && len2 > 0) {
		if (!dsize1) {
			size = asc2unichar(sb, astr1, len1, &c);
			astr1 += size;
			len1 -= size;

			if (decompose)
				dstr1 = decompose_unichar(c, &dsize1,
							  dhangul_1);
			if (!decompose || !dstr1) {
				c1 = c;
				dstr1 = &c1;
				dsize1 = 1;
			}
		}

		if (!dsize2) {
			size = asc2unichar(sb, astr2, len2, &c);
			astr2 += size;
			len2 -= size;

			if (decompose)
				dstr2 = decompose_unichar(c, &dsize2,
							  dhangul_2);
			if (!decompose || !dstr2) {
				c2 = c;
				dstr2 = &c2;
				dsize2 = 1;
			}
		}

		c1 = *dstr1;
		c2 = *dstr2;
		if (casefold) {
			c1 = case_fold(c1);
			if (!c1) {
				dstr1++;
				dsize1--;
				continue;
			}
			c2 = case_fold(c2);
			if (!c2) {
				dstr2++;
				dsize2--;
				continue;
			}
		}
		if (c1 < c2)
			return -1;
		else if (c1 > c2)
			return 1;

		dstr1++;
		dsize1--;
		dstr2++;
		dsize2--;
	}

	if (len1 < len2)
		return -1;
	if (len1 > len2)
		return 1;
	return 0;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	2	/*
	3	* linux/fs/hfsplus/unicode.c
	4	*
	5	* Copyright (C) 2001
	6	* Brad Boyer ([email protected])
	7	* (C) 2003 Ardis Technologies <[email protected]>
	8	*
	9	* Handler routines for unicode strings
	10	*/
	11
	12	#include <linux/types.h>
	13	#include <linux/nls.h>
	14	#include "hfsplus_fs.h"
	15	#include "hfsplus_raw.h"
	16
	17	/* Fold the case of a unicode char, given the 16 bit value */
	18	/* Returns folded char, or 0 if ignorable */
	19	static inline u16 case_fold(u16 c)
	20	{
20b7643d	21	u16 tmp;
1da177e4	22
20b7643d AS	23	tmp = hfsplus_case_fold_table[c >> 8];
	24	if (tmp)
	25	tmp = hfsplus_case_fold_table[tmp + (c & 0xff)];
	26	else
	27	tmp = c;
	28	return tmp;
1da177e4 LT	29	}
	30
	31	/* Compare unicode strings, return values like normal strcmp */
2179d372 DE	32	int hfsplus_strcasecmp(const struct hfsplus_unistr *s1,
2179d372 DE	33	const struct hfsplus_unistr *s2)
1da177e4 LT	34	{
	35	u16 len1, len2, c1, c2;
	36	const hfsplus_unichr p1, p2;
	37
	38	len1 = be16_to_cpu(s1->length);
	39	len2 = be16_to_cpu(s2->length);
	40	p1 = s1->unicode;
	41	p2 = s2->unicode;
	42
	43	while (1) {
	44	c1 = c2 = 0;
	45
	46	while (len1 && !c1) {
	47	c1 = case_fold(be16_to_cpu(*p1));
	48	p1++;
	49	len1--;
	50	}
	51	while (len2 && !c2) {
	52	c2 = case_fold(be16_to_cpu(*p2));
	53	p2++;
	54	len2--;
	55	}
	56
	57	if (c1 != c2)
	58	return (c1 < c2) ? -1 : 1;
	59	if (!c1 && !c2)
	60	return 0;
	61	}
	62	}
	63
2179d372 DE	64	/* Compare names as a sequence of 16-bit unsigned integers */
	65	int hfsplus_strcmp(const struct hfsplus_unistr *s1,
	66	const struct hfsplus_unistr *s2)
	67	{
	68	u16 len1, len2, c1, c2;
	69	const hfsplus_unichr p1, p2;
	70	int len;
	71
	72	len1 = be16_to_cpu(s1->length);
	73	len2 = be16_to_cpu(s2->length);
	74	p1 = s1->unicode;
	75	p2 = s2->unicode;
	76
	77	for (len = min(len1, len2); len > 0; len--) {
	78	c1 = be16_to_cpu(*p1);
	79	c2 = be16_to_cpu(*p2);
	80	if (c1 != c2)
	81	return c1 < c2 ? -1 : 1;
	82	p1++;
	83	p2++;
	84	}
	85
	86	return len1 < len2 ? -1 :
	87	len1 > len2 ? 1 : 0;
	88	}
	89
	90
1da177e4 LT	91	#define Hangul_SBase 0xac00
	92	#define Hangul_LBase 0x1100
	93	#define Hangul_VBase 0x1161
	94	#define Hangul_TBase 0x11a7
	95	#define Hangul_SCount 11172
	96	#define Hangul_LCount 19
	97	#define Hangul_VCount 21
	98	#define Hangul_TCount 28
	99	#define Hangul_NCount (Hangul_VCount * Hangul_TCount)
	100
	101
	102	static u16 hfsplus_compose_lookup(u16 p, u16 cc)
	103	{
	104	int i, s, e;
	105
	106	s = 1;
	107	e = p[1];
	108	if (!e \|\| cc < p[s * 2] \|\| cc > p[e * 2])
	109	return NULL;
	110	do {
	111	i = (s + e) / 2;
	112	if (cc > p[i * 2])
	113	s = i + 1;
	114	else if (cc < p[i * 2])
	115	e = i - 1;
	116	else
	117	return hfsplus_compose_table + p[i * 2 + 1];
	118	} while (s <= e);
	119	return NULL;
	120	}
	121
2753cc28 AS	122	int hfsplus_uni2asc(struct super_block *sb,
	123	const struct hfsplus_unistr *ustr,
	124	char astr, int len_p)
1da177e4 LT	125	{
1da177e4 LT	126	const hfsplus_unichr *ip;
dd73a01a	127	struct nls_table *nls = HFSPLUS_SB(sb)->nls;
1da177e4 LT	128	u8 *op;
	129	u16 cc, c0, c1;
	130	u16 ce1, ce2;
	131	int i, len, ustrlen, res, compose;
	132
	133	op = astr;
	134	ip = ustr->unicode;
	135	ustrlen = be16_to_cpu(ustr->length);
	136	len = *len_p;
	137	ce1 = NULL;
84adede3	138	compose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
1da177e4 LT	139
	140	while (ustrlen > 0) {
	141	c0 = be16_to_cpu(*ip++);
	142	ustrlen--;
	143	/* search for single decomposed char */
	144	if (likely(compose))
	145	ce1 = hfsplus_compose_lookup(hfsplus_compose_table, c0);
2b4f9ca8 AS	146	if (ce1)
	147	cc = ce1[0];
	148	else
	149	cc = 0;
	150	if (cc) {
1da177e4 LT	151	/* start of a possibly decomposed Hangul char */
	152	if (cc != 0xffff)
	153	goto done;
	154	if (!ustrlen)
	155	goto same;
	156	c1 = be16_to_cpu(*ip) - Hangul_VBase;
	157	if (c1 < Hangul_VCount) {
	158	/* compose the Hangul char */
	159	cc = (c0 - Hangul_LBase) * Hangul_VCount;
	160	cc = (cc + c1) * Hangul_TCount;
	161	cc += Hangul_SBase;
	162	ip++;
	163	ustrlen--;
	164	if (!ustrlen)
	165	goto done;
	166	c1 = be16_to_cpu(*ip) - Hangul_TBase;
	167	if (c1 > 0 && c1 < Hangul_TCount) {
	168	cc += c1;
	169	ip++;
	170	ustrlen--;
	171	}
	172	goto done;
	173	}
	174	}
	175	while (1) {
	176	/* main loop for common case of not composed chars */
	177	if (!ustrlen)
	178	goto same;
	179	c1 = be16_to_cpu(*ip);
	180	if (likely(compose))
2753cc28 AS	181	ce1 = hfsplus_compose_lookup(
2753cc28 AS	182	hfsplus_compose_table, c1);
1da177e4 LT	183	if (ce1)
	184	break;
	185	switch (c0) {
	186	case 0:
	187	c0 = 0x2400;
	188	break;
	189	case '/':
	190	c0 = ':';
	191	break;
	192	}
	193	res = nls->uni2char(c0, op, len);
	194	if (res < 0) {
	195	if (res == -ENAMETOOLONG)
	196	goto out;
	197	*op = '?';
	198	res = 1;
	199	}
	200	op += res;
	201	len -= res;
	202	c0 = c1;
	203	ip++;
	204	ustrlen--;
	205	}
	206	ce2 = hfsplus_compose_lookup(ce1, c0);
	207	if (ce2) {
	208	i = 1;
	209	while (i < ustrlen) {
2753cc28 AS	210	ce1 = hfsplus_compose_lookup(ce2,
2753cc28 AS	211	be16_to_cpu(ip[i]));
1da177e4 LT	212	if (!ce1)
	213	break;
	214	i++;
	215	ce2 = ce1;
	216	}
2b4f9ca8 AS	217	cc = ce2[0];
2b4f9ca8 AS	218	if (cc) {
1da177e4 LT	219	ip += i;
	220	ustrlen -= i;
	221	goto done;
	222	}
	223	}
20b7643d	224	same:
1da177e4 LT	225	switch (c0) {
	226	case 0:
	227	cc = 0x2400;
	228	break;
	229	case '/':
	230	cc = ':';
	231	break;
	232	default:
	233	cc = c0;
	234	}
20b7643d	235	done:
1da177e4 LT	236	res = nls->uni2char(cc, op, len);
	237	if (res < 0) {
	238	if (res == -ENAMETOOLONG)
	239	goto out;
	240	*op = '?';
	241	res = 1;
	242	}
	243	op += res;
	244	len -= res;
	245	}
	246	res = 0;
	247	out:
	248	len_p = (char )op - astr;
	249	return res;
	250	}
	251
1e96b7ca DG	252	/*
	253	* Convert one or more ASCII characters into a single unicode character.
	254	* Returns the number of ASCII characters corresponding to the unicode char.
	255	*/
	256	static inline int asc2unichar(struct super_block sb, const char astr, int len,
	257	wchar_t *uc)
1da177e4	258	{
dd73a01a	259	int size = HFSPLUS_SB(sb)->nls->char2uni(astr, len, uc);
1e96b7ca DG	260	if (size <= 0) {
	261	*uc = '?';
	262	size = 1;
	263	}
	264	switch (*uc) {
	265	case 0x2400:
	266	*uc = 0;
	267	break;
	268	case ':':
	269	*uc = '/';
	270	break;
	271	}
	272	return size;
	273	}
	274
afd6c9e1 EF	275	/* Decomposes a non-Hangul unicode character. */
afd6c9e1 EF	276	static u16 hfsplus_decompose_nonhangul(wchar_t uc, int size)
1e96b7ca DG	277	{
	278	int off;
	279
	280	off = hfsplus_decompose_table[(uc >> 12) & 0xf];
	281	if (off == 0 \|\| off == 0xffff)
	282	return NULL;
	283
	284	off = hfsplus_decompose_table[off + ((uc >> 8) & 0xf)];
	285	if (!off)
	286	return NULL;
	287
	288	off = hfsplus_decompose_table[off + ((uc >> 4) & 0xf)];
	289	if (!off)
	290	return NULL;
	291
	292	off = hfsplus_decompose_table[off + (uc & 0xf)];
	293	*size = off & 3;
	294	if (*size == 0)
	295	return NULL;
	296	return hfsplus_decompose_table + (off / 4);
	297	}
	298
afd6c9e1 EF	299	/*
	300	* Try to decompose a unicode character as Hangul. Return 0 if @uc is not
	301	* precomposed Hangul, otherwise return the length of the decomposition.
	302	*
	303	* This function was adapted from sample code from the Unicode Standard
	304	* Annex #15: Unicode Normalization Forms, version 3.2.0.
	305	*
	306	* Copyright (C) 1991-2018 Unicode, Inc. All rights reserved. Distributed
	307	* under the Terms of Use in http://www.unicode.org/copyright.html.
	308	*/
	309	static int hfsplus_try_decompose_hangul(wchar_t uc, u16 *result)
	310	{
	311	int index;
	312	int l, v, t;
	313
	314	index = uc - Hangul_SBase;
	315	if (index < 0 \|\| index >= Hangul_SCount)
	316	return 0;
	317
	318	l = Hangul_LBase + index / Hangul_NCount;
	319	v = Hangul_VBase + (index % Hangul_NCount) / Hangul_TCount;
	320	t = Hangul_TBase + index % Hangul_TCount;
	321
	322	result[0] = l;
	323	result[1] = v;
	324	if (t != Hangul_TBase) {
	325	result[2] = t;
	326	return 3;
	327	}
	328	return 2;
	329	}
	330
	331	/* Decomposes a single unicode character. */
	332	static u16 decompose_unichar(wchar_t uc, int size, u16 *hangul_buffer)
	333	{
	334	u16 *result;
	335
	336	/* Hangul is handled separately */
	337	result = hangul_buffer;
	338	*size = hfsplus_try_decompose_hangul(uc, result);
	339	if (*size == 0)
	340	result = hfsplus_decompose_nonhangul(uc, size);
	341	return result;
	342	}
	343
324ef39a VD	344	int hfsplus_asc2uni(struct super_block *sb,
324ef39a VD	345	struct hfsplus_unistr *ustr, int max_unistr_len,
1e96b7ca DG	346	const char *astr, int len)
	347	{
	348	int size, dsize, decompose;
	349	u16 *dstr, outlen = 0;
1da177e4	350	wchar_t c;
afd6c9e1	351	u16 dhangul[3];
1da177e4	352
84adede3	353	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
324ef39a	354	while (outlen < max_unistr_len && len > 0) {
1e96b7ca DG	355	size = asc2unichar(sb, astr, len, &c);
1e96b7ca DG	356
2b4f9ca8	357	if (decompose)
afd6c9e1	358	dstr = decompose_unichar(c, &dsize, dhangul);
2b4f9ca8 AS	359	else
	360	dstr = NULL;
	361	if (dstr) {
324ef39a	362	if (outlen + dsize > max_unistr_len)
1da177e4 LT	363	break;
1da177e4 LT	364	do {
1e96b7ca DG	365	ustr->unicode[outlen++] = cpu_to_be16(*dstr++);
	366	} while (--dsize > 0);
	367	} else
	368	ustr->unicode[outlen++] = cpu_to_be16(c);
	369
	370	astr += size;
	371	len -= size;
1da177e4 LT	372	}
	373	ustr->length = cpu_to_be16(outlen);
	374	if (len > 0)
	375	return -ENAMETOOLONG;
	376	return 0;
	377	}
d45bce8f DG	378
	379	/*
	380	* Hash a string to an integer as appropriate for the HFS+ filesystem.
	381	* Composed unicode characters are decomposed and case-folding is performed
	382	* if the appropriate bits are (un)set on the superblock.
	383	*/
da53be12	384	int hfsplus_hash_dentry(const struct dentry dentry, struct qstr str)
d45bce8f DG	385	{
	386	struct super_block *sb = dentry->d_sb;
	387	const char *astr;
	388	const u16 *dstr;
8aa84ab9	389	int casefold, decompose, size, len;
d45bce8f DG	390	unsigned long hash;
	391	wchar_t c;
	392	u16 c2;
afd6c9e1	393	u16 dhangul[3];
d45bce8f	394
84adede3 CH	395	casefold = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);
84adede3 CH	396	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
8387ff25	397	hash = init_name_hash(dentry);
d45bce8f DG	398	astr = str->name;
	399	len = str->len;
	400	while (len > 0) {
3f649ab7	401	int dsize;
d45bce8f DG	402	size = asc2unichar(sb, astr, len, &c);
	403	astr += size;
	404	len -= size;
	405
2b4f9ca8	406	if (decompose)
afd6c9e1	407	dstr = decompose_unichar(c, &dsize, dhangul);
2b4f9ca8 AS	408	else
	409	dstr = NULL;
	410	if (dstr) {
d45bce8f DG	411	do {
d45bce8f DG	412	c2 = *dstr++;
2b4f9ca8 AS	413	if (casefold)
	414	c2 = case_fold(c2);
	415	if (!casefold \|\| c2)
d45bce8f DG	416	hash = partial_name_hash(c2, hash);
	417	} while (--dsize > 0);
	418	} else {
	419	c2 = c;
2b4f9ca8 AS	420	if (casefold)
	421	c2 = case_fold(c2);
	422	if (!casefold \|\| c2)
d45bce8f DG	423	hash = partial_name_hash(c2, hash);
	424	}
	425	}
	426	str->hash = end_name_hash(hash);
	427
	428	return 0;
	429	}
	430
	431	/*
	432	* Compare strings with HFS+ filename ordering.
	433	* Composed unicode characters are decomposed and case-folding is performed
	434	* if the appropriate bits are (un)set on the superblock.
	435	*/
6fa67e70	436	int hfsplus_compare_dentry(const struct dentry *dentry,
621e155a	437	unsigned int len, const char str, const struct qstr name)
d45bce8f	438	{
d3fe1985	439	struct super_block *sb = dentry->d_sb;
d45bce8f DG	440	int casefold, decompose, size;
	441	int dsize1, dsize2, len1, len2;
	442	const u16 dstr1, dstr2;
	443	const char astr1, astr2;
	444	u16 c1, c2;
	445	wchar_t c;
afd6c9e1	446	u16 dhangul_1[3], dhangul_2[3];
d45bce8f	447
84adede3 CH	448	casefold = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);
84adede3 CH	449	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
621e155a NP	450	astr1 = str;
	451	len1 = len;
	452	astr2 = name->name;
	453	len2 = name->len;
d45bce8f DG	454	dsize1 = dsize2 = 0;
	455	dstr1 = dstr2 = NULL;
	456
	457	while (len1 > 0 && len2 > 0) {
	458	if (!dsize1) {
	459	size = asc2unichar(sb, astr1, len1, &c);
	460	astr1 += size;
	461	len1 -= size;
	462
2753cc28	463	if (decompose)
afd6c9e1 EF	464	dstr1 = decompose_unichar(c, &dsize1,
afd6c9e1 EF	465	dhangul_1);
2753cc28	466	if (!decompose \|\| !dstr1) {
d45bce8f DG	467	c1 = c;
	468	dstr1 = &c1;
	469	dsize1 = 1;
	470	}
	471	}
	472
	473	if (!dsize2) {
	474	size = asc2unichar(sb, astr2, len2, &c);
	475	astr2 += size;
	476	len2 -= size;
	477
2753cc28	478	if (decompose)
afd6c9e1 EF	479	dstr2 = decompose_unichar(c, &dsize2,
afd6c9e1 EF	480	dhangul_2);
2753cc28	481	if (!decompose \|\| !dstr2) {
d45bce8f DG	482	c2 = c;
	483	dstr2 = &c2;
	484	dsize2 = 1;
	485	}
	486	}
	487
	488	c1 = *dstr1;
	489	c2 = *dstr2;
	490	if (casefold) {
2b4f9ca8 AS	491	c1 = case_fold(c1);
2b4f9ca8 AS	492	if (!c1) {
d45bce8f DG	493	dstr1++;
	494	dsize1--;
	495	continue;
	496	}
2b4f9ca8 AS	497	c2 = case_fold(c2);
2b4f9ca8 AS	498	if (!c2) {
d45bce8f DG	499	dstr2++;
	500	dsize2--;
	501	continue;
	502	}
	503	}
	504	if (c1 < c2)
	505	return -1;
	506	else if (c1 > c2)
	507	return 1;
	508
	509	dstr1++;
	510	dsize1--;
	511	dstr2++;
	512	dsize2--;
	513	}
	514
	515	if (len1 < len2)
	516	return -1;
	517	if (len1 > len2)
	518	return 1;
	519	return 0;
	520	}