Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / fs / cifs / cifs_unicode.h
1 /*
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  *
8  *   Copyright (c) International Business Machines  Corp., 2000,2007
9  *
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.
14  *
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.
19  *
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
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
44 struct UniCaseRange {
45         wchar_t start;
46         wchar_t end;
47         signed char *table;
48 };
49 #endif                          /* UNICASERANGE_DEFINED */
50
51 #ifndef UNIUPR_NOUPPER
52 extern signed char CifsUniUpperTable[512];
53 extern const struct UniCaseRange CifsUniUpperRange[];
54 #endif                          /* UNIUPR_NOUPPER */
55
56 #ifndef UNIUPR_NOLOWER
57 extern signed char UniLowerTable[512];
58 extern struct UniCaseRange UniLowerRange[];
59 #endif                          /* UNIUPR_NOLOWER */
60
61 #ifdef __KERNEL__
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 *);
64 #endif
65
66 /*
67  * UniStrcat:  Concatenate the second string to the first
68  *
69  * Returns:
70  *     Address of the first string
71  */
72 static inline wchar_t *
73 UniStrcat(wchar_t *ucs1, const wchar_t *ucs2)
74 {
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  */
90 static inline wchar_t *
91 UniStrchr(const wchar_t *ucs, wchar_t uc)
92 {
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  */
109 static inline int
110 UniStrcmp(const wchar_t *ucs1, const wchar_t *ucs2)
111 {
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  */
122 static inline wchar_t *
123 UniStrcpy(wchar_t *ucs1, const wchar_t *ucs2)
124 {
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  */
134 static inline size_t
135 UniStrlen(const wchar_t *ucs1)
136 {
137         int i = 0;
138
139         while (*ucs1++)
140                 i++;
141         return i;
142 }
143
144 /*
145  * UniStrnlen:  Return the length (in 16 bit Unicode chars not bytes) of a
146  *              string (length limited)
147  */
148 static inline size_t
149 UniStrnlen(const wchar_t *ucs1, int maxlen)
150 {
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  */
164 static inline wchar_t *
165 UniStrncat(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
166 {
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  */
182 static inline int
183 UniStrncmp(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
184 {
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  */
197 static inline int
198 UniStrncmp_le(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
199 {
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  */
212 static inline wchar_t *
213 UniStrncpy(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
214 {
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  */
229 static inline wchar_t *
230 UniStrncpy_le(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
231 {
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  */
250 static inline wchar_t *
251 UniStrstr(const wchar_t *ucs1, const wchar_t *ucs2)
252 {
253         const wchar_t *anchor1 = ucs1;
254         const wchar_t *anchor2 = ucs2;
255
256         while (*ucs1) {
257                 if (*ucs1 == *ucs2) {
258                         /* Partial match found */
259                         ucs1++;
260                         ucs2++;
261                 } else {
262                         if (!*ucs2)     /* Match found */
263                                 return (wchar_t *) anchor1;
264                         ucs1 = ++anchor1;       /* No match */
265                         ucs2 = anchor2;
266                 }
267         }
268
269         if (!*ucs2)             /* Both end together */
270                 return (wchar_t *) anchor1;     /* Match found */
271         return NULL;            /* No match */
272 }
273
274 #ifndef UNIUPR_NOUPPER
275 /*
276  * UniToupper:  Convert a unicode character to upper case
277  */
278 static inline wchar_t
279 UniToupper(register wchar_t uc)
280 {
281         register const struct UniCaseRange *rp;
282
283         if (uc < sizeof(CifsUniUpperTable)) {
284                 /* Latin characters */
285                 return uc + CifsUniUpperTable[uc];      /* Use base tables */
286         } else {
287                 rp = CifsUniUpperRange; /* Use range tables */
288                 while (rp->start) {
289                         if (uc < rp->start)     /* Before start of range */
290                                 return uc;      /* Uppercase = input */
291                         if (uc <= rp->end)      /* In range */
292                                 return uc + rp->table[uc - rp->start];
293                         rp++;   /* Try next range */
294                 }
295         }
296         return uc;              /* Past last range */
297 }
298
299 /*
300  * UniStrupr:  Upper case a unicode string
301  */
302 static inline wchar_t *
303 UniStrupr(register wchar_t *upin)
304 {
305         register wchar_t *up;
306
307         up = upin;
308         while (*up) {           /* For all characters */
309                 *up = UniToupper(*up);
310                 up++;
311         }
312         return upin;            /* Return input pointer */
313 }
314 #endif                          /* UNIUPR_NOUPPER */
315
316 #ifndef UNIUPR_NOLOWER
317 /*
318  * UniTolower:  Convert a unicode character to lower case
319  */
320 static inline wchar_t
321 UniTolower(wchar_t uc)
322 {
323         register struct UniCaseRange *rp;
324
325         if (uc < sizeof(UniLowerTable)) {
326                 /* Latin characters */
327                 return uc + UniLowerTable[uc];  /* Use base tables */
328         } else {
329                 rp = UniLowerRange;     /* Use range tables */
330                 while (rp->start) {
331                         if (uc < rp->start)     /* Before start of range */
332                                 return uc;      /* Uppercase = input */
333                         if (uc <= rp->end)      /* In range */
334                                 return uc + rp->table[uc - rp->start];
335                         rp++;   /* Try next range */
336                 }
337         }
338         return uc;              /* Past last range */
339 }
340
341 /*
342  * UniStrlwr:  Lower case a unicode string
343  */
344 static inline wchar_t *
345 UniStrlwr(register wchar_t *upin)
346 {
347         register wchar_t *up;
348
349         up = upin;
350         while (*up) {           /* For all characters */
351                 *up = UniTolower(*up);
352                 up++;
353         }
354         return upin;            /* Return input pointer */
355 }
356
357 #endif