141fbea7be4edac706b5ba7bfc7b1196383d9ad4
[nivanova/samba-autobuild/.git] / lib / util / charset / 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 3 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, see <http://www.gnu.org/licenses/>.
19 */
20
21 /* This is a public header file that is installed as part of Samba. 
22  * If you remove any functions or change their signature, update 
23  * the so version number. */
24
25 #ifndef __CHARSET_H__
26 #define __CHARSET_H__
27
28 #include <talloc.h>
29
30 /* this defines the charset types used in samba */
31 typedef enum {CH_UTF16LE=0, CH_UTF16=0, CH_UNIX, CH_DISPLAY, CH_DOS, CH_UTF8, CH_UTF16BE, CH_UTF16MUNGED} charset_t;
32
33 #define NUM_CHARSETS 7
34
35 /*
36  * SMB UCS2 (16-bit unicode) internal type.
37  * smb_ucs2_t is *always* in little endian format.
38  */
39
40 typedef uint16_t smb_ucs2_t;
41
42 #ifdef WORDS_BIGENDIAN
43 #define UCS2_SHIFT 8
44 #else
45 #define UCS2_SHIFT 0
46 #endif
47
48 /* turn a 7 bit character into a ucs2 character */
49 #define UCS2_CHAR(c) ((c) << UCS2_SHIFT)
50
51 /*
52  *   for each charset we have a function that pulls from that charset to
53  *     a ucs2 buffer, and a function that pushes to a ucs2 buffer
54  *     */
55
56 struct charset_functions {
57         const char *name;
58         size_t (*pull)(void *, const char **inbuf, size_t *inbytesleft,
59                                    char **outbuf, size_t *outbytesleft);
60         size_t (*push)(void *, const char **inbuf, size_t *inbytesleft,
61                                    char **outbuf, size_t *outbytesleft);
62         struct charset_functions *prev, *next;
63 };
64
65 /* this type is used for manipulating unicode codepoints */
66 typedef uint32_t codepoint_t;
67
68 #define INVALID_CODEPOINT ((codepoint_t)-1)
69
70 /*
71  * This is auxiliary struct used by source/script/gen-8-bit-gap.sh script
72  * during generation of an encoding table for charset module
73  *     */
74
75 struct charset_gap_table {
76   uint16_t start;
77   uint16_t end;
78   int32_t idx;
79 };
80
81
82 /* generic iconv conversion structure */
83 typedef struct smb_iconv_s {
84         size_t (*direct)(void *cd, const char **inbuf, size_t *inbytesleft,
85                          char **outbuf, size_t *outbytesleft);
86         size_t (*pull)(void *cd, const char **inbuf, size_t *inbytesleft,
87                        char **outbuf, size_t *outbytesleft);
88         size_t (*push)(void *cd, const char **inbuf, size_t *inbytesleft,
89                        char **outbuf, size_t *outbytesleft);
90         void *cd_direct, *cd_pull, *cd_push;
91         char *from_name, *to_name;
92 } *smb_iconv_t;
93
94 /* string manipulation flags */
95 #define STR_TERMINATE 1
96 #define STR_UPPER 2
97 #define STR_ASCII 4
98 #define STR_UNICODE 8
99 #define STR_NOALIGN 16
100 #define STR_NO_RANGE_CHECK 32
101 #define STR_LEN8BIT 64
102 #define STR_TERMINATE_ASCII 128 /* only terminate if ascii */
103 #define STR_LEN_NOTERM 256 /* the length field is the unterminated length */
104
105 struct loadparm_context;
106 struct smb_iconv_convenience;
107
108 /* replace some string functions with multi-byte
109    versions */
110 #define strlower(s) strlower_m(s)
111 #define strupper(s) strupper_m(s)
112
113 char *strchr_m(const char *s, char c);
114 size_t strlen_m_ext(const char *s, charset_t src_charset, charset_t dst_charset);
115 size_t strlen_m_ext_term(const char *s, charset_t src_charset,
116                          charset_t dst_charset);
117 size_t strlen_m_term(const char *s);
118 size_t strlen_m_term_null(const char *s);
119 size_t strlen_m(const char *s);
120 char *alpha_strcpy(char *dest, const char *src, const char *other_safe_chars, size_t maxlength);
121 void string_replace_m(char *s, char oldc, char newc);
122 bool strcsequal(const char *s1,const char *s2);
123 bool strequal_m(const char *s1, const char *s2);
124 int strncasecmp_m(const char *s1, const char *s2, size_t n);
125 bool next_token(const char **ptr,char *buff, const char *sep, size_t bufsize);
126 int strcasecmp_m(const char *s1, const char *s2);
127 size_t count_chars_m(const char *s, char c);
128 void strupper_m(char *s);
129 void strlower_m(char *s);
130 char *strupper_talloc(TALLOC_CTX *ctx, const char *src);
131 char *talloc_strdup_upper(TALLOC_CTX *ctx, const char *src);
132 char *strupper_talloc_n(TALLOC_CTX *ctx, const char *src, size_t n);
133 char *strlower_talloc(TALLOC_CTX *ctx, const char *src);
134 bool strhasupper(const char *string);
135 bool strhaslower(const char *string);
136 char *strrchr_m(const char *s, char c);
137 char *strchr_m(const char *s, char c);
138
139 bool push_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src, size_t *converted_size);
140 bool push_ucs2_talloc(TALLOC_CTX *ctx, smb_ucs2_t **dest, const char *src, size_t *converted_size);
141 bool push_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src, size_t *converted_size);
142 bool pull_ascii_talloc(TALLOC_CTX *ctx, char **dest, const char *src, size_t *converted_size);
143 bool pull_ucs2_talloc(TALLOC_CTX *ctx, char **dest, const smb_ucs2_t *src, size_t *converted_size);
144 bool pull_utf8_talloc(TALLOC_CTX *ctx, char **dest, const char *src, size_t *converted_size);
145 ssize_t push_string(void *dest, const char *src, size_t dest_len, int flags);
146 ssize_t pull_string(char *dest, const void *src, size_t dest_len, size_t src_len, int flags);
147
148 bool convert_string_talloc(TALLOC_CTX *ctx, 
149                            charset_t from, charset_t to, 
150                            void const *src, size_t srclen, 
151                            void *dest, size_t *converted_size);
152
153 size_t convert_string(charset_t from, charset_t to,
154                       void const *src, size_t srclen, 
155                       void *dest, size_t destlen);
156
157 ssize_t iconv_talloc(TALLOC_CTX *mem_ctx, 
158                                        smb_iconv_t cd,
159                                        void const *src, size_t srclen, 
160                                        void *dest);
161
162 extern struct smb_iconv_convenience *global_iconv_convenience;
163 struct smb_iconv_convenience *get_iconv_convenience(void);
164 smb_iconv_t get_conv_handle(struct smb_iconv_convenience *ic,
165                             charset_t from, charset_t to);
166 const char *charset_name(struct smb_iconv_convenience *ic, charset_t ch);
167
168 codepoint_t next_codepoint_ext(const char *str, charset_t src_charset,
169                                size_t *size);
170 codepoint_t next_codepoint(const char *str, size_t *size);
171 ssize_t push_codepoint(char *str, codepoint_t c);
172
173 /* codepoints */
174 codepoint_t next_codepoint_convenience_ext(struct smb_iconv_convenience *ic,
175                             const char *str, charset_t src_charset,
176                             size_t *size);
177 codepoint_t next_codepoint_convenience(struct smb_iconv_convenience *ic, 
178                             const char *str, size_t *size);
179 ssize_t push_codepoint_convenience(struct smb_iconv_convenience *ic, 
180                                 char *str, codepoint_t c);
181
182 codepoint_t toupper_m(codepoint_t val);
183 codepoint_t tolower_m(codepoint_t val);
184 bool islower_m(codepoint_t val);
185 bool isupper_m(codepoint_t val);
186 int codepoint_cmpi(codepoint_t c1, codepoint_t c2);
187
188 /* Iconv convenience functions */
189 struct smb_iconv_convenience *smb_iconv_convenience_reinit(TALLOC_CTX *mem_ctx,
190                                                            const char *dos_charset,
191                                                            const char *unix_charset,
192                                                            const char *display_charset,
193                                                            bool native_iconv,
194                                                            struct smb_iconv_convenience *old_ic);
195
196 bool convert_string_convenience(struct smb_iconv_convenience *ic,
197                                 charset_t from, charset_t to,
198                                 void const *src, size_t srclen, 
199                                 void *dest, size_t destlen, size_t *converted_size);
200 bool convert_string_talloc_convenience(TALLOC_CTX *ctx, 
201                                        struct smb_iconv_convenience *ic, 
202                                        charset_t from, charset_t to, 
203                                        void const *src, size_t srclen, 
204                                        void *dest, size_t *converted_size);
205 /* iconv */
206 smb_iconv_t smb_iconv_open(const char *tocode, const char *fromcode);
207 int smb_iconv_close(smb_iconv_t cd);
208 size_t smb_iconv(smb_iconv_t cd, 
209                  const char **inbuf, size_t *inbytesleft,
210                  char **outbuf, size_t *outbytesleft);
211 smb_iconv_t smb_iconv_open_ex(TALLOC_CTX *mem_ctx, const char *tocode, 
212                               const char *fromcode, bool native_iconv);
213
214 void load_case_tables(void);
215 void load_case_tables_library(void);
216 bool smb_register_charset(const struct charset_functions *funcs_in);
217
218 /*
219  *   Define stub for charset module which implements 8-bit encoding with gaps.
220  *   Encoding tables for such module should be produced from glibc's CHARMAPs
221  *   using script source/script/gen-8bit-gap.sh
222  *   CHARSETNAME is CAPITALIZED charset name
223  *
224  *     */
225 #define SMB_GENERATE_CHARSET_MODULE_8_BIT_GAP(CHARSETNAME)                                      \
226 static size_t CHARSETNAME ## _push(void *cd, const char **inbuf, size_t *inbytesleft,                   \
227                          char **outbuf, size_t *outbytesleft)                                   \
228 {                                                                                               \
229         while (*inbytesleft >= 2 && *outbytesleft >= 1) {                                       \
230                 int i;                                                                          \
231                 int done = 0;                                                                   \
232                                                                                                 \
233                 uint16 ch = SVAL(*inbuf,0);                                                     \
234                                                                                                 \
235                 for (i=0; from_idx[i].start != 0xffff; i++) {                                   \
236                         if ((from_idx[i].start <= ch) && (from_idx[i].end >= ch)) {             \
237                                 ((unsigned char*)(*outbuf))[0] = from_ucs2[from_idx[i].idx+ch]; \
238                                 (*inbytesleft) -= 2;                                            \
239                                 (*outbytesleft) -= 1;                                           \
240                                 (*inbuf)  += 2;                                                 \
241                                 (*outbuf) += 1;                                                 \
242                                 done = 1;                                                       \
243                                 break;                                                          \
244                         }                                                                       \
245                 }                                                                               \
246                 if (!done) {                                                                    \
247                         errno = EINVAL;                                                         \
248                         return -1;                                                              \
249                 }                                                                               \
250                                                                                                 \
251         }                                                                                       \
252                                                                                                 \
253         if (*inbytesleft == 1) {                                                                \
254                 errno = EINVAL;                                                                 \
255                 return -1;                                                                      \
256         }                                                                                       \
257                                                                                                 \
258         if (*inbytesleft > 1) {                                                                 \
259                 errno = E2BIG;                                                                  \
260                 return -1;                                                                      \
261         }                                                                                       \
262                                                                                                 \
263         return 0;                                                                               \
264 }                                                                                               \
265                                                                                                 \
266 static size_t CHARSETNAME ## _pull(void *cd, const char **inbuf, size_t *inbytesleft,                           \
267                          char **outbuf, size_t *outbytesleft)                                   \
268 {                                                                                               \
269         while (*inbytesleft >= 1 && *outbytesleft >= 2) {                                       \
270                 SSVAL(*outbuf, 0, to_ucs2[((unsigned char*)(*inbuf))[0]]);                      \
271                 (*inbytesleft)  -= 1;                                                           \
272                 (*outbytesleft) -= 2;                                                           \
273                 (*inbuf)  += 1;                                                                 \
274                 (*outbuf) += 2;                                                                 \
275         }                                                                                       \
276                                                                                                 \
277         if (*inbytesleft > 0) {                                                                 \
278                 errno = E2BIG;                                                                  \
279                 return -1;                                                                      \
280         }                                                                                       \
281                                                                                                 \
282         return 0;                                                                               \
283 }                                                                                               \
284                                                                                                 \
285 struct charset_functions CHARSETNAME ## _functions =                                            \
286                 {#CHARSETNAME, CHARSETNAME ## _pull, CHARSETNAME ## _push};                     \
287                                                                                                 \
288 NTSTATUS charset_ ## CHARSETNAME ## _init(void);                                                        \
289 NTSTATUS charset_ ## CHARSETNAME ## _init(void)                                                 \
290 {                                                                                               \
291         if (!smb_register_charset(& CHARSETNAME ## _functions)) {       \
292                 return NT_STATUS_INTERNAL_ERROR;                        \
293         }                                                               \
294         return NT_STATUS_OK; \
295 }                                               \
296
297
298 #endif /* __CHARSET_H__ */