2 * cifs_unicode: Unicode kernel case support
5 * Convert a unicode character to upper or lower case using
8 * Copyright (c) International Business Machines Corp., 2000,2007
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
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * 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.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 * These APIs are based on the C library functions. The semantics
27 * should match the C functions but with expanded size operands.
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.
34 #include <asm/byteorder.h>
35 #include <linux/types.h>
36 #include <linux/nls.h>
38 #define UNIUPR_NOLOWER /* Example to not expand lower case tables */
40 /* Just define what we want from uniupr.h. We don't want to define the tables
41 * in each source file.
43 #ifndef UNICASERANGE_DEFINED
49 #endif /* UNICASERANGE_DEFINED */
51 #ifndef UNIUPR_NOUPPER
52 extern signed char CifsUniUpperTable[512];
53 extern const struct UniCaseRange CifsUniUpperRange[];
54 #endif /* UNIUPR_NOUPPER */
56 #ifndef UNIUPR_NOLOWER
57 extern signed char UniLowerTable[512];
58 extern struct UniCaseRange UniLowerRange[];
59 #endif /* UNIUPR_NOLOWER */
62 int cifs_strfromUCS_le(char *, const __le16 *, int, const struct nls_table *);
63 int cifs_strtoUCS(__le16 *, const char *, int, const struct nls_table *);
67 * To be safe - for UCS to UTF-8 with strings loaded with the rare long
68 * characters alloc more to account for such multibyte target UTF-8
71 #define UNICODE_NAME_MAX ((4 * NAME_MAX) + 2)
74 * UniStrcat: Concatenate the second string to the first
77 * Address of the first string
79 static inline wchar_t *
80 UniStrcat(wchar_t *ucs1, const wchar_t *ucs2)
82 wchar_t *anchor = ucs1; /* save a pointer to start of ucs1 */
84 while (*ucs1++) ; /* To end of first string */
85 ucs1--; /* Return to the null */
86 while ((*ucs1++ = *ucs2++)) ; /* copy string 2 over */
91 * UniStrchr: Find a character in a string
94 * Address of first occurrence of character in string
95 * or NULL if the character is not in the string
97 static inline wchar_t *
98 UniStrchr(const wchar_t *ucs, wchar_t uc)
100 while ((*ucs != uc) && *ucs)
104 return (wchar_t *) ucs;
109 * UniStrcmp: Compare two strings
112 * < 0: First string is less than second
113 * = 0: Strings are equal
114 * > 0: First string is greater than second
117 UniStrcmp(const wchar_t *ucs1, const wchar_t *ucs2)
119 while ((*ucs1 == *ucs2) && *ucs1) {
123 return (int) *ucs1 - (int) *ucs2;
127 * UniStrcpy: Copy a string
129 static inline wchar_t *
130 UniStrcpy(wchar_t *ucs1, const wchar_t *ucs2)
132 wchar_t *anchor = ucs1; /* save the start of result string */
134 while ((*ucs1++ = *ucs2++)) ;
139 * UniStrlen: Return the length of a string (in 16 bit Unicode chars not bytes)
142 UniStrlen(const wchar_t *ucs1)
152 * UniStrnlen: Return the length (in 16 bit Unicode chars not bytes) of a
153 * string (length limited)
156 UniStrnlen(const wchar_t *ucs1, int maxlen)
169 * UniStrncat: Concatenate length limited string
171 static inline wchar_t *
172 UniStrncat(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
174 wchar_t *anchor = ucs1; /* save pointer to string 1 */
177 ucs1--; /* point to null terminator of s1 */
178 while (n-- && (*ucs1 = *ucs2)) { /* copy s2 after s1 */
182 *ucs1 = 0; /* Null terminate the result */
187 * UniStrncmp: Compare length limited string
190 UniStrncmp(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
193 return 0; /* Null strings are equal */
194 while ((*ucs1 == *ucs2) && *ucs1 && --n) {
198 return (int) *ucs1 - (int) *ucs2;
202 * UniStrncmp_le: Compare length limited string - native to little-endian
205 UniStrncmp_le(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
208 return 0; /* Null strings are equal */
209 while ((*ucs1 == __le16_to_cpu(*ucs2)) && *ucs1 && --n) {
213 return (int) *ucs1 - (int) __le16_to_cpu(*ucs2);
217 * UniStrncpy: Copy length limited string with pad
219 static inline wchar_t *
220 UniStrncpy(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
222 wchar_t *anchor = ucs1;
224 while (n-- && *ucs2) /* Copy the strings */
228 while (n--) /* Pad with nulls */
234 * UniStrncpy_le: Copy length limited string with pad to little-endian
236 static inline wchar_t *
237 UniStrncpy_le(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
239 wchar_t *anchor = ucs1;
241 while (n-- && *ucs2) /* Copy the strings */
242 *ucs1++ = __le16_to_cpu(*ucs2++);
245 while (n--) /* Pad with nulls */
251 * UniStrstr: Find a string in a string
254 * Address of first match found
255 * NULL if no matching string is found
257 static inline wchar_t *
258 UniStrstr(const wchar_t *ucs1, const wchar_t *ucs2)
260 const wchar_t *anchor1 = ucs1;
261 const wchar_t *anchor2 = ucs2;
264 if (*ucs1 == *ucs2) {
265 /* Partial match found */
269 if (!*ucs2) /* Match found */
270 return (wchar_t *) anchor1;
271 ucs1 = ++anchor1; /* No match */
276 if (!*ucs2) /* Both end together */
277 return (wchar_t *) anchor1; /* Match found */
278 return NULL; /* No match */
281 #ifndef UNIUPR_NOUPPER
283 * UniToupper: Convert a unicode character to upper case
285 static inline wchar_t
286 UniToupper(register wchar_t uc)
288 register const struct UniCaseRange *rp;
290 if (uc < sizeof(CifsUniUpperTable)) {
291 /* Latin characters */
292 return uc + CifsUniUpperTable[uc]; /* Use base tables */
294 rp = CifsUniUpperRange; /* Use range tables */
296 if (uc < rp->start) /* Before start of range */
297 return uc; /* Uppercase = input */
298 if (uc <= rp->end) /* In range */
299 return uc + rp->table[uc - rp->start];
300 rp++; /* Try next range */
303 return uc; /* Past last range */
307 * UniStrupr: Upper case a unicode string
309 static inline wchar_t *
310 UniStrupr(register wchar_t *upin)
312 register wchar_t *up;
315 while (*up) { /* For all characters */
316 *up = UniToupper(*up);
319 return upin; /* Return input pointer */
321 #endif /* UNIUPR_NOUPPER */
323 #ifndef UNIUPR_NOLOWER
325 * UniTolower: Convert a unicode character to lower case
327 static inline wchar_t
328 UniTolower(wchar_t uc)
330 register struct UniCaseRange *rp;
332 if (uc < sizeof(UniLowerTable)) {
333 /* Latin characters */
334 return uc + UniLowerTable[uc]; /* Use base tables */
336 rp = UniLowerRange; /* Use range tables */
338 if (uc < rp->start) /* Before start of range */
339 return uc; /* Uppercase = input */
340 if (uc <= rp->end) /* In range */
341 return uc + rp->table[uc - rp->start];
342 rp++; /* Try next range */
345 return uc; /* Past last range */
349 * UniStrlwr: Lower case a unicode string
351 static inline wchar_t *
352 UniStrlwr(register wchar_t *upin)
354 register wchar_t *up;
357 while (*up) { /* For all characters */
358 *up = UniTolower(*up);
361 return upin; /* Return input pointer */