source/lib/iconv.c

   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         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. It only knows about
  74   a very small number of character sets - just enough that Samba works
  75   on systems that don't have iconv
  76  */
  77 size_t smb_iconv(smb_iconv_t cd,
  78                  const char **inbuf, size_t *inbytesleft,
  79                  char **outbuf, size_t *outbytesleft)
  80 {
  81         char cvtbuf[2048];
  82         char *bufp = cvtbuf;
  83         size_t bufsize;
  84
  85         /* in many cases we can go direct */
  86         if (cd->direct) {
  87                 return cd->direct(cd->cd_direct,
  88                                   (char **)inbuf, inbytesleft, outbuf, outbytesleft);
  89         }
  90
  91
  92         /* otherwise we have to do it chunks at a time */
  93         while (*inbytesleft > 0) {
  94                 bufp = cvtbuf;
  95                 bufsize = sizeof(cvtbuf);
  96
  97                 if (cd->pull(cd->cd_pull,
  98                              (char **)inbuf, inbytesleft, &bufp, &bufsize) == -1
  99                     && errno != E2BIG) return -1;
 100
 101                 bufp = cvtbuf;
 102                 bufsize = sizeof(cvtbuf) - bufsize;
 103
 104                 if (cd->push(cd->cd_push,
 105                              &bufp, &bufsize,
 106                              outbuf, outbytesleft) == -1) return -1;
 107         }
 108
 109         return 0;
 110 }
 111
 112 /*
 113   simple iconv_open() wrapper
 114  */
 115 smb_iconv_t smb_iconv_open(const char *tocode, const char *fromcode)
 116 {
 117         smb_iconv_t ret;
 118         int from, to;
 119
 120         ret = (smb_iconv_t)malloc(sizeof(*ret));
 121         if (!ret) {
 122                 errno = ENOMEM;
 123                 return (smb_iconv_t)-1;
 124         }
 125         memset(ret, 0, sizeof(*ret));
 126
 127         ret->from_name = strdup(fromcode);
 128         ret->to_name = strdup(tocode);
 129
 130         /* check for the simplest null conversion */
 131         if (strcmp(fromcode, tocode) == 0) {
 132                 ret->direct = iconv_copy;
 133                 return ret;
 134         }
 135
 136         for (from=0; charsets[from].name; from++) {
 137                 if (strcasecmp(charsets[from].name, fromcode) == 0) break;
 138         }
 139         for (to=0; charsets[to].name; to++) {
 140                 if (strcasecmp(charsets[to].name, tocode) == 0) break;
 141         }
 142
 143 #ifdef HAVE_NATIVE_ICONV
 144         if (!charsets[from].name) {
 145                 ret->pull = sys_iconv;
 146                 ret->cd_pull = iconv_open("UCS-2LE", fromcode);
 147                 if (ret->cd_pull == (iconv_t)-1) goto failed;
 148         }
 149         if (!charsets[to].name) {
 150                 ret->push = sys_iconv;
 151                 ret->cd_push = iconv_open(tocode, "UCS-2LE");
 152                 if (ret->cd_push == (iconv_t)-1) goto failed;
 153         }
 154 #else
 155         if (!charsets[from].name || !charsets[to].name) {
 156                 goto failed;
 157         }
 158 #endif
 159
 160         /* check for conversion to/from ucs2 */
 161         if (from == 0 && charsets[to].name) {
 162                 ret->direct = charsets[to].push;
 163                 return ret;
 164         }
 165         if (to == 0 && charsets[from].name) {
 166                 ret->direct = charsets[from].pull;
 167                 return ret;
 168         }
 169
 170 #ifdef HAVE_NATIVE_ICONV
 171         if (from == 0) {
 172                 ret->direct = sys_iconv;
 173                 ret->cd_direct = ret->cd_push;
 174                 ret->cd_push = NULL;
 175                 return ret;
 176         }
 177         if (to == 0) {
 178                 ret->direct = sys_iconv;
 179                 ret->cd_direct = ret->cd_pull;
 180                 ret->cd_pull = NULL;
 181                 return ret;
 182         }
 183 #endif
 184
 185         /* the general case has to go via a buffer */
 186         if (!ret->pull) ret->pull = charsets[from].pull;
 187         if (!ret->push) ret->push = charsets[to].push;
 188         return ret;
 189
 190 failed:
 191         SAFE_FREE(ret);
 192         errno = EINVAL;
 193         return (smb_iconv_t)-1;
 194 }
 195
 196 /*
 197   simple iconv_close() wrapper
 198 */
 199 int smb_iconv_close (smb_iconv_t cd)
 200 {
 201 #ifdef HAVE_NATIVE_ICONV
 202         if (cd->cd_direct) iconv_close((iconv_t)cd->cd_direct);
 203         if (cd->cd_pull) iconv_close((iconv_t)cd->cd_pull);
 204         if (cd->cd_push) iconv_close((iconv_t)cd->cd_push);
 205 #endif
 206
 207         SAFE_FREE(cd->from_name);
 208         SAFE_FREE(cd->to_name);
 209
 210         memset(cd, 0, sizeof(*cd));
 211         SAFE_FREE(cd);
 212         return 0;
 213 }
 214
 215
 216 /**********************************************************************
 217  the following functions implement the builtin character sets in Samba
 218  and also the "test" character sets that are designed to test
 219  multi-byte character set support for english users
 220 ***********************************************************************/
 221
 222 static size_t ascii_pull(void *cd, char **inbuf, size_t *inbytesleft,
 223                          char **outbuf, size_t *outbytesleft)
 224 {
 225         while (*inbytesleft >= 1 && *outbytesleft >= 2) {
 226                 (*outbuf)[0] = (*inbuf)[0];
 227                 (*outbuf)[1] = 0;
 228                 (*inbytesleft)  -= 1;
 229                 (*outbytesleft) -= 2;
 230                 (*inbuf)  += 1;
 231                 (*outbuf) += 2;
 232         }
 233
 234         if (*inbytesleft > 0) {
 235                 errno = E2BIG;
 236                 return -1;
 237         }
 238
 239         return 0;
 240 }
 241
 242 static size_t ascii_push(void *cd, char **inbuf, size_t *inbytesleft,
 243                          char **outbuf, size_t *outbytesleft)
 244 {
 245         int ir_count=0;
 246
 247         while (*inbytesleft >= 2 && *outbytesleft >= 1) {
 248                 (*outbuf)[0] = (*inbuf)[0] & 0x7F;
 249                 if ((*inbuf)[1]) ir_count++;
 250                 (*inbytesleft)  -= 2;
 251                 (*outbytesleft) -= 1;
 252                 (*inbuf)  += 2;
 253                 (*outbuf) += 1;
 254         }
 255
 256         if (*inbytesleft == 1) {
 257                 errno = EINVAL;
 258                 return -1;
 259         }
 260
 261         if (*inbytesleft > 1) {
 262                 errno = E2BIG;
 263                 return -1;
 264         }
 265
 266         return ir_count;
 267 }
 268
 269
 270 static size_t ucs2hex_pull(void *cd, char **inbuf, size_t *inbytesleft,
 271                          char **outbuf, size_t *outbytesleft)
 272 {
 273         while (*inbytesleft >= 1 && *outbytesleft >= 2) {
 274                 unsigned v;
 275
 276                 if ((*inbuf)[0] != '@') {
 277                         /* seven bit ascii case */
 278                         (*outbuf)[0] = (*inbuf)[0];
 279                         (*outbuf)[1] = 0;
 280                         (*inbytesleft)  -= 1;
 281                         (*outbytesleft) -= 2;
 282                         (*inbuf)  += 1;
 283                         (*outbuf) += 2;
 284                         continue;
 285                 }
 286                 /* it's a hex character */
 287                 if (*inbytesleft < 5) {
 288                         errno = EINVAL;
 289                         return -1;
 290                 }
 291
 292                 if (sscanf(&(*inbuf)[1], "%04x", &v) != 1) {
 293                         errno = EILSEQ;
 294                         return -1;
 295                 }
 296
 297                 (*outbuf)[0] = v&0xff;
 298                 (*outbuf)[1] = v>>8;
 299                 (*inbytesleft)  -= 5;
 300                 (*outbytesleft) -= 2;
 301                 (*inbuf)  += 5;
 302                 (*outbuf) += 2;
 303         }
 304
 305         if (*inbytesleft > 0) {
 306                 errno = E2BIG;
 307                 return -1;
 308         }
 309
 310         return 0;
 311 }
 312
 313 static size_t ucs2hex_push(void *cd, char **inbuf, size_t *inbytesleft,
 314                            char **outbuf, size_t *outbytesleft)
 315 {
 316         while (*inbytesleft >= 2 && *outbytesleft >= 1) {
 317                 char buf[6];
 318
 319                 if ((*inbuf)[1] == 0 &&
 320                     ((*inbuf)[0] & 0x80) == 0 &&
 321                     (*inbuf)[0] != '@') {
 322                         (*outbuf)[0] = (*inbuf)[0];
 323                         (*inbytesleft)  -= 2;
 324                         (*outbytesleft) -= 1;
 325                         (*inbuf)  += 2;
 326                         (*outbuf) += 1;
 327                         continue;
 328                 }
 329                 if (*outbytesleft < 5) {
 330                         errno = E2BIG;
 331                         return -1;
 332                 }
 333                 snprintf(buf, 6, "@%04x", SVAL(*inbuf, 0));
 334                 memcpy(*outbuf, buf, 5);
 335                 (*inbytesleft)  -= 2;
 336                 (*outbytesleft) -= 5;
 337                 (*inbuf)  += 2;
 338                 (*outbuf) += 5;
 339         }
 340
 341         if (*inbytesleft == 1) {
 342                 errno = EINVAL;
 343                 return -1;
 344         }
 345
 346         if (*inbytesleft > 1) {
 347                 errno = E2BIG;
 348                 return -1;
 349         }
 350
 351         return 0;
 352 }
 353
 354
 355 /* the "weird" character set is very useful for testing multi-byte
 356    support and finding bugs. Don't use on a production system!
 357 */
 358 static struct {
 359         char from;
 360         char *to;
 361         int len;
 362 } weird_table[] = {
 363         {'q', "^q^", 3},
 364         {'Q', "^Q^", 3},
 365         {0, NULL}
 366 };
 367
 368 static size_t weird_pull(void *cd, char **inbuf, size_t *inbytesleft,
 369                          char **outbuf, size_t *outbytesleft)
 370 {
 371         while (*inbytesleft >= 1 && *outbytesleft >= 2) {
 372                 int i;
 373                 int done = 0;
 374                 for (i=0;weird_table[i].from;i++) {
 375                         if (strncmp((*inbuf),
 376                                     weird_table[i].to,
 377                                     weird_table[i].len) == 0) {
 378                                 if (*inbytesleft < weird_table[i].len) {
 379                                         DEBUG(0,("ERROR: truncated weird string\n"));
 380                                         /* smb_panic("weird_pull"); */
 381
 382                                 } else {
 383                                         (*outbuf)[0] = weird_table[i].from;
 384                                         (*outbuf)[1] = 0;
 385                                         (*inbytesleft)  -= weird_table[i].len;
 386                                         (*outbytesleft) -= 2;
 387                                         (*inbuf)  += weird_table[i].len;
 388                                         (*outbuf) += 2;
 389                                         done = 1;
 390                                         break;
 391                                 }
 392                         }
 393                 }
 394                 if (done) continue;
 395                 (*outbuf)[0] = (*inbuf)[0];
 396                 (*outbuf)[1] = 0;
 397                 (*inbytesleft)  -= 1;
 398                 (*outbytesleft) -= 2;
 399                 (*inbuf)  += 1;
 400                 (*outbuf) += 2;
 401         }
 402
 403         if (*inbytesleft > 0) {
 404                 errno = E2BIG;
 405                 return -1;
 406         }
 407
 408         return 0;
 409 }
 410
 411 static size_t weird_push(void *cd, char **inbuf, size_t *inbytesleft,
 412                          char **outbuf, size_t *outbytesleft)
 413 {
 414         int ir_count=0;
 415
 416         while (*inbytesleft >= 2 && *outbytesleft >= 1) {
 417                 int i;
 418                 int done=0;
 419                 for (i=0;weird_table[i].from;i++) {
 420                         if ((*inbuf)[0] == weird_table[i].from &&
 421                             (*inbuf)[1] == 0) {
 422                                 if (*outbytesleft < weird_table[i].len) {
 423                                         DEBUG(0,("No room for weird character\n"));
 424                                         /* smb_panic("weird_push"); */
 425                                 } else {
 426                                         memcpy(*outbuf, weird_table[i].to,
 427                                                weird_table[i].len);
 428                                         (*inbytesleft)  -= 2;
 429                                         (*outbytesleft) -= weird_table[i].len;
 430                                         (*inbuf)  += 2;
 431                                         (*outbuf) += weird_table[i].len;
 432                                         done = 1;
 433                                         break;
 434                                 }
 435                         }
 436                 }
 437                 if (done) continue;
 438
 439                 (*outbuf)[0] = (*inbuf)[0];
 440                 if ((*inbuf)[1]) ir_count++;
 441                 (*inbytesleft)  -= 2;
 442                 (*outbytesleft) -= 1;
 443                 (*inbuf)  += 2;
 444                 (*outbuf) += 1;
 445         }
 446
 447         if (*inbytesleft == 1) {
 448                 errno = EINVAL;
 449                 return -1;
 450         }
 451
 452         if (*inbytesleft > 1) {
 453                 errno = E2BIG;
 454                 return -1;
 455         }
 456
 457         return ir_count;
 458 }
 459
 460 static size_t iconv_copy(void *cd, char **inbuf, size_t *inbytesleft,
 461                          char **outbuf, size_t *outbytesleft)
 462 {
 463         int n;
 464
 465         n = MIN(*inbytesleft, *outbytesleft);
 466
 467         memmove(*outbuf, *inbuf, n);
 468
 469         (*inbytesleft) -= n;
 470         (*outbytesleft) -= n;
 471         (*inbuf) += n;
 472         (*outbuf) += n;
 473
 474         if (*inbytesleft > 0) {
 475                 errno = E2BIG;
 476                 return -1;
 477         }
 478
 479         return 0;
 480 }
 481
 482 static size_t utf8_pull(void *cd, char **inbuf, size_t *inbytesleft,
 483                          char **outbuf, size_t *outbytesleft)
 484 {
 485         while (*inbytesleft >= 1 && *outbytesleft >= 2) {
 486                 unsigned char *c = (unsigned char *)*inbuf;
 487                 unsigned char *uc = (unsigned char *)*outbuf;
 488                 int len = 1;
 489
 490                 if ((c[0] & 0x80) == 0) {
 491                         uc[0] = c[0];
 492                         uc[1] = 0;
 493                 } else if ((c[0] & 0xf0) == 0xe0) {
 494                         if (*inbytesleft < 3) {
 495                                 DEBUG(0,("short utf8 char\n"));
 496                                 goto badseq;
 497                         }
 498                         uc[1] = ((c[0]&0xF)<<4) | ((c[1]>>2)&0xF);
 499                         uc[0] = (c[1]<<6) | (c[2]&0x3f);
 500                         len = 3;
 501                 } else if ((c[0] & 0xe0) == 0xc0) {
 502                         if (*inbytesleft < 2) {
 503                                 DEBUG(0,("short utf8 char\n"));
 504                                 goto badseq;
 505                         }
 506                         uc[1] = (c[0]>>2) & 0x7;
 507                         uc[0] = (c[0]<<6) | (c[1]&0x3f);
 508                         len = 2;
 509                 }
 510
 511                 (*inbuf)  += len;
 512                 (*inbytesleft)  -= len;
 513                 (*outbytesleft) -= 2;
 514                 (*outbuf) += 2;
 515         }
 516
 517         if (*inbytesleft > 0) {
 518                 errno = E2BIG;
 519                 return -1;
 520         }
 521
 522         return 0;
 523
 524 badseq:
 525         errno = EINVAL;
 526         return -1;
 527 }
 528
 529 static size_t utf8_push(void *cd, char **inbuf, size_t *inbytesleft,
 530                          char **outbuf, size_t *outbytesleft)
 531 {
 532         while (*inbytesleft >= 2 && *outbytesleft >= 1) {
 533                 unsigned char *c = (unsigned char *)*outbuf;
 534                 unsigned char *uc = (unsigned char *)*inbuf;
 535                 int len=1;
 536
 537                 if (uc[1] & 0xf8) {
 538                         if (*outbytesleft < 3) {
 539                                 DEBUG(0,("short utf8 write\n"));
 540                                 goto toobig;
 541                         }
 542                         c[0] = 0xe0 | (uc[1]>>4);
 543                         c[1] = 0x80 | ((uc[1]&0xF)<<2) | (uc[0]>>6);
 544                         c[2] = 0x80 | (uc[0]&0x3f);
 545                         len = 3;
 546                 } else if (uc[1] | (uc[0] & 0x80)) {
 547                         if (*outbytesleft < 2) {
 548                                 DEBUG(0,("short utf8 write\n"));
 549                                 goto toobig;
 550                         }
 551                         c[0] = 0xc0 | (uc[1]<<2) | (uc[0]>>6);
 552                         c[1] = 0x80 | (uc[0]&0x3f);
 553                         len = 2;
 554                 } else {
 555                         c[0] = uc[0];
 556                 }
 557
 558
 559                 (*inbytesleft)  -= 2;
 560                 (*outbytesleft) -= len;
 561                 (*inbuf)  += 2;
 562                 (*outbuf) += len;
 563         }
 564
 565         if (*inbytesleft == 1) {
 566                 errno = EINVAL;
 567                 return -1;
 568         }
 569
 570         if (*inbytesleft > 1) {
 571                 errno = E2BIG;
 572                 return -1;
 573         }
 574
 575         return 0;
 576
 577 toobig:
 578         errno = E2BIG;
 579         return -1;
 580 }
 581