← Back to branch summary

~vcs-imports/samba/main

« back to all changes in this revision

Viewing changes to source/include/charset.h

  • Committer: jerry
  • Date: 2006-07-14 21:48:39 UTC
  • Revision ID: vcs-imports@canonical.com-20060714214839-586d8c489a8fcead
gutting trunk to move to svn:externals

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/include/charset.h
1
 
/* 
2
 
   Unix SMB/CIFS implementation.
3
 
   charset defines
4
 
   Copyright (C) Andrew Tridgell 2001
5
 
   Copyright (C) Jelmer Vernooij 2002
6
 
   
7
 
   This program is free software; you can redistribute it and/or modify
8
 
   it under the terms of the GNU General Public License as published by
9
 
   the Free Software Foundation; either version 2 of the License, or
10
 
   (at your option) any later version.
11
 
   
12
 
   This program is distributed in the hope that it will be useful,
13
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
   GNU General Public License for more details.
16
 
   
17
 
   You should have received a copy of the GNU General Public License
18
 
   along with this program; if not, write to the Free Software
19
 
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20
 
*/
21
 
 
22
 
/* this defines the charset types used in samba */
23
 
typedef enum {CH_UCS2=0, CH_UNIX=1, CH_DISPLAY=2, CH_DOS=3, CH_UTF8=4} charset_t;
24
 
 
25
 
#define NUM_CHARSETS 5
26
 
 
27
 
/* 
28
 
 *   for each charset we have a function that pushes from that charset to a ucs2
29
 
 *   buffer, and a function that pulls from ucs2 buffer to that  charset.
30
 
 *     */
31
 
 
32
 
struct charset_functions {
33
 
        const char *name;
34
 
        size_t (*pull)(void *, const char **inbuf, size_t *inbytesleft,
35
 
                                   char **outbuf, size_t *outbytesleft);
36
 
        size_t (*push)(void *, const char **inbuf, size_t *inbytesleft,
37
 
                                   char **outbuf, size_t *outbytesleft);
38
 
        struct charset_functions *prev, *next;
39
 
};
40
 
 
41
 
/*
42
 
 * This is auxiliary struct used by source/script/gen-8-bit-gap.sh script
43
 
 * during generation of an encoding table for charset module
44
 
 *     */
45
 
 
46
 
struct charset_gap_table {
47
 
  uint16 start;
48
 
  uint16 end;
49
 
  int32 idx;
50
 
};
51
 
 
52
 
/*
53
 
 *   Define stub for charset module which implements 8-bit encoding with gaps.
54
 
 *   Encoding tables for such module should be produced from glibc's CHARMAPs
55
 
 *   using script source/script/gen-8bit-gap.sh
56
 
 *   CHARSETNAME is CAPITALIZED charset name
57
 
 *
58
 
 *     */
59
 
#define SMB_GENERATE_CHARSET_MODULE_8_BIT_GAP(CHARSETNAME)                                      \
60
 
static size_t CHARSETNAME ## _push(void *cd, const char **inbuf, size_t *inbytesleft,                   \
61
 
                         char **outbuf, size_t *outbytesleft)                                   \
62
 
{                                                                                               \
63
 
        while (*inbytesleft >= 2 && *outbytesleft >= 1) {                                       \
64
 
                int i;                                                                          \
65
 
                int done = 0;                                                                   \
66
 
                                                                                                \
67
 
                uint16 ch = SVAL(*inbuf,0);                                                     \
68
 
                                                                                                \
69
 
                for (i=0; from_idx[i].start != 0xffff; i++) {                                   \
70
 
                        if ((from_idx[i].start <= ch) && (from_idx[i].end >= ch)) {             \
71
 
                                ((unsigned char*)(*outbuf))[0] = from_ucs2[from_idx[i].idx+ch]; \
72
 
                                (*inbytesleft) -= 2;                                            \
73
 
                                (*outbytesleft) -= 1;                                           \
74
 
                                (*inbuf)  += 2;                                                 \
75
 
                                (*outbuf) += 1;                                                 \
76
 
                                done = 1;                                                       \
77
 
                                break;                                                          \
78
 
                        }                                                                       \
79
 
                }                                                                               \
80
 
                if (!done) {                                                                    \
81
 
                        errno = EINVAL;                                                         \
82
 
                        return -1;                                                              \
83
 
                }                                                                               \
84
 
                                                                                                \
85
 
        }                                                                                       \
86
 
                                                                                                \
87
 
        if (*inbytesleft == 1) {                                                                \
88
 
                errno = EINVAL;                                                                 \
89
 
                return -1;                                                                      \
90
 
        }                                                                                       \
91
 
                                                                                                \
92
 
        if (*inbytesleft > 1) {                                                                 \
93
 
                errno = E2BIG;                                                                  \
94
 
                return -1;                                                                      \
95
 
        }                                                                                       \
96
 
                                                                                                \
97
 
        return 0;                                                                               \
98
 
}                                                                                               \
99
 
                                                                                                \
100
 
static size_t CHARSETNAME ## _pull(void *cd, const char **inbuf, size_t *inbytesleft,                           \
101
 
                         char **outbuf, size_t *outbytesleft)                                   \
102
 
{                                                                                               \
103
 
        while (*inbytesleft >= 1 && *outbytesleft >= 2) {                                       \
104
 
                *(uint16*)(*outbuf) = to_ucs2[((unsigned char*)(*inbuf))[0]];                   \
105
 
                (*inbytesleft)  -= 1;                                                           \
106
 
                (*outbytesleft) -= 2;                                                           \
107
 
                (*inbuf)  += 1;                                                                 \
108
 
                (*outbuf) += 2;                                                                 \
109
 
        }                                                                                       \
110
 
                                                                                                \
111
 
        if (*inbytesleft > 0) {                                                                 \
112
 
                errno = E2BIG;                                                                  \
113
 
                return -1;                                                                      \
114
 
        }                                                                                       \
115
 
                                                                                                \
116
 
        return 0;                                                                               \
117
 
}                                                                                               \
118
 
                                                                                                \
119
 
struct charset_functions CHARSETNAME ## _functions =                                            \
120
 
                {#CHARSETNAME, CHARSETNAME ## _pull, CHARSETNAME ## _push};                     \
121
 
                                                                                                \
122
 
NTSTATUS charset_ ## CHARSETNAME ## _init(void)                                                 \
123
 
{                                                                                               \
124
 
        return smb_register_charset(& CHARSETNAME ## _functions);                               \
125
 
}                                                                                               \
126