r23784: use the GPLv3 boilerplate as recommended by the FSF and the license text
[abartlet/samba.git/.git] / source3 / include / charset.h
index 14b6ec2020f66604505b0b06fdce3c495963e78d..4d04b5a1a678ad0d40222ea2b796e89aa0b441de 100644 (file)
@@ -1,12 +1,12 @@
 /* 
-   Unix SMB/Netbios implementation.
-   Version 1.9.
-   Character set handling
-   Copyright (C) Andrew Tridgell 1992-1995
+   Unix SMB/CIFS implementation.
+   charset defines
+   Copyright (C) Andrew Tridgell 2001
+   Copyright (C) Jelmer Vernooij 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
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
    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., 675 Mass Ave, Cambridge, MA 02139, USA.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef CHARSET_C
+/* this defines the charset types used in samba */
+typedef enum {CH_UTF16LE=0, CH_UTF16=0, CH_UNIX=1, CH_DISPLAY=2, CH_DOS=3, CH_UTF8=4, CH_UTF16BE=5} charset_t;
 
-extern char *dos_char_map;
-extern char *upper_char_map;
-extern char *lower_char_map;
-extern void add_char_string(char *s);
-extern void charset_initialise(void);
+#define NUM_CHARSETS 6
 
-#ifdef toupper
-#undef toupper
-#endif
-
-#ifdef tolower
-#undef tolower
-#endif
-
-#ifdef isupper
-#undef isupper
-#endif
-
-#ifdef islower
-#undef islower
-#endif
+/* 
+ *   for each charset we have a function that pushes from that charset to a ucs2
+ *   buffer, and a function that pulls from ucs2 buffer to that  charset.
+ *     */
 
-#ifdef isdoschar
-#undef isdoschar
-#endif
+struct charset_functions {
+       const char *name;
+       size_t (*pull)(void *, const char **inbuf, size_t *inbytesleft,
+                                  char **outbuf, size_t *outbytesleft);
+       size_t (*push)(void *, const char **inbuf, size_t *inbytesleft,
+                                  char **outbuf, size_t *outbytesleft);
+       struct charset_functions *prev, *next;
+};
 
-#ifdef isspace
-#undef isspace
-#endif
+/*
+ * This is auxiliary struct used by source/script/gen-8-bit-gap.sh script
+ * during generation of an encoding table for charset module
+ *     */
 
-#define toupper(c) upper_char_map[(char)(c)]
-#define tolower(c) lower_char_map[(char)(c)]
-#define isupper(c) (((char)(c)) != tolower(c))
-#define islower(c) (((char)(c)) != toupper(c))
-#define isdoschar(c) (dos_char_map[(char)(c)] != 0)
-#define isspace(c) ((c)==' ' || (c) == '\t')
+struct charset_gap_table {
+  uint16 start;
+  uint16 end;
+  int32 idx;
+};
 
-/* this is used to determine if a character is safe to use in
-   something that may be put on a command line */
-#define issafe(c) (isalnum(c) || strchr("-._",c))
-#endif
+/*
+ *   Define stub for charset module which implements 8-bit encoding with gaps.
+ *   Encoding tables for such module should be produced from glibc's CHARMAPs
+ *   using script source/script/gen-8bit-gap.sh
+ *   CHARSETNAME is CAPITALIZED charset name
+ *
+ *     */
+#define SMB_GENERATE_CHARSET_MODULE_8_BIT_GAP(CHARSETNAME)                                     \
+static size_t CHARSETNAME ## _push(void *cd, const char **inbuf, size_t *inbytesleft,                  \
+                        char **outbuf, size_t *outbytesleft)                                   \
+{                                                                                              \
+       while (*inbytesleft >= 2 && *outbytesleft >= 1) {                                       \
+               int i;                                                                          \
+               int done = 0;                                                                   \
+                                                                                               \
+               uint16 ch = SVAL(*inbuf,0);                                                     \
+                                                                                               \
+               for (i=0; from_idx[i].start != 0xffff; i++) {                                   \
+                       if ((from_idx[i].start <= ch) && (from_idx[i].end >= ch)) {             \
+                               ((unsigned char*)(*outbuf))[0] = from_ucs2[from_idx[i].idx+ch]; \
+                               (*inbytesleft) -= 2;                                            \
+                               (*outbytesleft) -= 1;                                           \
+                               (*inbuf)  += 2;                                                 \
+                               (*outbuf) += 1;                                                 \
+                               done = 1;                                                       \
+                               break;                                                          \
+                       }                                                                       \
+               }                                                                               \
+               if (!done) {                                                                    \
+                       errno = EINVAL;                                                         \
+                       return -1;                                                              \
+               }                                                                               \
+                                                                                               \
+       }                                                                                       \
+                                                                                               \
+       if (*inbytesleft == 1) {                                                                \
+               errno = EINVAL;                                                                 \
+               return -1;                                                                      \
+       }                                                                                       \
+                                                                                               \
+       if (*inbytesleft > 1) {                                                                 \
+               errno = E2BIG;                                                                  \
+               return -1;                                                                      \
+       }                                                                                       \
+                                                                                               \
+       return 0;                                                                               \
+}                                                                                              \
+                                                                                               \
+static size_t CHARSETNAME ## _pull(void *cd, const char **inbuf, size_t *inbytesleft,                          \
+                        char **outbuf, size_t *outbytesleft)                                   \
+{                                                                                              \
+       while (*inbytesleft >= 1 && *outbytesleft >= 2) {                                       \
+               *(uint16*)(*outbuf) = to_ucs2[((unsigned char*)(*inbuf))[0]];                   \
+               (*inbytesleft)  -= 1;                                                           \
+               (*outbytesleft) -= 2;                                                           \
+               (*inbuf)  += 1;                                                                 \
+               (*outbuf) += 2;                                                                 \
+       }                                                                                       \
+                                                                                               \
+       if (*inbytesleft > 0) {                                                                 \
+               errno = E2BIG;                                                                  \
+               return -1;                                                                      \
+       }                                                                                       \
+                                                                                               \
+       return 0;                                                                               \
+}                                                                                              \
+                                                                                               \
+struct charset_functions CHARSETNAME ## _functions =                                           \
+               {#CHARSETNAME, CHARSETNAME ## _pull, CHARSETNAME ## _push};                     \
+                                                                                               \
+NTSTATUS charset_ ## CHARSETNAME ## _init(void);                                                       \
+NTSTATUS charset_ ## CHARSETNAME ## _init(void)                                                        \
+{                                                                                              \
+       return smb_register_charset(& CHARSETNAME ## _functions);                               \
+}                                                                                              \