lib/silcutil/silcstrutil.c

   1 /*
   2
   3   silcstrutil.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 2002 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; version 2 of the License.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18 */
  19 /* $Id$ */
  20
  21 #include "silcincludes.h"
  22 #include "silcstrutil.h"
  23
  24 static unsigned char pem_enc[64] =
  25 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  26
  27 /* Encodes data into PEM encoding. Returns NULL terminated PEM encoded
  28    data string. Note: This is originally public domain code and is
  29    still PD. */
  30
  31 char *silc_pem_encode(unsigned char *data, SilcUInt32 len)
  32 {
  33   int i, j;
  34   SilcUInt32 bits, c, char_count;
  35   char *pem;
  36
  37   char_count = 0;
  38   bits = 0;
  39   j = 0;
  40
  41   pem = silc_calloc(((len * 8 + 5) / 6) + 5, sizeof(*pem));
  42
  43   for (i = 0; i < len; i++) {
  44     c = data[i];
  45     bits += c;
  46     char_count++;
  47
  48     if (char_count == 3) {
  49       pem[j++] = pem_enc[bits  >> 18];
  50       pem[j++] = pem_enc[(bits >> 12) & 0x3f];
  51       pem[j++] = pem_enc[(bits >> 6)  & 0x3f];
  52       pem[j++] = pem_enc[bits & 0x3f];
  53       bits = 0;
  54       char_count = 0;
  55     } else {
  56       bits <<= 8;
  57     }
  58   }
  59
  60   if (char_count != 0) {
  61     bits <<= 16 - (8 * char_count);
  62     pem[j++] = pem_enc[bits >> 18];
  63     pem[j++] = pem_enc[(bits >> 12) & 0x3f];
  64
  65     if (char_count == 1) {
  66       pem[j++] = '=';
  67       pem[j] = '=';
  68     } else {
  69       pem[j++] = pem_enc[(bits >> 6) & 0x3f];
  70       pem[j] = '=';
  71     }
  72   }
  73
  74   return pem;
  75 }
  76
  77 /* Same as above but puts newline ('\n') every 72 characters. */
  78
  79 char *silc_pem_encode_file(unsigned char *data, SilcUInt32 data_len)
  80 {
  81   int i, j;
  82   SilcUInt32 len, cols;
  83   char *pem, *pem2;
  84
  85   pem = silc_pem_encode(data, data_len);
  86   len = strlen(pem);
  87
  88   pem2 = silc_calloc(len + (len / 72) + 1, sizeof(*pem2));
  89
  90   for (i = 0, j = 0, cols = 1; i < len; i++, cols++) {
  91     if (cols == 72) {
  92       pem2[i] = '\n';
  93       cols = 0;
  94       len++;
  95       continue;
  96     }
  97
  98     pem2[i] = pem[j++];
  99   }
 100
 101   silc_free(pem);
 102   return pem2;
 103 }
 104
 105 /* Decodes PEM into data. Returns the decoded data. Note: This is
 106    originally public domain code and is still PD. */
 107
 108 unsigned char *silc_pem_decode(unsigned char *pem, SilcUInt32 pem_len,
 109                                SilcUInt32 *ret_len)
 110 {
 111   int i, j;
 112   SilcUInt32 len, c, char_count, bits;
 113   unsigned char *data;
 114   static char ialpha[256], decoder[256];
 115
 116   for (i = 64 - 1; i >= 0; i--) {
 117     ialpha[pem_enc[i]] = 1;
 118     decoder[pem_enc[i]] = i;
 119   }
 120
 121   char_count = 0;
 122   bits = 0;
 123   j = 0;
 124
 125   if (!pem_len)
 126     len = strlen(pem);
 127   else
 128     len = pem_len;
 129
 130   data = silc_calloc(((len * 6) / 8), sizeof(*data));
 131
 132   for (i = 0; i < len; i++) {
 133     c = pem[i];
 134
 135     if (c == '=')
 136       break;
 137
 138     if (c > 127 || !ialpha[c])
 139       continue;
 140
 141     bits += decoder[c];
 142     char_count++;
 143
 144     if (char_count == 4) {
 145       data[j++] = bits >> 16;
 146       data[j++] = (bits >> 8) & 0xff;
 147       data[j++] = bits & 0xff;
 148       bits = 0;
 149       char_count = 0;
 150     } else {
 151       bits <<= 6;
 152     }
 153   }
 154
 155   switch(char_count) {
 156   case 1:
 157     silc_free(data);
 158     return NULL;
 159     break;
 160   case 2:
 161     data[j++] = bits >> 10;
 162     break;
 163   case 3:
 164     data[j++] = bits >> 16;
 165     data[j++] = (bits >> 8) & 0xff;
 166     break;
 167   }
 168
 169   if (ret_len)
 170     *ret_len = j;
 171
 172   return data;
 173 }
 174
 175 /* Encodes the string `bin' of which encoding is `bin_encoding' to the
 176    UTF-8 encoding into the buffer `utf8' which is of size of `utf8_size'.
 177    Returns the length of the UTF-8 encoded string, or zero (0) on error.
 178    By default `bin_encoding' is ASCII, and the caller needs to know the
 179    encoding of the input string if it is anything else. */
 180
 181 SilcUInt32 silc_utf8_encode(const unsigned char *bin, SilcUInt32 bin_len,
 182                             SilcStringEncoding bin_encoding,
 183                             unsigned char *utf8, SilcUInt32 utf8_size)
 184 {
 185   SilcUInt32 enclen = 0, i, charval = 0;
 186
 187   if (!bin || !bin_len)
 188     return 0;
 189
 190   if (silc_utf8_valid(bin, bin_len) && bin_len <= utf8_size) {
 191     memcpy(utf8, bin, bin_len);
 192     return bin_len;
 193   }
 194
 195   if (bin_encoding == SILC_STRING_LANGUAGE) {
 196 #if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO) && defined(CODESET)
 197     char *fromconv, *icp, *ocp;
 198     iconv_t icd;
 199     size_t inlen, outlen;
 200
 201     setlocale(LC_CTYPE, "");
 202     fromconv = nl_langinfo(CODESET);
 203     if (fromconv && strlen(fromconv)) {
 204       icd = iconv_open("UTF-8", fromconv);
 205       icp = (char *)bin;
 206       ocp = (char *)utf8;
 207       inlen = bin_len;
 208       outlen = utf8_size;
 209       if (icp && ocp && icd != (iconv_t)-1) {
 210         if (iconv(icd, &icp, &inlen, &ocp, &outlen) != -1) {
 211           utf8_size -= outlen;
 212           iconv_close(icd);
 213           return utf8_size;
 214         }
 215         iconv_close(icd);
 216       }
 217     }
 218 #endif
 219
 220     /* Fallback to 8-bit ASCII */
 221     bin_encoding = SILC_STRING_ASCII;
 222   }
 223
 224   for (i = 0; i < bin_len; i++) {
 225     switch (bin_encoding) {
 226     case SILC_STRING_ASCII:
 227       charval = bin[i];
 228       break;
 229     case SILC_STRING_ASCII_ESC:
 230       SILC_NOT_IMPLEMENTED("SILC_STRING_ASCII_ESC");
 231       return 0;
 232       break;
 233     case SILC_STRING_BMP:
 234       SILC_GET16_MSB(charval, bin + i);
 235       i += 1;
 236       break;
 237     case SILC_STRING_BMP_LSB:
 238       SILC_GET16_LSB(charval, bin + i);
 239       i += 1;
 240       break;
 241     case SILC_STRING_UNIVERSAL:
 242       SILC_GET32_MSB(charval, bin + i);
 243       i += 3;
 244       break;
 245     case SILC_STRING_UNIVERSAL_LSB:
 246       SILC_GET32_LSB(charval, bin + i);
 247       i += 3;
 248       break;
 249     case SILC_STRING_LANGUAGE:
 250       break;
 251     }
 252
 253     if (charval < 0x80) {
 254       if (utf8) {
 255         if (enclen > utf8_size)
 256           return 0;
 257
 258         utf8[enclen] = (unsigned char)charval;
 259       }
 260       enclen++;
 261     } else if (charval < 0x800) {
 262       if (utf8) {
 263         if (enclen + 2 > utf8_size)
 264           return 0;
 265
 266         utf8[enclen    ] = (unsigned char )(((charval >> 6)  & 0x1f) | 0xc0);
 267         utf8[enclen + 1] = (unsigned char )((charval & 0x3f) | 0x80);
 268       }
 269       enclen += 2;
 270     } else if (charval < 0x10000) {
 271       if (utf8) {
 272         if (enclen + 3 > utf8_size)
 273           return 0;
 274
 275         utf8[enclen    ] = (unsigned char )(((charval >> 12) & 0xf)  | 0xe0);
 276         utf8[enclen + 1] = (unsigned char )(((charval >> 6)  & 0x3f) | 0x80);
 277         utf8[enclen + 2] = (unsigned char )((charval & 0x3f) | 0x80);
 278       }
 279       enclen += 3;
 280     } else if (charval < 0x200000) {
 281       if (utf8) {
 282         if (enclen + 4 > utf8_size)
 283           return 0;
 284
 285         utf8[enclen    ] = (unsigned char )(((charval >> 18) & 0x7)  | 0xf0);
 286         utf8[enclen + 1] = (unsigned char )(((charval >> 12) & 0x3f) | 0x80);
 287         utf8[enclen + 2] = (unsigned char )(((charval >> 6)  & 0x3f) | 0x80);
 288         utf8[enclen + 3] = (unsigned char )((charval & 0x3f) | 0x80);
 289       }
 290       enclen += 4;
 291     } else if (charval < 0x4000000) {
 292       if (utf8) {
 293         if (enclen + 5 > utf8_size)
 294           return 0;
 295
 296         utf8[enclen    ] = (unsigned char )(((charval >> 24) & 0x3)  | 0xf8);
 297         utf8[enclen + 1] = (unsigned char )(((charval >> 18) & 0x3f) | 0x80);
 298         utf8[enclen + 2] = (unsigned char )(((charval >> 12) & 0x3f) | 0x80);
 299         utf8[enclen + 3] = (unsigned char )(((charval >> 6)  & 0x3f) | 0x80);
 300         utf8[enclen + 4] = (unsigned char )((charval & 0x3f) | 0x80);
 301       }
 302       enclen += 5;
 303     } else {
 304       if (utf8) {
 305         if (enclen + 6 > utf8_size)
 306           return 0;
 307
 308         utf8[enclen    ] = (unsigned char )(((charval >> 30) & 0x1)  | 0xfc);
 309         utf8[enclen + 1] = (unsigned char )(((charval >> 24) & 0x3f) | 0x80);
 310         utf8[enclen + 2] = (unsigned char )(((charval >> 18) & 0x3f) | 0x80);
 311         utf8[enclen + 3] = (unsigned char )(((charval >> 12) & 0x3f) | 0x80);
 312         utf8[enclen + 4] = (unsigned char )(((charval >> 6)  & 0x3f) | 0x80);
 313         utf8[enclen + 5] = (unsigned char )((charval & 0x3f) | 0x80);
 314       }
 315       enclen += 6;
 316     }
 317   }
 318
 319   return enclen;
 320 }
 321
 322 /* Decodes UTF-8 encoded string `utf8' to string of which encoding is
 323    to be `bin_encoding', into the `bin' buffer of size of `bin_size'.
 324    Returns the length of the decoded buffer, or zero (0) on error.
 325    By default `bin_encoding' is ASCII, and the caller needs to know to
 326    which encoding the output string is to be encoded if ASCII is not
 327    desired. */
 328
 329 SilcUInt32 silc_utf8_decode(const unsigned char *utf8, SilcUInt32 utf8_len,
 330                             SilcStringEncoding bin_encoding,
 331                             unsigned char *bin, SilcUInt32 bin_size)
 332 {
 333   SilcUInt32 enclen = 0, i, charval;
 334
 335   if (!utf8 || !utf8_len)
 336     return 0;
 337
 338   if (bin_encoding == SILC_STRING_LANGUAGE) {
 339 #if defined(HAVE_ICONV) && defined(HAVE_NL_LANGINFO) && defined(CODESET)
 340     char *toconv, *icp, *ocp;
 341     iconv_t icd;
 342     size_t inlen, outlen;
 343
 344     setlocale(LC_CTYPE, "");
 345     toconv = nl_langinfo(CODESET);
 346     if (toconv && strlen(toconv)) {
 347       icd = iconv_open(toconv, "UTF-8");
 348       icp = (char *)utf8;
 349       ocp = (char *)bin;
 350       inlen = utf8_len;
 351       outlen = bin_size;
 352       if (icp && ocp && icd != (iconv_t)-1) {
 353         if (iconv(icd, &icp, &inlen, &ocp, &outlen) != -1) {
 354           bin_size -= outlen;
 355           iconv_close(icd);
 356           return bin_size;
 357         }
 358         iconv_close(icd);
 359       }
 360     }
 361 #endif
 362
 363     /* Fallback to 8-bit ASCII */
 364     bin_encoding = SILC_STRING_ASCII;
 365   }
 366
 367   for (i = 0; i < utf8_len; i++) {
 368     if ((utf8[i] & 0x80) == 0x00) {
 369       charval = utf8[i] & 0x7f;
 370     } else if ((utf8[i] & 0xe0) == 0xc0) {
 371       if (utf8_len < 2)
 372         return 0;
 373
 374       if ((utf8[i + 1] & 0xc0) != 0x80)
 375         return 0;
 376
 377       charval = (utf8[i++] & 0x1f) << 6;
 378       charval |= utf8[i] & 0x3f;
 379       if (charval < 0x80)
 380         return 0;
 381     } else if ((utf8[i] & 0xf0) == 0xe0) {
 382       if (utf8_len < 3)
 383         return 0;
 384
 385       if (((utf8[i + 1] & 0xc0) != 0x80) ||
 386           ((utf8[i + 2] & 0xc0) != 0x80))
 387         return 0;
 388
 389       charval = (utf8[i++]  & 0xf)  << 12;
 390       charval |= (utf8[i++] & 0x3f) << 6;
 391       charval |= utf8[i] & 0x3f;
 392       if (charval < 0x800)
 393         return 0;
 394     } else if ((utf8[i] & 0xf8) == 0xf0) {
 395       if (utf8_len < 4)
 396         return 0;
 397
 398       if (((utf8[i + 1] & 0xc0) != 0x80) ||
 399           ((utf8[i + 2] & 0xc0) != 0x80) ||
 400           ((utf8[i + 3] & 0xc0) != 0x80))
 401         return 0;
 402
 403       charval = ((SilcUInt32)(utf8[i++] & 0x7)) << 18;
 404       charval |= (utf8[i++] & 0x3f) << 12;
 405       charval |= (utf8[i++] & 0x3f) << 6;
 406       charval |= utf8[i] & 0x3f;
 407       if (charval < 0x10000)
 408         return 0;
 409     } else if ((utf8[i] & 0xfc) == 0xf8) {
 410       if (utf8_len < 5)
 411         return 0;
 412
 413       if (((utf8[i + 1] & 0xc0) != 0x80) ||
 414           ((utf8[i + 2] & 0xc0) != 0x80) ||
 415           ((utf8[i + 3] & 0xc0) != 0x80) ||
 416           ((utf8[i + 4] & 0xc0) != 0x80))
 417         return 0;
 418
 419       charval = ((SilcUInt32)(utf8[i++]  & 0x3))  << 24;
 420       charval |= ((SilcUInt32)(utf8[i++] & 0x3f)) << 18;
 421       charval |= ((SilcUInt32)(utf8[i++] & 0x3f)) << 12;
 422       charval |= (utf8[i++] & 0x3f) << 6;
 423       charval |= utf8[i] & 0x3f;
 424       if (charval < 0x200000)
 425         return 0;
 426     } else if ((utf8[i] & 0xfe) == 0xfc) {
 427       if (utf8_len < 6)
 428         return 0;
 429
 430       if (((utf8[i + 1] & 0xc0) != 0x80) ||
 431           ((utf8[i + 2] & 0xc0) != 0x80) ||
 432           ((utf8[i + 3] & 0xc0) != 0x80) ||
 433           ((utf8[i + 4] & 0xc0) != 0x80) ||
 434           ((utf8[i + 5] & 0xc0) != 0x80))
 435         return 0;
 436
 437       charval = ((SilcUInt32)(utf8[i++]  & 0x1))  << 30;
 438       charval |= ((SilcUInt32)(utf8[i++] & 0x3f)) << 24;
 439       charval |= ((SilcUInt32)(utf8[i++] & 0x3f)) << 18;
 440       charval |= ((SilcUInt32)(utf8[i++] & 0x3f)) << 12;
 441       charval |= (utf8[i++] & 0x3f) << 6;
 442       charval |= utf8[i] & 0x3f;
 443       if (charval < 0x4000000)
 444         return 0;
 445     } else {
 446       return 0;
 447     }
 448
 449     switch (bin_encoding) {
 450     case SILC_STRING_ASCII:
 451       if (bin) {
 452         if (enclen + 1 > bin_size)
 453           return 0;
 454
 455         bin[enclen] = (unsigned char)charval;
 456       }
 457       enclen++;
 458       break;
 459     case SILC_STRING_ASCII_ESC:
 460       SILC_NOT_IMPLEMENTED("SILC_STRING_ASCII_ESC");
 461       return 0;
 462       break;
 463     case SILC_STRING_BMP:
 464       SILC_PUT16_MSB(charval, bin + enclen);
 465       enclen += 2;
 466       break;
 467     case SILC_STRING_BMP_LSB:
 468       SILC_PUT16_LSB(charval, bin + enclen);
 469       enclen += 2;
 470       break;
 471     case SILC_STRING_UNIVERSAL:
 472       SILC_PUT32_MSB(charval, bin + enclen);
 473       enclen += 4;
 474       break;
 475     case SILC_STRING_UNIVERSAL_LSB:
 476       SILC_PUT32_LSB(charval, bin + enclen);
 477       enclen += 4;
 478       break;
 479     case SILC_STRING_LANGUAGE:
 480       break;
 481     }
 482   }
 483
 484   return enclen;
 485 }
 486
 487 /* Returns the length of UTF-8 encoded string if the `bin' of
 488    encoding of `bin_encoding' is encoded with silc_utf8_encode. */
 489
 490 SilcUInt32 silc_utf8_encoded_len(const unsigned char *bin, SilcUInt32 bin_len,
 491                                  SilcStringEncoding bin_encoding)
 492 {
 493   return silc_utf8_encode(bin, bin_len, bin_encoding, NULL, 0);
 494 }
 495
 496 /* Returns TRUE if the `utf8' string of length of `utf8_len' is valid
 497    UTF-8 encoded string, FALSE if it is not UTF-8 encoded string. */
 498
 499 bool silc_utf8_valid(const unsigned char *utf8, SilcUInt32 utf8_len)
 500 {
 501   return silc_utf8_decode(utf8, utf8_len, 0, NULL, 0) != 0;
 502 }
 503
 504 /* Mime constants and macros */
 505 #define MIME_VERSION "MIME-Version: "
 506 #define MIME_VERSION_LEN 14
 507 #define MIME_CONTENT_TYPE "Content-Type: "
 508 #define MIME_CONTENT_TYPE_LEN 14
 509 #define MIME_TRANSFER_ENCODING "Content-Transfer-Encoding: "
 510 #define MIME_TRANSFER_ENCODING_LEN 27
 511
 512 #define MIME_GET_FIELD(header, mime, mime_len, field, field_len,        \
 513                        dest, dest_size)                                 \
 514 do {                                                                    \
 515   if (dest) {                                                           \
 516     char *f = strstr(header, field);                                    \
 517     if (f) {                                                            \
 518       f = (char *)mime + (f - header) + field_len;                      \
 519       for (i = 0; i < (mime_len - (f - (char *)mime)); i++) {           \
 520         if (f[i] == '\r' || f[i] == '\n' || i == dest_size)             \
 521           break;                                                        \
 522         dest[i] = f[i];                                                 \
 523       }                                                                 \
 524     }                                                                   \
 525   }                                                                     \
 526 } while(0)
 527
 528 /* Parses MIME object and MIME header in it. */
 529
 530 bool
 531 silc_mime_parse(const unsigned char *mime, SilcUInt32 mime_len,
 532                 char *version, SilcUInt32 version_size,
 533                 char *content_type, SilcUInt32 content_type_size,
 534                 char *transfer_encoding, SilcUInt32 transfer_encoding_size,
 535                 unsigned char **mime_data_ptr, SilcUInt32 *mime_data_len)
 536 {
 537   int i;
 538   char header[256];
 539
 540   memcpy(header, mime, 256 > mime_len ? mime_len : 256);
 541   header[sizeof(header) - 1] = '\0';
 542
 543   /* Check for mandatory Content-Type field */
 544   if (!strstr(header, MIME_CONTENT_TYPE))
 545     return FALSE;
 546
 547   /* Get the pointer to the data area in the object */
 548   for (i = 0; i < mime_len; i++) {
 549     if (mime_len >= i + 4 &&
 550         mime[i    ] == '\r' && mime[i + 1] == '\n' &&
 551         mime[i + 2] == '\r' && mime[i + 3] == '\n')
 552       break;
 553   }
 554   if (i >= mime_len)
 555     return FALSE;
 556
 557   if (mime_data_ptr)
 558     *mime_data_ptr = (unsigned char *)mime + i + 4;
 559   if (mime_data_len)
 560     *mime_data_len = mime_len - ((mime + i + 4) - mime);
 561
 562   /* Get MIME version, Content-Type and Transfer Encoding fields */
 563   MIME_GET_FIELD(header, mime, mime_len,
 564                  MIME_VERSION, MIME_VERSION_LEN,
 565                  version, version_size);
 566   MIME_GET_FIELD(header, mime, mime_len,
 567                  MIME_CONTENT_TYPE, MIME_CONTENT_TYPE_LEN,
 568                  content_type, content_type_size);
 569   MIME_GET_FIELD(header, mime, mime_len,
 570                  MIME_TRANSFER_ENCODING, MIME_TRANSFER_ENCODING_LEN,
 571                  transfer_encoding, transfer_encoding_size);
 572
 573   return TRUE;
 574 }