Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 353 insertions, 0 deletions

diff --git a/fs/cifs/cifs_unicode.h b/fs/cifs/cifs_unicode.h
new file mode 100644
index 000000000000..da8dde965275
--- /dev/null
+++ b/fs/cifs/cifs_unicode.h
@@ -0,0 +1,353 @@
+/*
+ * cifs_unicode:  Unicode kernel case support
+ *
+ * Function:
+ *     Convert a unicode character to upper or lower case using
+ *     compressed tables.
+ *
+ *   Copyright (c) International Business Machines  Corp., 2000,2002
+ *
+ *   This program is free software;  you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or 
+ *   (at your option) any later version.
+ * 
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
+ *   the GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program;  if not, write to the Free Software 
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ *
+ * 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.
+ *
+ */
+
+#include <asm/byteorder.h>
+#include <linux/types.h>
+#include <linux/nls.h>
+
+#define  UNIUPR_NOLOWER         /* Example to not expand lower case tables */
+
+/* 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
+extern signed char UniLowerTable[512];
+extern struct UniCaseRange UniLowerRange[];
+#endif                          /* UNIUPR_NOLOWER */
+
+#ifdef __KERNEL__
+int cifs_strfromUCS_le(char *, const wchar_t *, int, const struct nls_table *);
+int cifs_strtoUCS(wchar_t *, const char *, int, const struct nls_table *);
+#endif
+
+/*
+ * UniStrcat:  Concatenate the second string to the first
+ *
+ * Returns:
+ *     Address of the first string
+ */
+static inline wchar_t *
+UniStrcat(wchar_t * ucs1, const wchar_t * ucs2)
+{
+        wchar_t *anchor = ucs1; /* save a pointer to start of ucs1 */
+
+        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 *
+UniStrchr(const wchar_t * ucs, wchar_t uc)
+{
+        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
+UniStrcmp(const wchar_t * ucs1, const wchar_t * ucs2)
+{
+        while ((*ucs1 == *ucs2) && *ucs1) {
+                ucs1++;
+                ucs2++;
+        }
+        return (int) *ucs1 - (int) *ucs2;
+}
+
+/*
+ * UniStrcpy:  Copy a string
+ */
+static inline wchar_t *
+UniStrcpy(wchar_t * ucs1, const wchar_t * ucs2)
+{
+        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
+UniStrlen(const wchar_t * ucs1)
+{
+        int i = 0;
+
+        while (*ucs1++)
+                i++;
+        return i;
+}
+
+/*
+ * UniStrnlen:  Return the length (in 16 bit Unicode chars not bytes) of a string (length limited)
+ */
+static inline size_t
+UniStrnlen(const wchar_t * ucs1, int maxlen)
+{
+        int i = 0;
+
+        while (*ucs1++) {
+                i++;
+                if (i >= maxlen)
+                        break;
+        }
+        return i;
+}
+
+/*
+ * UniStrncat:  Concatenate length limited string
+ */
+static inline wchar_t *
+UniStrncat(wchar_t * ucs1, const wchar_t * ucs2, size_t n)
+{
+        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
+UniStrncmp(const wchar_t * ucs1, const wchar_t * ucs2, size_t n)
+{
+        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
+UniStrncmp_le(const wchar_t * ucs1, const wchar_t * ucs2, size_t n)
+{
+        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 *
+UniStrncpy(wchar_t * ucs1, const wchar_t * ucs2, size_t n)
+{
+        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 *
+UniStrncpy_le(wchar_t * ucs1, const wchar_t * ucs2, size_t n)
+{
+        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 *
+UniStrstr(const wchar_t * ucs1, const wchar_t * ucs2)
+{
+        const wchar_t *anchor1 = ucs1;
+        const wchar_t *anchor2 = ucs2;
+
+        while (*ucs1) {
+                if (*ucs1 == *ucs2) {   /* Partial match found */
+                        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;
+
+        if (uc < sizeof (CifsUniUpperTable)) {  /* Latin characters */
+                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
+ */
+static inline wchar_t *
+UniStrupr(register wchar_t * upin)
+{
+        register wchar_t *up;
+
+        up = upin;
+        while (*up) {           /* For all characters */
+                *up = UniToupper(*up);
+                up++;
+        }
+        return upin;            /* Return input pointer */
+}
+#endif                          /* UNIUPR_NOUPPER */
+
+#ifndef UNIUPR_NOLOWER
+/*
+ * UniTolower:  Convert a unicode character to lower case
+ */
+static inline wchar_t
+UniTolower(wchar_t uc)
+{
+        register struct UniCaseRange *rp;
+
+        if (uc < sizeof (UniLowerTable)) {      /* Latin characters */
+                return uc + UniLowerTable[uc];  /* Use base tables */
+        } else {
+                rp = UniLowerRange;     /* 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 */
+}
+
+/*
+ * UniStrlwr:  Lower case a unicode string
+ */
+static inline wchar_t *
+UniStrlwr(register wchar_t * upin)
+{
+        register wchar_t *up;
+
+        up = upin;
+        while (*up) {           /* For all characters */
+                *up = UniTolower(*up);
+                up++;
+        }
+        return upin;            /* Return input pointer */
+}
+
+#endif