Blame view
fs/cifs/cifs_unicode.h
9.56 KB
1a59d1b8e
|
1 |
/* SPDX-License-Identifier: GPL-2.0-or-later */ |
1da177e4c
|
2 3 4 5 6 7 8 |
/* * cifs_unicode: Unicode kernel case support * * Function: * Convert a unicode character to upper or lower case using * compressed tables. * |
d185cda77
|
9 |
* Copyright (c) International Business Machines Corp., 2000,2009 |
1da177e4c
|
10 |
* |
1da177e4c
|
11 12 13 14 15 16 |
* Notes: * These APIs are based on the C library functions. The semantics * should match the C functions but with expanded size operands. * * The upper/lower functions are based on a table created by mkupr. * This is a compressed table of upper and lower case conversion. |
1da177e4c
|
17 |
*/ |
bf4f12113
|
18 19 |
#ifndef _CIFS_UNICODE_H #define _CIFS_UNICODE_H |
1da177e4c
|
20 21 22 23 24 25 |
#include <asm/byteorder.h> #include <linux/types.h> #include <linux/nls.h> #define UNIUPR_NOLOWER /* Example to not expand lower case tables */ |
66345f50f
|
26 27 28 29 30 |
/* * Windows maps these to the user defined 16 bit Unicode range since they are * reserved symbols (along with \ and /), otherwise illegal to store * in filenames in NTFS */ |
581ade4d1
|
31 |
#define UNI_ASTERISK (__u16) ('*' + 0xF000) |
66345f50f
|
32 33 34 35 36 37 |
#define UNI_QUESTION (__u16) ('?' + 0xF000) #define UNI_COLON (__u16) (':' + 0xF000) #define UNI_GRTRTHAN (__u16) ('>' + 0xF000) #define UNI_LESSTHAN (__u16) ('<' + 0xF000) #define UNI_PIPE (__u16) ('|' + 0xF000) #define UNI_SLASH (__u16) ('\\' + 0xF000) |
b693855fe
|
38 39 40 41 |
/* * Macs use an older "SFM" mapping of the symbols above. Fortunately it does * not conflict (although almost does) with the mapping above. */ |
85435d7a1
|
42 |
#define SFM_DOUBLEQUOTE ((__u16) 0xF020) |
b693855fe
|
43 44 45 46 47 48 49 |
#define SFM_ASTERISK ((__u16) 0xF021) #define SFM_QUESTION ((__u16) 0xF025) #define SFM_COLON ((__u16) 0xF022) #define SFM_GRTRTHAN ((__u16) 0xF024) #define SFM_LESSTHAN ((__u16) 0xF023) #define SFM_PIPE ((__u16) 0xF027) #define SFM_SLASH ((__u16) 0xF026) |
b704e70b7
|
50 51 |
#define SFM_SPACE ((__u16) 0xF028) #define SFM_PERIOD ((__u16) 0xF029) |
b693855fe
|
52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 |
/* * Mapping mechanism to use when one of the seven reserved characters is * encountered. We can only map using one of the mechanisms at a time * since otherwise readdir could return directory entries which we would * not be able to open * * NO_MAP_UNI_RSVD = do not perform any remapping of the character * SFM_MAP_UNI_RSVD = map reserved characters using SFM scheme (MAC compatible) * SFU_MAP_UNI_RSVD = map reserved characters ala SFU ("mapchars" option) * */ #define NO_MAP_UNI_RSVD 0 #define SFM_MAP_UNI_RSVD 1 #define SFU_MAP_UNI_RSVD 2 |
1da177e4c
|
67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 |
/* Just define what we want from uniupr.h. We don't want to define the tables * in each source file. */ #ifndef UNICASERANGE_DEFINED struct UniCaseRange { wchar_t start; wchar_t end; signed char *table; }; #endif /* UNICASERANGE_DEFINED */ #ifndef UNIUPR_NOUPPER extern signed char CifsUniUpperTable[512]; extern const struct UniCaseRange CifsUniUpperRange[]; #endif /* UNIUPR_NOUPPER */ #ifndef UNIUPR_NOLOWER |
bf4f12113
|
84 85 |
extern signed char CifsUniLowerTable[512]; extern const struct UniCaseRange CifsUniLowerRange[]; |
1da177e4c
|
86 87 88 |
#endif /* UNIUPR_NOLOWER */ #ifdef __KERNEL__ |
acbbb76a2
|
89 |
int cifs_from_utf16(char *to, const __le16 *from, int tolen, int fromlen, |
b693855fe
|
90 |
const struct nls_table *cp, int map_type); |
acbbb76a2
|
91 92 93 94 95 96 97 98 |
int cifs_utf16_bytes(const __le16 *from, int maxbytes, const struct nls_table *codepage); int cifs_strtoUTF16(__le16 *, const char *, int, const struct nls_table *); char *cifs_strndup_from_utf16(const char *src, const int maxlen, const bool is_unicode, const struct nls_table *codepage); extern int cifsConvertToUTF16(__le16 *target, const char *source, int maxlen, const struct nls_table *cp, int mapChars); |
2baa26825
|
99 |
extern int cifs_remap(struct cifs_sb_info *cifs_sb); |
2503a0dba
|
100 101 102 |
extern __le16 *cifs_strndup_to_utf16(const char *src, const int maxlen, int *utf16_len, const struct nls_table *cp, int remap); |
1da177e4c
|
103 |
#endif |
c2ccf53dd
|
104 |
wchar_t cifs_toupper(wchar_t in); |
1da177e4c
|
105 106 107 108 109 110 |
/* * UniStrcat: Concatenate the second string to the first * * Returns: * Address of the first string */ |
284316dd4
|
111 112 |
static inline __le16 * UniStrcat(__le16 *ucs1, const __le16 *ucs2) |
1da177e4c
|
113 |
{ |
284316dd4
|
114 |
__le16 *anchor = ucs1; /* save a pointer to start of ucs1 */ |
1da177e4c
|
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 |
while (*ucs1++) ; /* To end of first string */ ucs1--; /* Return to the null */ while ((*ucs1++ = *ucs2++)) ; /* copy string 2 over */ return anchor; } /* * UniStrchr: Find a character in a string * * Returns: * Address of first occurrence of character in string * or NULL if the character is not in the string */ static inline wchar_t * |
50c2f7538
|
130 |
UniStrchr(const wchar_t *ucs, wchar_t uc) |
1da177e4c
|
131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 |
{ while ((*ucs != uc) && *ucs) ucs++; if (*ucs == uc) return (wchar_t *) ucs; return NULL; } /* * UniStrcmp: Compare two strings * * Returns: * < 0: First string is less than second * = 0: Strings are equal * > 0: First string is greater than second */ static inline int |
50c2f7538
|
149 |
UniStrcmp(const wchar_t *ucs1, const wchar_t *ucs2) |
1da177e4c
|
150 151 152 153 154 155 156 157 158 159 160 161 |
{ while ((*ucs1 == *ucs2) && *ucs1) { ucs1++; ucs2++; } return (int) *ucs1 - (int) *ucs2; } /* * UniStrcpy: Copy a string */ static inline wchar_t * |
50c2f7538
|
162 |
UniStrcpy(wchar_t *ucs1, const wchar_t *ucs2) |
1da177e4c
|
163 164 165 166 167 168 169 170 171 172 173 |
{ wchar_t *anchor = ucs1; /* save the start of result string */ while ((*ucs1++ = *ucs2++)) ; return anchor; } /* * UniStrlen: Return the length of a string (in 16 bit Unicode chars not bytes) */ static inline size_t |
50c2f7538
|
174 |
UniStrlen(const wchar_t *ucs1) |
1da177e4c
|
175 176 177 178 179 180 181 182 183 |
{ int i = 0; while (*ucs1++) i++; return i; } /* |
d38d8c74c
|
184 185 |
* UniStrnlen: Return the length (in 16 bit Unicode chars not bytes) of a * string (length limited) |
1da177e4c
|
186 187 |
*/ static inline size_t |
50c2f7538
|
188 |
UniStrnlen(const wchar_t *ucs1, int maxlen) |
1da177e4c
|
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 |
{ int i = 0; while (*ucs1++) { i++; if (i >= maxlen) break; } return i; } /* * UniStrncat: Concatenate length limited string */ static inline wchar_t * |
50c2f7538
|
204 |
UniStrncat(wchar_t *ucs1, const wchar_t *ucs2, size_t n) |
1da177e4c
|
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 |
{ wchar_t *anchor = ucs1; /* save pointer to string 1 */ while (*ucs1++) ; ucs1--; /* point to null terminator of s1 */ while (n-- && (*ucs1 = *ucs2)) { /* copy s2 after s1 */ ucs1++; ucs2++; } *ucs1 = 0; /* Null terminate the result */ return (anchor); } /* * UniStrncmp: Compare length limited string */ static inline int |
50c2f7538
|
222 |
UniStrncmp(const wchar_t *ucs1, const wchar_t *ucs2, size_t n) |
1da177e4c
|
223 224 225 226 227 228 229 230 231 232 233 234 235 236 |
{ if (!n) return 0; /* Null strings are equal */ while ((*ucs1 == *ucs2) && *ucs1 && --n) { ucs1++; ucs2++; } return (int) *ucs1 - (int) *ucs2; } /* * UniStrncmp_le: Compare length limited string - native to little-endian */ static inline int |
50c2f7538
|
237 |
UniStrncmp_le(const wchar_t *ucs1, const wchar_t *ucs2, size_t n) |
1da177e4c
|
238 239 240 241 242 243 244 245 246 247 248 249 250 251 |
{ if (!n) return 0; /* Null strings are equal */ while ((*ucs1 == __le16_to_cpu(*ucs2)) && *ucs1 && --n) { ucs1++; ucs2++; } return (int) *ucs1 - (int) __le16_to_cpu(*ucs2); } /* * UniStrncpy: Copy length limited string with pad */ static inline wchar_t * |
50c2f7538
|
252 |
UniStrncpy(wchar_t *ucs1, const wchar_t *ucs2, size_t n) |
1da177e4c
|
253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 |
{ wchar_t *anchor = ucs1; while (n-- && *ucs2) /* Copy the strings */ *ucs1++ = *ucs2++; n++; while (n--) /* Pad with nulls */ *ucs1++ = 0; return anchor; } /* * UniStrncpy_le: Copy length limited string with pad to little-endian */ static inline wchar_t * |
50c2f7538
|
269 |
UniStrncpy_le(wchar_t *ucs1, const wchar_t *ucs2, size_t n) |
1da177e4c
|
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 |
{ wchar_t *anchor = ucs1; while (n-- && *ucs2) /* Copy the strings */ *ucs1++ = __le16_to_cpu(*ucs2++); n++; while (n--) /* Pad with nulls */ *ucs1++ = 0; return anchor; } /* * UniStrstr: Find a string in a string * * Returns: * Address of first match found * NULL if no matching string is found */ static inline wchar_t * |
50c2f7538
|
290 |
UniStrstr(const wchar_t *ucs1, const wchar_t *ucs2) |
1da177e4c
|
291 292 293 294 295 |
{ const wchar_t *anchor1 = ucs1; const wchar_t *anchor2 = ucs2; while (*ucs1) { |
ad7a2926b
|
296 297 |
if (*ucs1 == *ucs2) { /* Partial match found */ |
1da177e4c
|
298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 |
ucs1++; ucs2++; } else { if (!*ucs2) /* Match found */ return (wchar_t *) anchor1; ucs1 = ++anchor1; /* No match */ ucs2 = anchor2; } } if (!*ucs2) /* Both end together */ return (wchar_t *) anchor1; /* Match found */ return NULL; /* No match */ } #ifndef UNIUPR_NOUPPER /* * UniToupper: Convert a unicode character to upper case */ static inline wchar_t UniToupper(register wchar_t uc) { register const struct UniCaseRange *rp; |
ad7a2926b
|
321 322 |
if (uc < sizeof(CifsUniUpperTable)) { /* Latin characters */ |
1da177e4c
|
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 |
return uc + CifsUniUpperTable[uc]; /* Use base tables */ } else { rp = CifsUniUpperRange; /* Use range tables */ while (rp->start) { if (uc < rp->start) /* Before start of range */ return uc; /* Uppercase = input */ if (uc <= rp->end) /* In range */ return uc + rp->table[uc - rp->start]; rp++; /* Try next range */ } } return uc; /* Past last range */ } /* * UniStrupr: Upper case a unicode string */ |
fdf96a907
|
340 341 |
static inline __le16 * UniStrupr(register __le16 *upin) |
1da177e4c
|
342 |
{ |
fdf96a907
|
343 |
register __le16 *up; |
1da177e4c
|
344 345 346 |
up = upin; while (*up) { /* For all characters */ |
fdf96a907
|
347 |
*up = cpu_to_le16(UniToupper(le16_to_cpu(*up))); |
1da177e4c
|
348 349 350 351 352 353 354 355 356 357 358 |
up++; } return upin; /* Return input pointer */ } #endif /* UNIUPR_NOUPPER */ #ifndef UNIUPR_NOLOWER /* * UniTolower: Convert a unicode character to lower case */ static inline wchar_t |
bf4f12113
|
359 |
UniTolower(register wchar_t uc) |
1da177e4c
|
360 |
{ |
bf4f12113
|
361 |
register const struct UniCaseRange *rp; |
1da177e4c
|
362 |
|
bf4f12113
|
363 |
if (uc < sizeof(CifsUniLowerTable)) { |
ad7a2926b
|
364 |
/* Latin characters */ |
bf4f12113
|
365 |
return uc + CifsUniLowerTable[uc]; /* Use base tables */ |
1da177e4c
|
366 |
} else { |
bf4f12113
|
367 |
rp = CifsUniLowerRange; /* Use range tables */ |
1da177e4c
|
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 |
while (rp->start) { if (uc < rp->start) /* Before start of range */ return uc; /* Uppercase = input */ if (uc <= rp->end) /* In range */ return uc + rp->table[uc - rp->start]; rp++; /* Try next range */ } } return uc; /* Past last range */ } /* * UniStrlwr: Lower case a unicode string */ static inline wchar_t * |
50c2f7538
|
383 |
UniStrlwr(register wchar_t *upin) |
1da177e4c
|
384 385 386 387 388 389 390 391 392 393 394 395 |
{ register wchar_t *up; up = upin; while (*up) { /* For all characters */ *up = UniTolower(*up); up++; } return upin; /* Return input pointer */ } #endif |
bf4f12113
|
396 397 |
#endif /* _CIFS_UNICODE_H */ |