?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Janitorial duties to make autogen.sh portable.
[Samba/gebeck_regimport.git] / source3 / lib / iconv.c
blob54733c2ac27c62e843a17827f16d416c890c3d3b
1 /*
2 Unix SMB/CIFS implementation.
3 minimal iconv implementation
4 Copyright (C) Andrew Tridgell 2001
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20
21 #include "includes.h"
22
23 static size_t ascii_pull(void *,char **, size_t *, char **, size_t *);
24 static size_t ascii_push(void *,char **, size_t *, char **, size_t *);
25 static size_t utf8_pull(void *,char **, size_t *, char **, size_t *);
26 static size_t utf8_push(void *,char **, size_t *, char **, size_t *);
27 static size_t weird_pull(void *,char **, size_t *, char **, size_t *);
28 static size_t weird_push(void *,char **, size_t *, char **, size_t *);
29 static size_t ucs2hex_pull(void *,char **, size_t *, char **, size_t *);
30 static size_t ucs2hex_push(void *,char **, size_t *, char **, size_t *);
31 static size_t iconv_copy(void *,char **, size_t *, char **, size_t *);
32
33 /*
34 for each charset we have a function that pulls from that charset to
35 a ucs2 buffer, and a function that pushes to a ucs2 buffer
36 */
37 static struct {
38 const char *name;
39 size_t (*pull)(void *, char **inbuf, size_t *inbytesleft,
40 char **outbuf, size_t *outbytesleft);
41 size_t (*push)(void *, char **inbuf, size_t *inbytesleft,
42 char **outbuf, size_t *outbytesleft);
43 } charsets[] = {
44 {"UCS-2LE", iconv_copy, iconv_copy},
45 {"UTF8", utf8_pull, utf8_push},
46 {"ASCII", ascii_pull, ascii_push},
47 {"WEIRD", weird_pull, weird_push},
48 {"UCS2-HEX", ucs2hex_pull, ucs2hex_push},
49 {NULL, NULL, NULL}
50 };
51
52
53 /* if there was an error then reset the internal state,
54 this ensures that we don't have a shift state remaining for
55 character sets like SJIS */
56 static size_t sys_iconv(void *cd,
57 char **inbuf, size_t *inbytesleft,
58 char **outbuf, size_t *outbytesleft)
59 {
60 #ifdef HAVE_NATIVE_ICONV
61 size_t ret = iconv((iconv_t)cd,
62 inbuf, inbytesleft,
63 outbuf, outbytesleft);
64 if (ret == (size_t)-1) iconv(cd, NULL, NULL, NULL, NULL);
65 return ret;
66 #else
67 errno = EINVAL;
68 return -1;
69 #endif
70 }
71
72 /**
73 * This is a simple portable iconv() implementaion.
74 *
75 * It only knows about a very small number of character sets - just
76 * enough that Samba works on systems that don't have iconv.
77 **/
78 size_t smb_iconv(smb_iconv_t cd,
79 const char **inbuf, size_t *inbytesleft,
80 char **outbuf, size_t *outbytesleft)
81 {
82 char cvtbuf[2048];
83 char *bufp = cvtbuf;
84 size_t bufsize;
85
86 /* in many cases we can go direct */
87 if (cd->direct) {
88 return cd->direct(cd->cd_direct,
89 (char **)inbuf, inbytesleft, outbuf, outbytesleft);
90 }
91
92
93 /* otherwise we have to do it chunks at a time */
94 while (*inbytesleft > 0) {
95 bufp = cvtbuf;
96 bufsize = sizeof(cvtbuf);
97
98 if (cd->pull(cd->cd_pull,
99 (char **)inbuf, inbytesleft, &bufp, &bufsize) == -1
100 && errno != E2BIG) return -1;
101
102 bufp = cvtbuf;
103 bufsize = sizeof(cvtbuf) - bufsize;
104
105 if (cd->push(cd->cd_push,
106 &bufp, &bufsize,
107 outbuf, outbytesleft) == -1) return -1;
108 }
109
110 return 0;
111 }
112
113 /*
114 simple iconv_open() wrapper
115 */
116 smb_iconv_t smb_iconv_open(const char *tocode, const char *fromcode)
117 {
118 smb_iconv_t ret;
119 int from, to;
120
121 ret = (smb_iconv_t)malloc(sizeof(*ret));
122 if (!ret) {
123 errno = ENOMEM;
124 return (smb_iconv_t)-1;
125 }
126 memset(ret, 0, sizeof(*ret));
127
128 ret->from_name = strdup(fromcode);
129 ret->to_name = strdup(tocode);
130
131 /* check for the simplest null conversion */
132 if (strcmp(fromcode, tocode) == 0) {
133 ret->direct = iconv_copy;
134 return ret;
135 }
136
137 for (from=0; charsets[from].name; from++) {
138 if (strcasecmp(charsets[from].name, fromcode) == 0) break;
139 }
140 for (to=0; charsets[to].name; to++) {
141 if (strcasecmp(charsets[to].name, tocode) == 0) break;
142 }
143
144 #ifdef HAVE_NATIVE_ICONV
145 if (!charsets[from].name) {
146 ret->pull = sys_iconv;
147 ret->cd_pull = iconv_open("UCS-2LE", fromcode);
148 if (ret->cd_pull == (iconv_t)-1) goto failed;
149 }
150 if (!charsets[to].name) {
151 ret->push = sys_iconv;
152 ret->cd_push = iconv_open(tocode, "UCS-2LE");
153 if (ret->cd_push == (iconv_t)-1) goto failed;
154 }
155 #else
156 if (!charsets[from].name || !charsets[to].name) {
157 goto failed;
158 }
159 #endif
160
161 /* check for conversion to/from ucs2 */
162 if (from == 0 && charsets[to].name) {
163 ret->direct = charsets[to].push;
164 return ret;
165 }
166 if (to == 0 && charsets[from].name) {
167 ret->direct = charsets[from].pull;
168 return ret;
169 }
170
171 #ifdef HAVE_NATIVE_ICONV
172 if (from == 0) {
173 ret->direct = sys_iconv;
174 ret->cd_direct = ret->cd_push;
175 ret->cd_push = NULL;
176 return ret;
177 }
178 if (to == 0) {
179 ret->direct = sys_iconv;
180 ret->cd_direct = ret->cd_pull;
181 ret->cd_pull = NULL;
182 return ret;
183 }
184 #endif
185
186 /* the general case has to go via a buffer */
187 if (!ret->pull) ret->pull = charsets[from].pull;
188 if (!ret->push) ret->push = charsets[to].push;
189 return ret;
190
191 failed:
192 SAFE_FREE(ret);
193 errno = EINVAL;
194 return (smb_iconv_t)-1;
195 }
196
197 /*
198 simple iconv_close() wrapper
199 */
200 int smb_iconv_close (smb_iconv_t cd)
201 {
202 #ifdef HAVE_NATIVE_ICONV
203 if (cd->cd_direct) iconv_close((iconv_t)cd->cd_direct);
204 if (cd->cd_pull) iconv_close((iconv_t)cd->cd_pull);
205 if (cd->cd_push) iconv_close((iconv_t)cd->cd_push);
206 #endif
207
208 SAFE_FREE(cd->from_name);
209 SAFE_FREE(cd->to_name);
210
211 memset(cd, 0, sizeof(*cd));
212 SAFE_FREE(cd);
213 return 0;
214 }
215
216
217 /**********************************************************************
218 the following functions implement the builtin character sets in Samba
219 and also the "test" character sets that are designed to test
220 multi-byte character set support for english users
221 ***********************************************************************/
222
223 static size_t ascii_pull(void *cd, char **inbuf, size_t *inbytesleft,
224 char **outbuf, size_t *outbytesleft)
225 {
226 while (*inbytesleft >= 1 && *outbytesleft >= 2) {
227 (*outbuf)[0] = (*inbuf)[0];
228 (*outbuf)[1] = 0;
229 (*inbytesleft) -= 1;
230 (*outbytesleft) -= 2;
231 (*inbuf) += 1;
232 (*outbuf) += 2;
233 }
234
235 if (*inbytesleft > 0) {
236 errno = E2BIG;
237 return -1;
238 }
239
240 return 0;
241 }
242
243 static size_t ascii_push(void *cd, char **inbuf, size_t *inbytesleft,
244 char **outbuf, size_t *outbytesleft)
245 {
246 int ir_count=0;
247
248 while (*inbytesleft >= 2 && *outbytesleft >= 1) {
249 (*outbuf)[0] = (*inbuf)[0] & 0x7F;
250 if ((*inbuf)[1]) ir_count++;
251 (*inbytesleft) -= 2;
252 (*outbytesleft) -= 1;
253 (*inbuf) += 2;
254 (*outbuf) += 1;
255 }
256
257 if (*inbytesleft == 1) {
258 errno = EINVAL;
259 return -1;
260 }
261
262 if (*inbytesleft > 1) {
263 errno = E2BIG;
264 return -1;
265 }
266
267 return ir_count;
268 }
269
270
271 static size_t ucs2hex_pull(void *cd, char **inbuf, size_t *inbytesleft,
272 char **outbuf, size_t *outbytesleft)
273 {
274 while (*inbytesleft >= 1 && *outbytesleft >= 2) {
275 unsigned v;
276
277 if ((*inbuf)[0] != '@') {
278 /* seven bit ascii case */
279 (*outbuf)[0] = (*inbuf)[0];
280 (*outbuf)[1] = 0;
281 (*inbytesleft) -= 1;
282 (*outbytesleft) -= 2;
283 (*inbuf) += 1;
284 (*outbuf) += 2;
285 continue;
286 }
287 /* it's a hex character */
288 if (*inbytesleft < 5) {
289 errno = EINVAL;
290 return -1;
291 }
292
293 if (sscanf(&(*inbuf)[1], "%04x", &v) != 1) {
294 errno = EILSEQ;
295 return -1;
296 }
297
298 (*outbuf)[0] = v&0xff;
299 (*outbuf)[1] = v>>8;
300 (*inbytesleft) -= 5;
301 (*outbytesleft) -= 2;
302 (*inbuf) += 5;
303 (*outbuf) += 2;
304 }
305
306 if (*inbytesleft > 0) {
307 errno = E2BIG;
308 return -1;
309 }
310
311 return 0;
312 }
313
314 static size_t ucs2hex_push(void *cd, char **inbuf, size_t *inbytesleft,
315 char **outbuf, size_t *outbytesleft)
316 {
317 while (*inbytesleft >= 2 && *outbytesleft >= 1) {
318 char buf[6];
319
320 if ((*inbuf)[1] == 0 &&
321 ((*inbuf)[0] & 0x80) == 0 &&
322 (*inbuf)[0] != '@') {
323 (*outbuf)[0] = (*inbuf)[0];
324 (*inbytesleft) -= 2;
325 (*outbytesleft) -= 1;
326 (*inbuf) += 2;
327 (*outbuf) += 1;
328 continue;
329 }
330 if (*outbytesleft < 5) {
331 errno = E2BIG;
332 return -1;
333 }
334 snprintf(buf, 6, "@%04x", SVAL(*inbuf, 0));
335 memcpy(*outbuf, buf, 5);
336 (*inbytesleft) -= 2;
337 (*outbytesleft) -= 5;
338 (*inbuf) += 2;
339 (*outbuf) += 5;
340 }
341
342 if (*inbytesleft == 1) {
343 errno = EINVAL;
344 return -1;
345 }
346
347 if (*inbytesleft > 1) {
348 errno = E2BIG;
349 return -1;
350 }
351
352 return 0;
353 }
354
355
356 /* the "weird" character set is very useful for testing multi-byte
357 support and finding bugs. Don't use on a production system!
358 */
359 static struct {
360 const char from;
361 const char *to;
362 int len;
363 } weird_table[] = {
364 {'q', "^q^", 3},
365 {'Q', "^Q^", 3},
366 {0, NULL}
367 };
368
369 static size_t weird_pull(void *cd, char **inbuf, size_t *inbytesleft,
370 char **outbuf, size_t *outbytesleft)
371 {
372 while (*inbytesleft >= 1 && *outbytesleft >= 2) {
373 int i;
374 int done = 0;
375 for (i=0;weird_table[i].from;i++) {
376 if (strncmp((*inbuf),
377 weird_table[i].to,
378 weird_table[i].len) == 0) {
379 if (*inbytesleft < weird_table[i].len) {
380 DEBUG(0,("ERROR: truncated weird string\n"));
381 /* smb_panic("weird_pull"); */
382
383 } else {
384 (*outbuf)[0] = weird_table[i].from;
385 (*outbuf)[1] = 0;
386 (*inbytesleft) -= weird_table[i].len;
387 (*outbytesleft) -= 2;
388 (*inbuf) += weird_table[i].len;
389 (*outbuf) += 2;
390 done = 1;
391 break;
392 }
393 }
394 }
395 if (done) continue;
396 (*outbuf)[0] = (*inbuf)[0];
397 (*outbuf)[1] = 0;
398 (*inbytesleft) -= 1;
399 (*outbytesleft) -= 2;
400 (*inbuf) += 1;
401 (*outbuf) += 2;
402 }
403
404 if (*inbytesleft > 0) {
405 errno = E2BIG;
406 return -1;
407 }
408
409 return 0;
410 }
411
412 static size_t weird_push(void *cd, char **inbuf, size_t *inbytesleft,
413 char **outbuf, size_t *outbytesleft)
414 {
415 int ir_count=0;
416
417 while (*inbytesleft >= 2 && *outbytesleft >= 1) {
418 int i;
419 int done=0;
420 for (i=0;weird_table[i].from;i++) {
421 if ((*inbuf)[0] == weird_table[i].from &&
422 (*inbuf)[1] == 0) {
423 if (*outbytesleft < weird_table[i].len) {
424 DEBUG(0,("No room for weird character\n"));
425 /* smb_panic("weird_push"); */
426 } else {
427 memcpy(*outbuf, weird_table[i].to,
428 weird_table[i].len);
429 (*inbytesleft) -= 2;
430 (*outbytesleft) -= weird_table[i].len;
431 (*inbuf) += 2;
432 (*outbuf) += weird_table[i].len;
433 done = 1;
434 break;
435 }
436 }
437 }
438 if (done) continue;
439
440 (*outbuf)[0] = (*inbuf)[0];
441 if ((*inbuf)[1]) ir_count++;
442 (*inbytesleft) -= 2;
443 (*outbytesleft) -= 1;
444 (*inbuf) += 2;
445 (*outbuf) += 1;
446 }
447
448 if (*inbytesleft == 1) {
449 errno = EINVAL;
450 return -1;
451 }
452
453 if (*inbytesleft > 1) {
454 errno = E2BIG;
455 return -1;
456 }
457
458 return ir_count;
459 }
460
461 static size_t iconv_copy(void *cd, char **inbuf, size_t *inbytesleft,
462 char **outbuf, size_t *outbytesleft)
463 {
464 int n;
465
466 n = MIN(*inbytesleft, *outbytesleft);
467
468 memmove(*outbuf, *inbuf, n);
469
470 (*inbytesleft) -= n;
471 (*outbytesleft) -= n;
472 (*inbuf) += n;
473 (*outbuf) += n;
474
475 if (*inbytesleft > 0) {
476 errno = E2BIG;
477 return -1;
478 }
479
480 return 0;
481 }
482
483 static size_t utf8_pull(void *cd, char **inbuf, size_t *inbytesleft,
484 char **outbuf, size_t *outbytesleft)
485 {
486 while (*inbytesleft >= 1 && *outbytesleft >= 2) {
487 unsigned char *c = (unsigned char *)*inbuf;
488 unsigned char *uc = (unsigned char *)*outbuf;
489 int len = 1;
490
491 if ((c[0] & 0x80) == 0) {
492 uc[0] = c[0];
493 uc[1] = 0;
494 } else if ((c[0] & 0xf0) == 0xe0) {
495 if (*inbytesleft < 3) {
496 DEBUG(0,("short utf8 char\n"));
497 goto badseq;
498 }
499 uc[1] = ((c[0]&0xF)<<4) | ((c[1]>>2)&0xF);
500 uc[0] = (c[1]<<6) | (c[2]&0x3f);
501 len = 3;
502 } else if ((c[0] & 0xe0) == 0xc0) {
503 if (*inbytesleft < 2) {
504 DEBUG(0,("short utf8 char\n"));
505 goto badseq;
506 }
507 uc[1] = (c[0]>>2) & 0x7;
508 uc[0] = (c[0]<<6) | (c[1]&0x3f);
509 len = 2;
510 }
511
512 (*inbuf) += len;
513 (*inbytesleft) -= len;
514 (*outbytesleft) -= 2;
515 (*outbuf) += 2;
516 }
517
518 if (*inbytesleft > 0) {
519 errno = E2BIG;
520 return -1;
521 }
522
523 return 0;
524
525 badseq:
526 errno = EINVAL;
527 return -1;
528 }
529
530 static size_t utf8_push(void *cd, char **inbuf, size_t *inbytesleft,
531 char **outbuf, size_t *outbytesleft)
532 {
533 while (*inbytesleft >= 2 && *outbytesleft >= 1) {
534 unsigned char *c = (unsigned char *)*outbuf;
535 unsigned char *uc = (unsigned char *)*inbuf;
536 int len=1;
537
538 if (uc[1] & 0xf8) {
539 if (*outbytesleft < 3) {
540 DEBUG(0,("short utf8 write\n"));
541 goto toobig;
542 }
543 c[0] = 0xe0 | (uc[1]>>4);
544 c[1] = 0x80 | ((uc[1]&0xF)<<2) | (uc[0]>>6);
545 c[2] = 0x80 | (uc[0]&0x3f);
546 len = 3;
547 } else if (uc[1] | (uc[0] & 0x80)) {
548 if (*outbytesleft < 2) {
549 DEBUG(0,("short utf8 write\n"));
550 goto toobig;
551 }
552 c[0] = 0xc0 | (uc[1]<<2) | (uc[0]>>6);
553 c[1] = 0x80 | (uc[0]&0x3f);
554 len = 2;
555 } else {
556 c[0] = uc[0];
557 }
558
559
560 (*inbytesleft) -= 2;
561 (*outbytesleft) -= len;
562 (*inbuf) += 2;
563 (*outbuf) += len;
564 }
565
566 if (*inbytesleft == 1) {
567 errno = EINVAL;
568 return -1;
569 }
570
571 if (*inbytesleft > 1) {
572 errno = E2BIG;
573 return -1;
574 }
575
576 return 0;
577
578 toobig:
579 errno = E2BIG;
580 return -1;
581 }
582
reg import