[mirror_ubuntu-bionic-kernel.git] / fs / hfsplus / unicode.c

// SPDX-License-Identifier: GPL-2.0
/*
 *  linux/fs/hfsplus/unicode.c
 *
 * Copyright (C) 2001
 * Brad Boyer (flar@allandria.com)
 * (C) 2003 Ardis Technologies <roman@ardistech.com>
 *
 * 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 single unicode character. */
static inline u16 *decompose_unichar(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);
}

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;

	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);
		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;

	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 uninitialized_var(dsize);
		size = asc2unichar(sb, astr, len, &c);
		astr += size;
		len -= size;

		if (decompose)
			dstr = decompose_unichar(c, &dsize);
		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;

	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);
			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);
			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 (flar@allandria.com)
	7	* (C) 2003 Ardis Technologies <roman@ardistech.com>
	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
	275	/* Decomposes a single unicode character. */
	276	static inline u16 decompose_unichar(wchar_t uc, int size)
	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
324ef39a VD	299	int hfsplus_asc2uni(struct super_block *sb,
324ef39a VD	300	struct hfsplus_unistr *ustr, int max_unistr_len,
1e96b7ca DG	301	const char *astr, int len)
	302	{
	303	int size, dsize, decompose;
	304	u16 *dstr, outlen = 0;
1da177e4	305	wchar_t c;
1da177e4	306
84adede3	307	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
324ef39a	308	while (outlen < max_unistr_len && len > 0) {
1e96b7ca DG	309	size = asc2unichar(sb, astr, len, &c);
1e96b7ca DG	310
2b4f9ca8 AS	311	if (decompose)
	312	dstr = decompose_unichar(c, &dsize);
	313	else
	314	dstr = NULL;
	315	if (dstr) {
324ef39a	316	if (outlen + dsize > max_unistr_len)
1da177e4 LT	317	break;
1da177e4 LT	318	do {
1e96b7ca DG	319	ustr->unicode[outlen++] = cpu_to_be16(*dstr++);
	320	} while (--dsize > 0);
	321	} else
	322	ustr->unicode[outlen++] = cpu_to_be16(c);
	323
	324	astr += size;
	325	len -= size;
1da177e4 LT	326	}
	327	ustr->length = cpu_to_be16(outlen);
	328	if (len > 0)
	329	return -ENAMETOOLONG;
	330	return 0;
	331	}
d45bce8f DG	332
	333	/*
	334	* Hash a string to an integer as appropriate for the HFS+ filesystem.
	335	* Composed unicode characters are decomposed and case-folding is performed
	336	* if the appropriate bits are (un)set on the superblock.
	337	*/
da53be12	338	int hfsplus_hash_dentry(const struct dentry dentry, struct qstr str)
d45bce8f DG	339	{
	340	struct super_block *sb = dentry->d_sb;
	341	const char *astr;
	342	const u16 *dstr;
8aa84ab9	343	int casefold, decompose, size, len;
d45bce8f DG	344	unsigned long hash;
	345	wchar_t c;
	346	u16 c2;
	347
84adede3 CH	348	casefold = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);
84adede3 CH	349	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
8387ff25	350	hash = init_name_hash(dentry);
d45bce8f DG	351	astr = str->name;
	352	len = str->len;
	353	while (len > 0) {
8aa84ab9	354	int uninitialized_var(dsize);
d45bce8f DG	355	size = asc2unichar(sb, astr, len, &c);
	356	astr += size;
	357	len -= size;
	358
2b4f9ca8 AS	359	if (decompose)
	360	dstr = decompose_unichar(c, &dsize);
	361	else
	362	dstr = NULL;
	363	if (dstr) {
d45bce8f DG	364	do {
d45bce8f DG	365	c2 = *dstr++;
2b4f9ca8 AS	366	if (casefold)
	367	c2 = case_fold(c2);
	368	if (!casefold \|\| c2)
d45bce8f DG	369	hash = partial_name_hash(c2, hash);
	370	} while (--dsize > 0);
	371	} else {
	372	c2 = c;
2b4f9ca8 AS	373	if (casefold)
	374	c2 = case_fold(c2);
	375	if (!casefold \|\| c2)
d45bce8f DG	376	hash = partial_name_hash(c2, hash);
	377	}
	378	}
	379	str->hash = end_name_hash(hash);
	380
	381	return 0;
	382	}
	383
	384	/*
	385	* Compare strings with HFS+ filename ordering.
	386	* Composed unicode characters are decomposed and case-folding is performed
	387	* if the appropriate bits are (un)set on the superblock.
	388	*/
6fa67e70	389	int hfsplus_compare_dentry(const struct dentry *dentry,
621e155a	390	unsigned int len, const char str, const struct qstr name)
d45bce8f	391	{
d3fe1985	392	struct super_block *sb = dentry->d_sb;
d45bce8f DG	393	int casefold, decompose, size;
	394	int dsize1, dsize2, len1, len2;
	395	const u16 dstr1, dstr2;
	396	const char astr1, astr2;
	397	u16 c1, c2;
	398	wchar_t c;
	399
84adede3 CH	400	casefold = test_bit(HFSPLUS_SB_CASEFOLD, &HFSPLUS_SB(sb)->flags);
84adede3 CH	401	decompose = !test_bit(HFSPLUS_SB_NODECOMPOSE, &HFSPLUS_SB(sb)->flags);
621e155a NP	402	astr1 = str;
	403	len1 = len;
	404	astr2 = name->name;
	405	len2 = name->len;
d45bce8f DG	406	dsize1 = dsize2 = 0;
	407	dstr1 = dstr2 = NULL;
	408
	409	while (len1 > 0 && len2 > 0) {
	410	if (!dsize1) {
	411	size = asc2unichar(sb, astr1, len1, &c);
	412	astr1 += size;
	413	len1 -= size;
	414
2753cc28 AS	415	if (decompose)
	416	dstr1 = decompose_unichar(c, &dsize1);
	417	if (!decompose \|\| !dstr1) {
d45bce8f DG	418	c1 = c;
	419	dstr1 = &c1;
	420	dsize1 = 1;
	421	}
	422	}
	423
	424	if (!dsize2) {
	425	size = asc2unichar(sb, astr2, len2, &c);
	426	astr2 += size;
	427	len2 -= size;
	428
2753cc28 AS	429	if (decompose)
	430	dstr2 = decompose_unichar(c, &dsize2);
	431	if (!decompose \|\| !dstr2) {
d45bce8f DG	432	c2 = c;
	433	dstr2 = &c2;
	434	dsize2 = 1;
	435	}
	436	}
	437
	438	c1 = *dstr1;
	439	c2 = *dstr2;
	440	if (casefold) {
2b4f9ca8 AS	441	c1 = case_fold(c1);
2b4f9ca8 AS	442	if (!c1) {
d45bce8f DG	443	dstr1++;
	444	dsize1--;
	445	continue;
	446	}
2b4f9ca8 AS	447	c2 = case_fold(c2);
2b4f9ca8 AS	448	if (!c2) {
d45bce8f DG	449	dstr2++;
	450	dsize2--;
	451	continue;
	452	}
	453	}
	454	if (c1 < c2)
	455	return -1;
	456	else if (c1 > c2)
	457	return 1;
	458
	459	dstr1++;
	460	dsize1--;
	461	dstr2++;
	462	dsize2--;
	463	}
	464
	465	if (len1 < len2)
	466	return -1;
	467	if (len1 > len2)
	468	return 1;
	469	return 0;
	470	}