blob: 614c11fcdcb67d0f704badaf029991dddc3682c0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * cifs_unicode: Unicode kernel case support
3 *
4 * Function:
5 * Convert a unicode character to upper or lower case using
6 * compressed tables.
7 *
Steve Frenchd38d8c72007-06-28 19:44:13 +00008 * Copyright (c) International Business Machines Corp., 2000,2007
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
Steve Frenchd38d8c72007-06-28 19:44:13 +000012 * the Free Software Foundation; either version 2 of the License, or
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 * (at your option) any later version.
Steve Frenchd38d8c72007-06-28 19:44:13 +000014 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
18 * the GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
Steve Frenchd38d8c72007-06-28 19:44:13 +000021 * along with this program; if not, write to the Free Software
Linus Torvalds1da177e2005-04-16 15:20:36 -070022 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 *
25 * Notes:
26 * These APIs are based on the C library functions. The semantics
27 * should match the C functions but with expanded size operands.
28 *
29 * The upper/lower functions are based on a table created by mkupr.
30 * This is a compressed table of upper and lower case conversion.
31 *
32 */
33
34#include <asm/byteorder.h>
35#include <linux/types.h>
36#include <linux/nls.h>
37
38#define UNIUPR_NOLOWER /* Example to not expand lower case tables */
39
40/* Just define what we want from uniupr.h. We don't want to define the tables
41 * in each source file.
42 */
43#ifndef UNICASERANGE_DEFINED
44struct UniCaseRange {
45 wchar_t start;
46 wchar_t end;
47 signed char *table;
48};
49#endif /* UNICASERANGE_DEFINED */
50
51#ifndef UNIUPR_NOUPPER
52extern signed char CifsUniUpperTable[512];
53extern const struct UniCaseRange CifsUniUpperRange[];
54#endif /* UNIUPR_NOUPPER */
55
56#ifndef UNIUPR_NOLOWER
57extern signed char UniLowerTable[512];
58extern struct UniCaseRange UniLowerRange[];
59#endif /* UNIUPR_NOLOWER */
60
61#ifdef __KERNEL__
Steve Frenche89dc922005-11-11 15:18:19 -080062int cifs_strfromUCS_le(char *, const __le16 *, int, const struct nls_table *);
63int cifs_strtoUCS(__le16 *, const char *, int, const struct nls_table *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#endif
65
66/*
67 * UniStrcat: Concatenate the second string to the first
68 *
69 * Returns:
70 * Address of the first string
71 */
72static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +000073UniStrcat(wchar_t *ucs1, const wchar_t *ucs2)
Linus Torvalds1da177e2005-04-16 15:20:36 -070074{
75 wchar_t *anchor = ucs1; /* save a pointer to start of ucs1 */
76
77 while (*ucs1++) ; /* To end of first string */
78 ucs1--; /* Return to the null */
79 while ((*ucs1++ = *ucs2++)) ; /* copy string 2 over */
80 return anchor;
81}
82
83/*
84 * UniStrchr: Find a character in a string
85 *
86 * Returns:
87 * Address of first occurrence of character in string
88 * or NULL if the character is not in the string
89 */
90static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +000091UniStrchr(const wchar_t *ucs, wchar_t uc)
Linus Torvalds1da177e2005-04-16 15:20:36 -070092{
93 while ((*ucs != uc) && *ucs)
94 ucs++;
95
96 if (*ucs == uc)
97 return (wchar_t *) ucs;
98 return NULL;
99}
100
101/*
102 * UniStrcmp: Compare two strings
103 *
104 * Returns:
105 * < 0: First string is less than second
106 * = 0: Strings are equal
107 * > 0: First string is greater than second
108 */
109static inline int
Steve French50c2f752007-07-13 00:33:32 +0000110UniStrcmp(const wchar_t *ucs1, const wchar_t *ucs2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111{
112 while ((*ucs1 == *ucs2) && *ucs1) {
113 ucs1++;
114 ucs2++;
115 }
116 return (int) *ucs1 - (int) *ucs2;
117}
118
119/*
120 * UniStrcpy: Copy a string
121 */
122static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +0000123UniStrcpy(wchar_t *ucs1, const wchar_t *ucs2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124{
125 wchar_t *anchor = ucs1; /* save the start of result string */
126
127 while ((*ucs1++ = *ucs2++)) ;
128 return anchor;
129}
130
131/*
132 * UniStrlen: Return the length of a string (in 16 bit Unicode chars not bytes)
133 */
134static inline size_t
Steve French50c2f752007-07-13 00:33:32 +0000135UniStrlen(const wchar_t *ucs1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136{
137 int i = 0;
138
139 while (*ucs1++)
140 i++;
141 return i;
142}
143
144/*
Steve Frenchd38d8c72007-06-28 19:44:13 +0000145 * UniStrnlen: Return the length (in 16 bit Unicode chars not bytes) of a
146 * string (length limited)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 */
148static inline size_t
Steve French50c2f752007-07-13 00:33:32 +0000149UniStrnlen(const wchar_t *ucs1, int maxlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150{
151 int i = 0;
152
153 while (*ucs1++) {
154 i++;
155 if (i >= maxlen)
156 break;
157 }
158 return i;
159}
160
161/*
162 * UniStrncat: Concatenate length limited string
163 */
164static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +0000165UniStrncat(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166{
167 wchar_t *anchor = ucs1; /* save pointer to string 1 */
168
169 while (*ucs1++) ;
170 ucs1--; /* point to null terminator of s1 */
171 while (n-- && (*ucs1 = *ucs2)) { /* copy s2 after s1 */
172 ucs1++;
173 ucs2++;
174 }
175 *ucs1 = 0; /* Null terminate the result */
176 return (anchor);
177}
178
179/*
180 * UniStrncmp: Compare length limited string
181 */
182static inline int
Steve French50c2f752007-07-13 00:33:32 +0000183UniStrncmp(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184{
185 if (!n)
186 return 0; /* Null strings are equal */
187 while ((*ucs1 == *ucs2) && *ucs1 && --n) {
188 ucs1++;
189 ucs2++;
190 }
191 return (int) *ucs1 - (int) *ucs2;
192}
193
194/*
195 * UniStrncmp_le: Compare length limited string - native to little-endian
196 */
197static inline int
Steve French50c2f752007-07-13 00:33:32 +0000198UniStrncmp_le(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199{
200 if (!n)
201 return 0; /* Null strings are equal */
202 while ((*ucs1 == __le16_to_cpu(*ucs2)) && *ucs1 && --n) {
203 ucs1++;
204 ucs2++;
205 }
206 return (int) *ucs1 - (int) __le16_to_cpu(*ucs2);
207}
208
209/*
210 * UniStrncpy: Copy length limited string with pad
211 */
212static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +0000213UniStrncpy(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214{
215 wchar_t *anchor = ucs1;
216
217 while (n-- && *ucs2) /* Copy the strings */
218 *ucs1++ = *ucs2++;
219
220 n++;
221 while (n--) /* Pad with nulls */
222 *ucs1++ = 0;
223 return anchor;
224}
225
226/*
227 * UniStrncpy_le: Copy length limited string with pad to little-endian
228 */
229static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +0000230UniStrncpy_le(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231{
232 wchar_t *anchor = ucs1;
233
234 while (n-- && *ucs2) /* Copy the strings */
235 *ucs1++ = __le16_to_cpu(*ucs2++);
236
237 n++;
238 while (n--) /* Pad with nulls */
239 *ucs1++ = 0;
240 return anchor;
241}
242
243/*
244 * UniStrstr: Find a string in a string
245 *
246 * Returns:
247 * Address of first match found
248 * NULL if no matching string is found
249 */
250static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +0000251UniStrstr(const wchar_t *ucs1, const wchar_t *ucs2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252{
253 const wchar_t *anchor1 = ucs1;
254 const wchar_t *anchor2 = ucs2;
255
256 while (*ucs1) {
257 if (*ucs1 == *ucs2) { /* Partial match found */
258 ucs1++;
259 ucs2++;
260 } else {
261 if (!*ucs2) /* Match found */
262 return (wchar_t *) anchor1;
263 ucs1 = ++anchor1; /* No match */
264 ucs2 = anchor2;
265 }
266 }
267
268 if (!*ucs2) /* Both end together */
269 return (wchar_t *) anchor1; /* Match found */
270 return NULL; /* No match */
271}
272
273#ifndef UNIUPR_NOUPPER
274/*
275 * UniToupper: Convert a unicode character to upper case
276 */
277static inline wchar_t
278UniToupper(register wchar_t uc)
279{
280 register const struct UniCaseRange *rp;
281
282 if (uc < sizeof (CifsUniUpperTable)) { /* Latin characters */
283 return uc + CifsUniUpperTable[uc]; /* Use base tables */
284 } else {
285 rp = CifsUniUpperRange; /* Use range tables */
286 while (rp->start) {
287 if (uc < rp->start) /* Before start of range */
288 return uc; /* Uppercase = input */
289 if (uc <= rp->end) /* In range */
290 return uc + rp->table[uc - rp->start];
291 rp++; /* Try next range */
292 }
293 }
294 return uc; /* Past last range */
295}
296
297/*
298 * UniStrupr: Upper case a unicode string
299 */
300static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +0000301UniStrupr(register wchar_t *upin)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302{
303 register wchar_t *up;
304
305 up = upin;
306 while (*up) { /* For all characters */
307 *up = UniToupper(*up);
308 up++;
309 }
310 return upin; /* Return input pointer */
311}
312#endif /* UNIUPR_NOUPPER */
313
314#ifndef UNIUPR_NOLOWER
315/*
316 * UniTolower: Convert a unicode character to lower case
317 */
318static inline wchar_t
319UniTolower(wchar_t uc)
320{
321 register struct UniCaseRange *rp;
322
323 if (uc < sizeof (UniLowerTable)) { /* Latin characters */
324 return uc + UniLowerTable[uc]; /* Use base tables */
325 } else {
326 rp = UniLowerRange; /* Use range tables */
327 while (rp->start) {
328 if (uc < rp->start) /* Before start of range */
329 return uc; /* Uppercase = input */
330 if (uc <= rp->end) /* In range */
331 return uc + rp->table[uc - rp->start];
332 rp++; /* Try next range */
333 }
334 }
335 return uc; /* Past last range */
336}
337
338/*
339 * UniStrlwr: Lower case a unicode string
340 */
341static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +0000342UniStrlwr(register wchar_t *upin)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343{
344 register wchar_t *up;
345
346 up = upin;
347 while (*up) { /* For all characters */
348 *up = UniTolower(*up);
349 up++;
350 }
351 return upin; /* Return input pointer */
352}
353
354#endif