release/src-rt-6.x/linux/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) {   /* Partial match found */
 258                         ucs1++;
 259                         ucs2++;
 260                 } else {
 261                         if (!*ucs2)     /* Match found */
 262                                 return (wchar_t *) anchor1;
 263                         ucs1 = ++anchor1;       /* No match */
 264                         ucs2 = anchor2;
 265                 }
 266         }
 267
 268         if (!*ucs2)             /* Both end together */
 269                 return (wchar_t *) anchor1;     /* Match found */
 270         return NULL;            /* No match */
 271 }
 272
 273 #ifndef UNIUPR_NOUPPER
 274 /*
 275  * UniToupper:  Convert a unicode character to upper case
 276  */
 277 static inline wchar_t
 278 UniToupper(register wchar_t uc)
 279 {
 280         register const struct UniCaseRange *rp;
 281
 282         if (uc < sizeof (CifsUniUpperTable)) {  /* Latin characters */
 283                 return uc + CifsUniUpperTable[uc];      /* Use base tables */
 284         } else {
 285                 rp = CifsUniUpperRange; /* Use range tables */
 286                 while (rp->start) {
 287                         if (uc < rp->start)     /* Before start of range */
 288                                 return uc;      /* Uppercase = input */
 289                         if (uc <= rp->end)      /* In range */
 290                                 return uc + rp->table[uc - rp->start];
 291                         rp++;   /* Try next range */
 292                 }
 293         }
 294         return uc;              /* Past last range */
 295 }
 296
 297 /*
 298  * UniStrupr:  Upper case a unicode string
 299  */
 300 static inline wchar_t *
 301 UniStrupr(register wchar_t *upin)
 302 {
 303         register wchar_t *up;
 304
 305         up = upin;
 306         while (*up) {           /* For all characters */
 307                 *up = UniToupper(*up);
 308                 up++;
 309         }
 310         return upin;            /* Return input pointer */
 311 }
 312 #endif                          /* UNIUPR_NOUPPER */
 313
 314 #ifndef UNIUPR_NOLOWER
 315 /*
 316  * UniTolower:  Convert a unicode character to lower case
 317  */
 318 static inline wchar_t
 319 UniTolower(wchar_t uc)
 320 {
 321         register struct UniCaseRange *rp;
 322
 323         if (uc < sizeof (UniLowerTable)) {      /* Latin characters */
 324                 return uc + UniLowerTable[uc];  /* Use base tables */
 325         } else {
 326                 rp = UniLowerRange;     /* Use range tables */
 327                 while (rp->start) {
 328                         if (uc < rp->start)     /* Before start of range */
 329                                 return uc;      /* Uppercase = input */
 330                         if (uc <= rp->end)      /* In range */
 331                                 return uc + rp->table[uc - rp->start];
 332                         rp++;   /* Try next range */
 333                 }
 334         }
 335         return uc;              /* Past last range */
 336 }
 337
 338 /*
 339  * UniStrlwr:  Lower case a unicode string
 340  */
 341 static inline wchar_t *
 342 UniStrlwr(register wchar_t *upin)
 343 {
 344         register wchar_t *up;
 345
 346         up = upin;
 347         while (*up) {           /* For all characters */
 348                 *up = UniTolower(*up);
 349                 up++;
 350         }
 351         return upin;            /* Return input pointer */
 352 }
 353
 354 #endif