Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
cifs_unicode.h
Go to the documentation of this file.
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,2009
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 #ifndef _CIFS_UNICODE_H
34 #define _CIFS_UNICODE_H
35 
36 #include <asm/byteorder.h>
37 #include <linux/types.h>
38 #include <linux/nls.h>
39 
40 #define UNIUPR_NOLOWER /* Example to not expand lower case tables */
41 
42 /*
43  * Windows maps these to the user defined 16 bit Unicode range since they are
44  * reserved symbols (along with \ and /), otherwise illegal to store
45  * in filenames in NTFS
46  */
47 #define UNI_ASTERISK (__u16) ('*' + 0xF000)
48 #define UNI_QUESTION (__u16) ('?' + 0xF000)
49 #define UNI_COLON (__u16) (':' + 0xF000)
50 #define UNI_GRTRTHAN (__u16) ('>' + 0xF000)
51 #define UNI_LESSTHAN (__u16) ('<' + 0xF000)
52 #define UNI_PIPE (__u16) ('|' + 0xF000)
53 #define UNI_SLASH (__u16) ('\\' + 0xF000)
54 
55 /* Just define what we want from uniupr.h. We don't want to define the tables
56  * in each source file.
57  */
58 #ifndef UNICASERANGE_DEFINED
59 struct UniCaseRange {
60  wchar_t start;
61  wchar_t end;
62  signed char *table;
63 };
64 #endif /* UNICASERANGE_DEFINED */
65 
66 #ifndef UNIUPR_NOUPPER
67 extern signed char CifsUniUpperTable[512];
68 extern const struct UniCaseRange CifsUniUpperRange[];
69 #endif /* UNIUPR_NOUPPER */
70 
71 #ifndef UNIUPR_NOLOWER
72 extern signed char CifsUniLowerTable[512];
73 extern const struct UniCaseRange CifsUniLowerRange[];
74 #endif /* UNIUPR_NOLOWER */
75 
76 #ifdef __KERNEL__
77 int cifs_from_utf16(char *to, const __le16 *from, int tolen, int fromlen,
78  const struct nls_table *codepage, bool mapchar);
79 int cifs_utf16_bytes(const __le16 *from, int maxbytes,
80  const struct nls_table *codepage);
81 int cifs_strtoUTF16(__le16 *, const char *, int, const struct nls_table *);
82 char *cifs_strndup_from_utf16(const char *src, const int maxlen,
83  const bool is_unicode,
84  const struct nls_table *codepage);
85 extern int cifsConvertToUTF16(__le16 *target, const char *source, int maxlen,
86  const struct nls_table *cp, int mapChars);
87 #ifdef CONFIG_CIFS_SMB2
88 extern __le16 *cifs_strndup_to_utf16(const char *src, const int maxlen,
89  int *utf16_len, const struct nls_table *cp,
90  int remap);
91 #endif /* CONFIG_CIFS_SMB2 */
92 #endif
93 
94 /*
95  * UniStrcat: Concatenate the second string to the first
96  *
97  * Returns:
98  * Address of the first string
99  */
100 static inline wchar_t *
101 UniStrcat(wchar_t *ucs1, const wchar_t *ucs2)
102 {
103  wchar_t *anchor = ucs1; /* save a pointer to start of ucs1 */
104 
105  while (*ucs1++) ; /* To end of first string */
106  ucs1--; /* Return to the null */
107  while ((*ucs1++ = *ucs2++)) ; /* copy string 2 over */
108  return anchor;
109 }
110 
111 /*
112  * UniStrchr: Find a character in a string
113  *
114  * Returns:
115  * Address of first occurrence of character in string
116  * or NULL if the character is not in the string
117  */
118 static inline wchar_t *
119 UniStrchr(const wchar_t *ucs, wchar_t uc)
120 {
121  while ((*ucs != uc) && *ucs)
122  ucs++;
123 
124  if (*ucs == uc)
125  return (wchar_t *) ucs;
126  return NULL;
127 }
128 
129 /*
130  * UniStrcmp: Compare two strings
131  *
132  * Returns:
133  * < 0: First string is less than second
134  * = 0: Strings are equal
135  * > 0: First string is greater than second
136  */
137 static inline int
138 UniStrcmp(const wchar_t *ucs1, const wchar_t *ucs2)
139 {
140  while ((*ucs1 == *ucs2) && *ucs1) {
141  ucs1++;
142  ucs2++;
143  }
144  return (int) *ucs1 - (int) *ucs2;
145 }
146 
147 /*
148  * UniStrcpy: Copy a string
149  */
150 static inline wchar_t *
151 UniStrcpy(wchar_t *ucs1, const wchar_t *ucs2)
152 {
153  wchar_t *anchor = ucs1; /* save the start of result string */
154 
155  while ((*ucs1++ = *ucs2++)) ;
156  return anchor;
157 }
158 
159 /*
160  * UniStrlen: Return the length of a string (in 16 bit Unicode chars not bytes)
161  */
162 static inline size_t
163 UniStrlen(const wchar_t *ucs1)
164 {
165  int i = 0;
166 
167  while (*ucs1++)
168  i++;
169  return i;
170 }
171 
172 /*
173  * UniStrnlen: Return the length (in 16 bit Unicode chars not bytes) of a
174  * string (length limited)
175  */
176 static inline size_t
177 UniStrnlen(const wchar_t *ucs1, int maxlen)
178 {
179  int i = 0;
180 
181  while (*ucs1++) {
182  i++;
183  if (i >= maxlen)
184  break;
185  }
186  return i;
187 }
188 
189 /*
190  * UniStrncat: Concatenate length limited string
191  */
192 static inline wchar_t *
193 UniStrncat(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
194 {
195  wchar_t *anchor = ucs1; /* save pointer to string 1 */
196 
197  while (*ucs1++) ;
198  ucs1--; /* point to null terminator of s1 */
199  while (n-- && (*ucs1 = *ucs2)) { /* copy s2 after s1 */
200  ucs1++;
201  ucs2++;
202  }
203  *ucs1 = 0; /* Null terminate the result */
204  return (anchor);
205 }
206 
207 /*
208  * UniStrncmp: Compare length limited string
209  */
210 static inline int
211 UniStrncmp(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
212 {
213  if (!n)
214  return 0; /* Null strings are equal */
215  while ((*ucs1 == *ucs2) && *ucs1 && --n) {
216  ucs1++;
217  ucs2++;
218  }
219  return (int) *ucs1 - (int) *ucs2;
220 }
221 
222 /*
223  * UniStrncmp_le: Compare length limited string - native to little-endian
224  */
225 static inline int
226 UniStrncmp_le(const wchar_t *ucs1, const wchar_t *ucs2, size_t n)
227 {
228  if (!n)
229  return 0; /* Null strings are equal */
230  while ((*ucs1 == __le16_to_cpu(*ucs2)) && *ucs1 && --n) {
231  ucs1++;
232  ucs2++;
233  }
234  return (int) *ucs1 - (int) __le16_to_cpu(*ucs2);
235 }
236 
237 /*
238  * UniStrncpy: Copy length limited string with pad
239  */
240 static inline wchar_t *
241 UniStrncpy(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
242 {
243  wchar_t *anchor = ucs1;
244 
245  while (n-- && *ucs2) /* Copy the strings */
246  *ucs1++ = *ucs2++;
247 
248  n++;
249  while (n--) /* Pad with nulls */
250  *ucs1++ = 0;
251  return anchor;
252 }
253 
254 /*
255  * UniStrncpy_le: Copy length limited string with pad to little-endian
256  */
257 static inline wchar_t *
258 UniStrncpy_le(wchar_t *ucs1, const wchar_t *ucs2, size_t n)
259 {
260  wchar_t *anchor = ucs1;
261 
262  while (n-- && *ucs2) /* Copy the strings */
263  *ucs1++ = __le16_to_cpu(*ucs2++);
264 
265  n++;
266  while (n--) /* Pad with nulls */
267  *ucs1++ = 0;
268  return anchor;
269 }
270 
271 /*
272  * UniStrstr: Find a string in a string
273  *
274  * Returns:
275  * Address of first match found
276  * NULL if no matching string is found
277  */
278 static inline wchar_t *
279 UniStrstr(const wchar_t *ucs1, const wchar_t *ucs2)
280 {
281  const wchar_t *anchor1 = ucs1;
282  const wchar_t *anchor2 = ucs2;
283 
284  while (*ucs1) {
285  if (*ucs1 == *ucs2) {
286  /* Partial match found */
287  ucs1++;
288  ucs2++;
289  } else {
290  if (!*ucs2) /* Match found */
291  return (wchar_t *) anchor1;
292  ucs1 = ++anchor1; /* No match */
293  ucs2 = anchor2;
294  }
295  }
296 
297  if (!*ucs2) /* Both end together */
298  return (wchar_t *) anchor1; /* Match found */
299  return NULL; /* No match */
300 }
301 
302 #ifndef UNIUPR_NOUPPER
303 /*
304  * UniToupper: Convert a unicode character to upper case
305  */
306 static inline wchar_t
307 UniToupper(register wchar_t uc)
308 {
309  register const struct UniCaseRange *rp;
310 
311  if (uc < sizeof(CifsUniUpperTable)) {
312  /* Latin characters */
313  return uc + CifsUniUpperTable[uc]; /* Use base tables */
314  } else {
315  rp = CifsUniUpperRange; /* Use range tables */
316  while (rp->start) {
317  if (uc < rp->start) /* Before start of range */
318  return uc; /* Uppercase = input */
319  if (uc <= rp->end) /* In range */
320  return uc + rp->table[uc - rp->start];
321  rp++; /* Try next range */
322  }
323  }
324  return uc; /* Past last range */
325 }
326 
327 /*
328  * UniStrupr: Upper case a unicode string
329  */
330 static inline wchar_t *
331 UniStrupr(register wchar_t *upin)
332 {
333  register wchar_t *up;
334 
335  up = upin;
336  while (*up) { /* For all characters */
337  *up = UniToupper(*up);
338  up++;
339  }
340  return upin; /* Return input pointer */
341 }
342 #endif /* UNIUPR_NOUPPER */
343 
344 #ifndef UNIUPR_NOLOWER
345 /*
346  * UniTolower: Convert a unicode character to lower case
347  */
348 static inline wchar_t
349 UniTolower(register wchar_t uc)
350 {
351  register const struct UniCaseRange *rp;
352 
353  if (uc < sizeof(CifsUniLowerTable)) {
354  /* Latin characters */
355  return uc + CifsUniLowerTable[uc]; /* Use base tables */
356  } else {
357  rp = CifsUniLowerRange; /* Use range tables */
358  while (rp->start) {
359  if (uc < rp->start) /* Before start of range */
360  return uc; /* Uppercase = input */
361  if (uc <= rp->end) /* In range */
362  return uc + rp->table[uc - rp->start];
363  rp++; /* Try next range */
364  }
365  }
366  return uc; /* Past last range */
367 }
368 
369 /*
370  * UniStrlwr: Lower case a unicode string
371  */
372 static inline wchar_t *
373 UniStrlwr(register wchar_t *upin)
374 {
375  register wchar_t *up;
376 
377  up = upin;
378  while (*up) { /* For all characters */
379  *up = UniTolower(*up);
380  up++;
381  }
382  return upin; /* Return input pointer */
383 }
384 
385 #endif
386 
387 #endif /* _CIFS_UNICODE_H */