1/*
2 *  linux/fs/hfsplus/unicode.c
3 *
4 * Copyright (C) 2001
5 * Brad Boyer (flar@allandria.com)
6 * (C) 2003 Ardis Technologies <roman@ardistech.com>
7 *
8 * Handler routines for unicode strings
9 */
10
11#include <linux/types.h>
12#include <linux/nls.h>
13#include "hfsplus_fs.h"
14#include "hfsplus_raw.h"
15
16/* Fold the case of a unicode char, given the 16 bit value */
17/* Returns folded char, or 0 if ignorable */
18static inline u16 case_fold(u16 c)
19{
20        u16 tmp;
21
22        tmp = hfsplus_case_fold_table[c >> 8];
23        if (tmp)
24                tmp = hfsplus_case_fold_table[tmp + (c & 0xff)];
25        else
26                tmp = c;
27        return tmp;
28}
29
30/* Compare unicode strings, return values like normal strcmp */
31int hfsplus_strcasecmp(const struct hfsplus_unistr *s1,
32		       const struct hfsplus_unistr *s2)
33{
34	u16 len1, len2, c1, c2;
35	const hfsplus_unichr *p1, *p2;
36
37	len1 = be16_to_cpu(s1->length);
38	len2 = be16_to_cpu(s2->length);
39	p1 = s1->unicode;
40	p2 = s2->unicode;
41
42	while (1) {
43		c1 = c2 = 0;
44
45		while (len1 && !c1) {
46			c1 = case_fold(be16_to_cpu(*p1));
47			p1++;
48			len1--;
49		}
50		while (len2 && !c2) {
51			c2 = case_fold(be16_to_cpu(*p2));
52			p2++;
53			len2--;
54		}
55
56		if (c1 != c2)
57			return (c1 < c2) ? -1 : 1;
58		if (!c1 && !c2)
59			return 0;
60	}
61}
62
63/* Compare names as a sequence of 16-bit unsigned integers */
64int hfsplus_strcmp(const struct hfsplus_unistr *s1,
65		   const struct hfsplus_unistr *s2)
66{
67	u16 len1, len2, c1, c2;
68	const hfsplus_unichr *p1, *p2;
69	int len;
70
71	len1 = be16_to_cpu(s1->length);
72	len2 = be16_to_cpu(s2->length);
73	p1 = s1->unicode;
74	p2 = s2->unicode;
75
76	for (len = min(len1, len2); len > 0; len--) {
77		c1 = be16_to_cpu(*p1);
78		c2 = be16_to_cpu(*p2);
79		if (c1 != c2)
80			return c1 < c2 ? -1 : 1;
81		p1++;
82		p2++;
83	}
84
85	return len1 < len2 ? -1 :
86	       len1 > len2 ? 1 : 0;
87}
88
89
90#define Hangul_SBase	0xac00
91#define Hangul_LBase	0x1100
92#define Hangul_VBase	0x1161
93#define Hangul_TBase	0x11a7
94#define Hangul_SCount	11172
95#define Hangul_LCount	19
96#define Hangul_VCount	21
97#define Hangul_TCount	28
98#define Hangul_NCount	(Hangul_VCount * Hangul_TCount)
99
100
101static u16 *hfsplus_compose_lookup(u16 *p, u16 cc)
102{
103	int i, s, e;
104
105	s = 1;
106	e = p[1];
107	if (!e || cc < p[s * 2] || cc > p[e * 2])
108		return NULL;
109	do {
110		i = (s + e) / 2;
111		if (cc > p[i * 2])
112			s = i + 1;
113		else if (cc < p[i * 2])
114			e = i - 1;
115		else
116			return hfsplus_compose_table + p[i * 2 + 1];
117	} while (s <= e);
118	return NULL;
119}
120
121int hfsplus_uni2asc(struct super_block *sb, const struct hfsplus_unistr *ustr, char *astr, int *len_p)
122{
123	const hfsplus_unichr *ip;
124	struct nls_table *nls = HFSPLUS_SB(sb).nls;
125	u8 *op;
126	u16 cc, c0, c1;
127	u16 *ce1, *ce2;
128	int i, len, ustrlen, res, compose;
129
130	op = astr;
131	ip = ustr->unicode;
132	ustrlen = be16_to_cpu(ustr->length);
133	len = *len_p;
134	ce1 = NULL;
135	compose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
136
137	while (ustrlen > 0) {
138		c0 = be16_to_cpu(*ip++);
139		ustrlen--;
140		/* search for single decomposed char */
141		if (likely(compose))
142			ce1 = hfsplus_compose_lookup(hfsplus_compose_table, c0);
143		if (ce1 && (cc = ce1[0])) {
144			/* start of a possibly decomposed Hangul char */
145			if (cc != 0xffff)
146				goto done;
147			if (!ustrlen)
148				goto same;
149			c1 = be16_to_cpu(*ip) - Hangul_VBase;
150			if (c1 < Hangul_VCount) {
151				/* compose the Hangul char */
152				cc = (c0 - Hangul_LBase) * Hangul_VCount;
153				cc = (cc + c1) * Hangul_TCount;
154				cc += Hangul_SBase;
155				ip++;
156				ustrlen--;
157				if (!ustrlen)
158					goto done;
159				c1 = be16_to_cpu(*ip) - Hangul_TBase;
160				if (c1 > 0 && c1 < Hangul_TCount) {
161					cc += c1;
162					ip++;
163					ustrlen--;
164				}
165				goto done;
166			}
167		}
168		while (1) {
169			/* main loop for common case of not composed chars */
170			if (!ustrlen)
171				goto same;
172			c1 = be16_to_cpu(*ip);
173			if (likely(compose))
174				ce1 = hfsplus_compose_lookup(hfsplus_compose_table, c1);
175			if (ce1)
176				break;
177			switch (c0) {
178			case 0:
179				c0 = 0x2400;
180				break;
181			case '/':
182				c0 = ':';
183				break;
184			}
185			res = nls->uni2char(c0, op, len);
186			if (res < 0) {
187				if (res == -ENAMETOOLONG)
188					goto out;
189				*op = '?';
190				res = 1;
191			}
192			op += res;
193			len -= res;
194			c0 = c1;
195			ip++;
196			ustrlen--;
197		}
198		ce2 = hfsplus_compose_lookup(ce1, c0);
199		if (ce2) {
200			i = 1;
201			while (i < ustrlen) {
202				ce1 = hfsplus_compose_lookup(ce2, be16_to_cpu(ip[i]));
203				if (!ce1)
204					break;
205				i++;
206				ce2 = ce1;
207			}
208			if ((cc = ce2[0])) {
209				ip += i;
210				ustrlen -= i;
211				goto done;
212			}
213		}
214	same:
215		switch (c0) {
216		case 0:
217			cc = 0x2400;
218			break;
219		case '/':
220			cc = ':';
221			break;
222		default:
223			cc = c0;
224		}
225	done:
226		res = nls->uni2char(cc, op, len);
227		if (res < 0) {
228			if (res == -ENAMETOOLONG)
229				goto out;
230			*op = '?';
231			res = 1;
232		}
233		op += res;
234		len -= res;
235	}
236	res = 0;
237out:
238	*len_p = (char *)op - astr;
239	return res;
240}
241
242int hfsplus_asc2uni(struct super_block *sb, struct hfsplus_unistr *ustr, const char *astr, int len)
243{
244	struct nls_table *nls = HFSPLUS_SB(sb).nls;
245	int size, off, decompose;
246	wchar_t c;
247	u16 outlen = 0;
248
249	decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
250
251	while (outlen < HFSPLUS_MAX_STRLEN && len > 0) {
252		size = nls->char2uni(astr, len, &c);
253		if (size <= 0) {
254			c = '?';
255			size = 1;
256		}
257		astr += size;
258		len -= size;
259		switch (c) {
260		case 0x2400:
261			c = 0;
262			break;
263		case ':':
264			c = '/';
265			break;
266		}
267		if (c >= 0xc0 && decompose) {
268			off = hfsplus_decompose_table[(c >> 12) & 0xf];
269			if (!off)
270				goto done;
271			if (off == 0xffff) {
272				goto done;
273			}
274			off = hfsplus_decompose_table[off + ((c >> 8) & 0xf)];
275			if (!off)
276				goto done;
277			off = hfsplus_decompose_table[off + ((c >> 4) & 0xf)];
278			if (!off)
279				goto done;
280			off = hfsplus_decompose_table[off + (c & 0xf)];
281			size = off & 3;
282			if (!size)
283				goto done;
284			off /= 4;
285			if (outlen + size > HFSPLUS_MAX_STRLEN)
286				break;
287			do {
288				ustr->unicode[outlen++] = cpu_to_be16(hfsplus_decompose_table[off++]);
289			} while (--size > 0);
290			continue;
291		}
292	done:
293		ustr->unicode[outlen++] = cpu_to_be16(c);
294	}
295	ustr->length = cpu_to_be16(outlen);
296	if (len > 0)
297		return -ENAMETOOLONG;
298	return 0;
299}
300