ia64/linux-2.6.18-xen.hg

view fs/cifs/cifs_unicode.h @ 524:7f8b544237bf

netfront: Allow netfront in domain 0.

This is useful if your physical network device is in a utility domain.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Tue Apr 15 15:18:58 2008 +0100 (2008-04-15)
parents 831230e53067
children
line source
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,2005555555555555555555555555555555555555555555555555555555
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 */
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.
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 */
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 */
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
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 */
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 }
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++;
96 if (*ucs == uc)
97 return (wchar_t *) ucs;
98 return NULL;
99 }
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 }
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 */
127 while ((*ucs1++ = *ucs2++)) ;
128 return anchor;
129 }
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;
139 while (*ucs1++)
140 i++;
141 return i;
142 }
144 /*
145 * UniStrnlen: Return the length (in 16 bit Unicode chars not bytes) of a string (length limited)
146 */
147 static inline size_t
148 UniStrnlen(const wchar_t * ucs1, int maxlen)
149 {
150 int i = 0;
152 while (*ucs1++) {
153 i++;
154 if (i >= maxlen)
155 break;
156 }
157 return i;
158 }
160 /*
161 * UniStrncat: Concatenate length limited string
162 */
163 static inline wchar_t *
164 UniStrncat(wchar_t * ucs1, const wchar_t * ucs2, size_t n)
165 {
166 wchar_t *anchor = ucs1; /* save pointer to string 1 */
168 while (*ucs1++) ;
169 ucs1--; /* point to null terminator of s1 */
170 while (n-- && (*ucs1 = *ucs2)) { /* copy s2 after s1 */
171 ucs1++;
172 ucs2++;
173 }
174 *ucs1 = 0; /* Null terminate the result */
175 return (anchor);
176 }
178 /*
179 * UniStrncmp: Compare length limited string
180 */
181 static inline int
182 UniStrncmp(const wchar_t * ucs1, const wchar_t * ucs2, size_t n)
183 {
184 if (!n)
185 return 0; /* Null strings are equal */
186 while ((*ucs1 == *ucs2) && *ucs1 && --n) {
187 ucs1++;
188 ucs2++;
189 }
190 return (int) *ucs1 - (int) *ucs2;
191 }
193 /*
194 * UniStrncmp_le: Compare length limited string - native to little-endian
195 */
196 static inline int
197 UniStrncmp_le(const wchar_t * ucs1, const wchar_t * ucs2, size_t n)
198 {
199 if (!n)
200 return 0; /* Null strings are equal */
201 while ((*ucs1 == __le16_to_cpu(*ucs2)) && *ucs1 && --n) {
202 ucs1++;
203 ucs2++;
204 }
205 return (int) *ucs1 - (int) __le16_to_cpu(*ucs2);
206 }
208 /*
209 * UniStrncpy: Copy length limited string with pad
210 */
211 static inline wchar_t *
212 UniStrncpy(wchar_t * ucs1, const wchar_t * ucs2, size_t n)
213 {
214 wchar_t *anchor = ucs1;
216 while (n-- && *ucs2) /* Copy the strings */
217 *ucs1++ = *ucs2++;
219 n++;
220 while (n--) /* Pad with nulls */
221 *ucs1++ = 0;
222 return anchor;
223 }
225 /*
226 * UniStrncpy_le: Copy length limited string with pad to little-endian
227 */
228 static inline wchar_t *
229 UniStrncpy_le(wchar_t * ucs1, const wchar_t * ucs2, size_t n)
230 {
231 wchar_t *anchor = ucs1;
233 while (n-- && *ucs2) /* Copy the strings */
234 *ucs1++ = __le16_to_cpu(*ucs2++);
236 n++;
237 while (n--) /* Pad with nulls */
238 *ucs1++ = 0;
239 return anchor;
240 }
242 /*
243 * UniStrstr: Find a string in a string
244 *
245 * Returns:
246 * Address of first match found
247 * NULL if no matching string is found
248 */
249 static inline wchar_t *
250 UniStrstr(const wchar_t * ucs1, const wchar_t * ucs2)
251 {
252 const wchar_t *anchor1 = ucs1;
253 const wchar_t *anchor2 = ucs2;
255 while (*ucs1) {
256 if (*ucs1 == *ucs2) { /* Partial match found */
257 ucs1++;
258 ucs2++;
259 } else {
260 if (!*ucs2) /* Match found */
261 return (wchar_t *) anchor1;
262 ucs1 = ++anchor1; /* No match */
263 ucs2 = anchor2;
264 }
265 }
267 if (!*ucs2) /* Both end together */
268 return (wchar_t *) anchor1; /* Match found */
269 return NULL; /* No match */
270 }
272 #ifndef UNIUPR_NOUPPER
273 /*
274 * UniToupper: Convert a unicode character to upper case
275 */
276 static inline wchar_t
277 UniToupper(register wchar_t uc)
278 {
279 register const struct UniCaseRange *rp;
281 if (uc < sizeof (CifsUniUpperTable)) { /* Latin characters */
282 return uc + CifsUniUpperTable[uc]; /* Use base tables */
283 } else {
284 rp = CifsUniUpperRange; /* Use range tables */
285 while (rp->start) {
286 if (uc < rp->start) /* Before start of range */
287 return uc; /* Uppercase = input */
288 if (uc <= rp->end) /* In range */
289 return uc + rp->table[uc - rp->start];
290 rp++; /* Try next range */
291 }
292 }
293 return uc; /* Past last range */
294 }
296 /*
297 * UniStrupr: Upper case a unicode string
298 */
299 static inline wchar_t *
300 UniStrupr(register wchar_t * upin)
301 {
302 register wchar_t *up;
304 up = upin;
305 while (*up) { /* For all characters */
306 *up = UniToupper(*up);
307 up++;
308 }
309 return upin; /* Return input pointer */
310 }
311 #endif /* UNIUPR_NOUPPER */
313 #ifndef UNIUPR_NOLOWER
314 /*
315 * UniTolower: Convert a unicode character to lower case
316 */
317 static inline wchar_t
318 UniTolower(wchar_t uc)
319 {
320 register struct UniCaseRange *rp;
322 if (uc < sizeof (UniLowerTable)) { /* Latin characters */
323 return uc + UniLowerTable[uc]; /* Use base tables */
324 } else {
325 rp = UniLowerRange; /* Use range tables */
326 while (rp->start) {
327 if (uc < rp->start) /* Before start of range */
328 return uc; /* Uppercase = input */
329 if (uc <= rp->end) /* In range */
330 return uc + rp->table[uc - rp->start];
331 rp++; /* Try next range */
332 }
333 }
334 return uc; /* Past last range */
335 }
337 /*
338 * UniStrlwr: Lower case a unicode string
339 */
340 static inline wchar_t *
341 UniStrlwr(register wchar_t * upin)
342 {
343 register wchar_t *up;
345 up = upin;
346 while (*up) { /* For all characters */
347 *up = UniTolower(*up);
348 up++;
349 }
350 return upin; /* Return input pointer */
351 }
353 #endif