blob: 650638275a6feed35d31fdbc183e57092b872f33 [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 Frenchd185cda2009-04-30 17:45:10 +00008 * Copyright (c) International Business Machines Corp., 2000,2009
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
Jeff Layton66345f52009-04-30 06:45:08 -040040/*
41 * Windows maps these to the user defined 16 bit Unicode range since they are
42 * reserved symbols (along with \ and /), otherwise illegal to store
43 * in filenames in NTFS
44 */
45#define UNI_ASTERIK (__u16) ('*' + 0xF000)
46#define UNI_QUESTION (__u16) ('?' + 0xF000)
47#define UNI_COLON (__u16) (':' + 0xF000)
48#define UNI_GRTRTHAN (__u16) ('>' + 0xF000)
49#define UNI_LESSTHAN (__u16) ('<' + 0xF000)
50#define UNI_PIPE (__u16) ('|' + 0xF000)
51#define UNI_SLASH (__u16) ('\\' + 0xF000)
52
Linus Torvalds1da177e2005-04-16 15:20:36 -070053/* Just define what we want from uniupr.h. We don't want to define the tables
54 * in each source file.
55 */
56#ifndef UNICASERANGE_DEFINED
57struct UniCaseRange {
58 wchar_t start;
59 wchar_t end;
60 signed char *table;
61};
62#endif /* UNICASERANGE_DEFINED */
63
64#ifndef UNIUPR_NOUPPER
65extern signed char CifsUniUpperTable[512];
66extern const struct UniCaseRange CifsUniUpperRange[];
67#endif /* UNIUPR_NOUPPER */
68
69#ifndef UNIUPR_NOLOWER
70extern signed char UniLowerTable[512];
71extern struct UniCaseRange UniLowerRange[];
72#endif /* UNIUPR_NOLOWER */
73
74#ifdef __KERNEL__
Jeff Layton7fabf0c2009-04-30 06:46:15 -040075int cifs_from_ucs2(char *to, const __le16 *from, int tolen, int fromlen,
76 const struct nls_table *codepage, bool mapchar);
Jeff Layton69f801f2009-04-30 06:46:32 -040077int cifs_ucs2_bytes(const __le16 *from, int maxbytes,
78 const struct nls_table *codepage);
Steve Frenche89dc922005-11-11 15:18:19 -080079int cifs_strtoUCS(__le16 *, const char *, int, const struct nls_table *);
Steve Frenchd185cda2009-04-30 17:45:10 +000080char *cifs_strndup_from_ucs(const char *src, const int maxlen,
81 const bool is_unicode,
82 const struct nls_table *codepage);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083#endif
84
85/*
86 * UniStrcat: Concatenate the second string to the first
87 *
88 * Returns:
89 * Address of the first string
90 */
91static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +000092UniStrcat(wchar_t *ucs1, const wchar_t *ucs2)
Linus Torvalds1da177e2005-04-16 15:20:36 -070093{
94 wchar_t *anchor = ucs1; /* save a pointer to start of ucs1 */
95
96 while (*ucs1++) ; /* To end of first string */
97 ucs1--; /* Return to the null */
98 while ((*ucs1++ = *ucs2++)) ; /* copy string 2 over */
99 return anchor;
100}
101
102/*
103 * UniStrchr: Find a character in a string
104 *
105 * Returns:
106 * Address of first occurrence of character in string
107 * or NULL if the character is not in the string
108 */
109static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +0000110UniStrchr(const wchar_t *ucs, wchar_t uc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111{
112 while ((*ucs != uc) && *ucs)
113 ucs++;
114
115 if (*ucs == uc)
116 return (wchar_t *) ucs;
117 return NULL;
118}
119
120/*
121 * UniStrcmp: Compare two strings
122 *
123 * Returns:
124 * < 0: First string is less than second
125 * = 0: Strings are equal
126 * > 0: First string is greater than second
127 */
128static inline int
Steve French50c2f752007-07-13 00:33:32 +0000129UniStrcmp(const wchar_t *ucs1, const wchar_t *ucs2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130{
131 while ((*ucs1 == *ucs2) && *ucs1) {
132 ucs1++;
133 ucs2++;
134 }
135 return (int) *ucs1 - (int) *ucs2;
136}
137
138/*
139 * UniStrcpy: Copy a string
140 */
141static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +0000142UniStrcpy(wchar_t *ucs1, const wchar_t *ucs2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143{
144 wchar_t *anchor = ucs1; /* save the start of result string */
145
146 while ((*ucs1++ = *ucs2++)) ;
147 return anchor;
148}
149
150/*
151 * UniStrlen: Return the length of a string (in 16 bit Unicode chars not bytes)
152 */
153static inline size_t
Steve French50c2f752007-07-13 00:33:32 +0000154UniStrlen(const wchar_t *ucs1)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155{
156 int i = 0;
157
158 while (*ucs1++)
159 i++;
160 return i;
161}
162
163/*
Steve Frenchd38d8c72007-06-28 19:44:13 +0000164 * UniStrnlen: Return the length (in 16 bit Unicode chars not bytes) of a
165 * string (length limited)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 */
167static inline size_t
Steve French50c2f752007-07-13 00:33:32 +0000168UniStrnlen(const wchar_t *ucs1, int maxlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169{
170 int i = 0;
171
172 while (*ucs1++) {
173 i++;
174 if (i >= maxlen)
175 break;
176 }
177 return i;
178}
179
180/*
181 * UniStrncat: Concatenate length limited string
182 */
183static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +0000184UniStrncat(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185{
186 wchar_t *anchor = ucs1; /* save pointer to string 1 */
187
188 while (*ucs1++) ;
189 ucs1--; /* point to null terminator of s1 */
190 while (n-- && (*ucs1 = *ucs2)) { /* copy s2 after s1 */
191 ucs1++;
192 ucs2++;
193 }
194 *ucs1 = 0; /* Null terminate the result */
195 return (anchor);
196}
197
198/*
199 * UniStrncmp: Compare length limited string
200 */
201static inline int
Steve French50c2f752007-07-13 00:33:32 +0000202UniStrncmp(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203{
204 if (!n)
205 return 0; /* Null strings are equal */
206 while ((*ucs1 == *ucs2) && *ucs1 && --n) {
207 ucs1++;
208 ucs2++;
209 }
210 return (int) *ucs1 - (int) *ucs2;
211}
212
213/*
214 * UniStrncmp_le: Compare length limited string - native to little-endian
215 */
216static inline int
Steve French50c2f752007-07-13 00:33:32 +0000217UniStrncmp_le(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
219 if (!n)
220 return 0; /* Null strings are equal */
221 while ((*ucs1 == __le16_to_cpu(*ucs2)) && *ucs1 && --n) {
222 ucs1++;
223 ucs2++;
224 }
225 return (int) *ucs1 - (int) __le16_to_cpu(*ucs2);
226}
227
228/*
229 * UniStrncpy: Copy length limited string with pad
230 */
231static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +0000232UniStrncpy(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233{
234 wchar_t *anchor = ucs1;
235
236 while (n-- && *ucs2) /* Copy the strings */
237 *ucs1++ = *ucs2++;
238
239 n++;
240 while (n--) /* Pad with nulls */
241 *ucs1++ = 0;
242 return anchor;
243}
244
245/*
246 * UniStrncpy_le: Copy length limited string with pad to little-endian
247 */
248static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +0000249UniStrncpy_le(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250{
251 wchar_t *anchor = ucs1;
252
253 while (n-- && *ucs2) /* Copy the strings */
254 *ucs1++ = __le16_to_cpu(*ucs2++);
255
256 n++;
257 while (n--) /* Pad with nulls */
258 *ucs1++ = 0;
259 return anchor;
260}
261
262/*
263 * UniStrstr: Find a string in a string
264 *
265 * Returns:
266 * Address of first match found
267 * NULL if no matching string is found
268 */
269static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +0000270UniStrstr(const wchar_t *ucs1, const wchar_t *ucs2)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271{
272 const wchar_t *anchor1 = ucs1;
273 const wchar_t *anchor2 = ucs2;
274
275 while (*ucs1) {
Steve Frenchad7a2922008-02-07 23:25:02 +0000276 if (*ucs1 == *ucs2) {
277 /* Partial match found */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 ucs1++;
279 ucs2++;
280 } else {
281 if (!*ucs2) /* Match found */
282 return (wchar_t *) anchor1;
283 ucs1 = ++anchor1; /* No match */
284 ucs2 = anchor2;
285 }
286 }
287
288 if (!*ucs2) /* Both end together */
289 return (wchar_t *) anchor1; /* Match found */
290 return NULL; /* No match */
291}
292
293#ifndef UNIUPR_NOUPPER
294/*
295 * UniToupper: Convert a unicode character to upper case
296 */
297static inline wchar_t
298UniToupper(register wchar_t uc)
299{
300 register const struct UniCaseRange *rp;
301
Steve Frenchad7a2922008-02-07 23:25:02 +0000302 if (uc < sizeof(CifsUniUpperTable)) {
303 /* Latin characters */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 return uc + CifsUniUpperTable[uc]; /* Use base tables */
305 } else {
306 rp = CifsUniUpperRange; /* Use range tables */
307 while (rp->start) {
308 if (uc < rp->start) /* Before start of range */
309 return uc; /* Uppercase = input */
310 if (uc <= rp->end) /* In range */
311 return uc + rp->table[uc - rp->start];
312 rp++; /* Try next range */
313 }
314 }
315 return uc; /* Past last range */
316}
317
318/*
319 * UniStrupr: Upper case a unicode string
320 */
321static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +0000322UniStrupr(register wchar_t *upin)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323{
324 register wchar_t *up;
325
326 up = upin;
327 while (*up) { /* For all characters */
328 *up = UniToupper(*up);
329 up++;
330 }
331 return upin; /* Return input pointer */
332}
333#endif /* UNIUPR_NOUPPER */
334
335#ifndef UNIUPR_NOLOWER
336/*
337 * UniTolower: Convert a unicode character to lower case
338 */
339static inline wchar_t
340UniTolower(wchar_t uc)
341{
342 register struct UniCaseRange *rp;
343
Steve Frenchad7a2922008-02-07 23:25:02 +0000344 if (uc < sizeof(UniLowerTable)) {
345 /* Latin characters */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 return uc + UniLowerTable[uc]; /* Use base tables */
347 } else {
348 rp = UniLowerRange; /* Use range tables */
349 while (rp->start) {
350 if (uc < rp->start) /* Before start of range */
351 return uc; /* Uppercase = input */
352 if (uc <= rp->end) /* In range */
353 return uc + rp->table[uc - rp->start];
354 rp++; /* Try next range */
355 }
356 }
357 return uc; /* Past last range */
358}
359
360/*
361 * UniStrlwr: Lower case a unicode string
362 */
363static inline wchar_t *
Steve French50c2f752007-07-13 00:33:32 +0000364UniStrlwr(register wchar_t *upin)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365{
366 register wchar_t *up;
367
368 up = upin;
369 while (*up) { /* For all characters */
370 *up = UniTolower(*up);
371 up++;
372 }
373 return upin; /* Return input pointer */
374}
375
376#endif