updates
[silc.git] / 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   for (i = 0; i < bin_len; i++) {
196     switch (bin_encoding) {
197     case SILC_STRING_ASCII:
198       charval = bin[i];
199       break;
200     case SILC_STRING_ASCII_ESC:
201       break;
202     case SILC_STRING_BMP:
203       break;
204     case SILC_STRING_UNIVERSAL:
205       break;
206     }
207
208     if (charval < 0x80) {
209       if (utf8) {
210         if (enclen > utf8_size)
211           return 0;
212
213         utf8[enclen] = (unsigned char)charval;
214       }
215       enclen++;
216     } else if (charval < 0x800) {
217       if (utf8) {
218         if (enclen + 2 > utf8_size)
219           return 0;
220
221         utf8[enclen    ] = (unsigned char )(((charval >> 6)  & 0x1f) | 0xc0);
222         utf8[enclen + 1] = (unsigned char )((charval & 0x3f) | 0x80);
223       }
224       enclen += 2;
225     } else if (charval < 0x10000) {
226       if (utf8) {
227         if (enclen + 3 > utf8_size)
228           return 0;
229
230         utf8[enclen    ] = (unsigned char )(((charval >> 12) & 0xf)  | 0xe0);
231         utf8[enclen + 1] = (unsigned char )(((charval >> 6)  & 0x3f) | 0x80);
232         utf8[enclen + 2] = (unsigned char )((charval & 0x3f) | 0x80);
233       }
234       enclen += 3;
235     } else if (charval < 0x200000) {
236       if (utf8) {
237         if (enclen + 4 > utf8_size)
238           return 0;
239
240         utf8[enclen    ] = (unsigned char )(((charval >> 18) & 0x7)  | 0xf0);
241         utf8[enclen + 1] = (unsigned char )(((charval >> 12) & 0x3f) | 0x80);
242         utf8[enclen + 2] = (unsigned char )(((charval >> 6)  & 0x3f) | 0x80);
243         utf8[enclen + 3] = (unsigned char )((charval & 0x3f) | 0x80);
244       }
245       enclen += 4;
246     } else if (charval < 0x4000000) {
247       if (utf8) {
248         if (enclen + 5 > utf8_size)
249           return 0;
250
251         utf8[enclen    ] = (unsigned char )(((charval >> 24) & 0x3)  | 0xf8);
252         utf8[enclen + 1] = (unsigned char )(((charval >> 18) & 0x3f) | 0x80);
253         utf8[enclen + 2] = (unsigned char )(((charval >> 12) & 0x3f) | 0x80);
254         utf8[enclen + 3] = (unsigned char )(((charval >> 6)  & 0x3f) | 0x80);
255         utf8[enclen + 4] = (unsigned char )((charval & 0x3f) | 0x80);
256       }
257       enclen += 5;
258     } else {
259       if (utf8) {
260         if (enclen + 6 > utf8_size)
261           return 0;
262
263         utf8[enclen    ] = (unsigned char )(((charval >> 30) & 0x1)  | 0xfc);
264         utf8[enclen + 1] = (unsigned char )(((charval >> 24) & 0x3f) | 0x80);
265         utf8[enclen + 2] = (unsigned char )(((charval >> 18) & 0x3f) | 0x80);
266         utf8[enclen + 3] = (unsigned char )(((charval >> 12) & 0x3f) | 0x80);
267         utf8[enclen + 4] = (unsigned char )(((charval >> 6)  & 0x3f) | 0x80);
268         utf8[enclen + 5] = (unsigned char )((charval & 0x3f) | 0x80);
269       }
270       enclen += 6;
271     }
272   }
273
274   return enclen;
275 }
276
277 /* Decodes UTF-8 encoded string `utf8' to string of which encoding is
278    to be `bin_encoding', into the `bin' buffer of size of `bin_size'.
279    Returns the length of the decoded buffer, or zero (0) on error.
280    By default `bin_encoding' is ASCII, and the caller needs to know to
281    which encoding the output string is to be encoded if ASCII is not
282    desired. */
283
284 SilcUInt32 silc_utf8_decode(const unsigned char *utf8, SilcUInt32 utf8_len,
285                             SilcStringEncoding bin_encoding,
286                             unsigned char *bin, SilcUInt32 bin_size)
287 {
288   SilcUInt32 enclen = 0, i, charval;
289
290   if (!utf8 || !utf8_len)
291     return 0;
292
293   for (i = 0; i < utf8_len; i++) {
294     if ((utf8[i] & 0x80) == 0x00) {
295       charval = utf8[i] & 0x7f;
296     } else if ((utf8[i] & 0xe0) == 0xc0) {
297       if (utf8_len < 2)
298         return 0;
299
300       if ((utf8[i + 1] & 0xc0) != 0x80)
301         return 0;
302
303       charval = (utf8[i++] & 0x1f) << 6;
304       charval |= utf8[i] & 0x3f;
305       if (charval < 0x80)
306         return 0;
307     } else if ((utf8[i] & 0xf0) == 0xe0) {
308       if (utf8_len < 3)
309         return 0;
310
311       if (((utf8[i + 1] & 0xc0) != 0x80) || 
312           ((utf8[i + 2] & 0xc0) != 0x80))
313         return 0;
314
315       charval = (utf8[i++]  & 0xf)  << 12;
316       charval |= (utf8[i++] & 0x3f) << 6;
317       charval |= utf8[i] & 0x3f;
318       if (charval < 0x800)
319         return 0;
320     } else if ((utf8[i] & 0xf8) == 0xf0) {
321       if (utf8_len < 4)
322         return 0;
323
324       if (((utf8[i + 1] & 0xc0) != 0x80) || 
325           ((utf8[i + 2] & 0xc0) != 0x80) ||
326           ((utf8[i + 3] & 0xc0) != 0x80))
327         return 0;
328
329       charval = ((SilcUInt32)(utf8[i++] & 0x7)) << 18;
330       charval |= (utf8[i++] & 0x3f) << 12;
331       charval |= (utf8[i++] & 0x3f) << 6;
332       charval |= utf8[i] & 0x3f;
333       if (charval < 0x10000)
334         return 0;
335     } else if ((utf8[i] & 0xfc) == 0xf8) {
336       if (utf8_len < 5)
337         return 0;
338
339       if (((utf8[i + 1] & 0xc0) != 0x80) || 
340           ((utf8[i + 2] & 0xc0) != 0x80) ||
341           ((utf8[i + 3] & 0xc0) != 0x80) ||
342           ((utf8[i + 4] & 0xc0) != 0x80))
343         return 0;
344
345       charval = ((SilcUInt32)(utf8[i++]  & 0x3))  << 24;
346       charval |= ((SilcUInt32)(utf8[i++] & 0x3f)) << 18;
347       charval |= ((SilcUInt32)(utf8[i++] & 0x3f)) << 12;
348       charval |= (utf8[i++] & 0x3f) << 6;
349       charval |= utf8[i] & 0x3f;
350       if (charval < 0x200000)
351         return 0;
352     } else if ((utf8[i] & 0xfe) == 0xfc) {
353       if (utf8_len < 6)
354         return 0;
355
356       if (((utf8[i + 1] & 0xc0) != 0x80) || 
357           ((utf8[i + 2] & 0xc0) != 0x80) ||
358           ((utf8[i + 3] & 0xc0) != 0x80) ||
359           ((utf8[i + 4] & 0xc0) != 0x80) ||
360           ((utf8[i + 5] & 0xc0) != 0x80))
361         return 0;
362
363       charval = ((SilcUInt32)(utf8[i++]  & 0x1))  << 30;
364       charval |= ((SilcUInt32)(utf8[i++] & 0x3f)) << 24;
365       charval |= ((SilcUInt32)(utf8[i++] & 0x3f)) << 18;
366       charval |= ((SilcUInt32)(utf8[i++] & 0x3f)) << 12;
367       charval |= (utf8[i++] & 0x3f) << 6;
368       charval |= utf8[i] & 0x3f;
369       if (charval < 0x4000000)
370         return 0;
371     } else {
372       return 0;
373     }
374
375     switch (bin_encoding) {
376     case SILC_STRING_ASCII:
377       if (bin) {
378         if (enclen + 1 > bin_size)
379           return 0;
380
381         bin[enclen] = (unsigned char)charval;
382       }
383       enclen++;
384       break;
385     case SILC_STRING_ASCII_ESC:
386       return 0;
387       break;
388     case SILC_STRING_BMP:
389       return 0;
390       break;
391     case SILC_STRING_UNIVERSAL:
392       return 0;
393       break;
394     }
395   }
396
397   return enclen;
398 }
399
400 /* Returns the length of UTF-8 encoded string if the `bin' of
401    encoding of `bin_encoding' is encoded with silc_utf8_encode. */
402
403 SilcUInt32 silc_utf8_encoded_len(const unsigned char *bin, SilcUInt32 bin_len,
404                                  SilcStringEncoding bin_encoding)
405 {
406   return silc_utf8_encode(bin, bin_len, bin_encoding, NULL, 0);
407 }
408
409 /* Returns TRUE if the `utf8' string of length of `utf8_len' is valid
410    UTF-8 encoded string, FALSE if it is not UTF-8 encoded string. */
411
412 bool silc_utf8_valid(const unsigned char *utf8, SilcUInt32 utf8_len)
413 {
414   return silc_utf8_decode(utf8, utf8_len, 0, NULL, 0) != 0;
415 }
416
417 /* Mime constants and macros */
418 #define MIME_VERSION "MIME-Version: "
419 #define MIME_VERSION_LEN 14
420 #define MIME_CONTENT_TYPE "Content-Type: "
421 #define MIME_CONTENT_TYPE_LEN 14
422 #define MIME_TRANSFER_ENCODING "Content-Transfer-Encoding: "
423 #define MIME_TRANSFER_ENCODING_LEN 27
424
425 #define MIME_GET_FIELD(header, mime, mime_len, field, field_len,        \
426                        dest, dest_size)                                 \
427 do {                                                                    \
428   if (dest) {                                                           \
429     char *f = strstr(header, field);                                    \
430     if (f) {                                                            \
431       f = (char *)mime + (f - header) + field_len;                      \
432       for (i = 0; i < (mime_len - (f - (char *)mime)); i++) {           \
433         if (f[i] == '\r' || f[i] == '\n' || i == dest_size)             \
434           break;                                                        \
435         dest[i] = f[i];                                                 \
436       }                                                                 \
437     }                                                                   \
438   }                                                                     \
439 } while(0)
440
441 /* Parses MIME object and MIME header in it. */
442
443 bool 
444 silc_mime_parse(const unsigned char *mime, SilcUInt32 mime_len,
445                 char *version, SilcUInt32 version_size,
446                 char *content_type, SilcUInt32 content_type_size,
447                 char *transfer_encoding, SilcUInt32 transfer_encoding_size,
448                 unsigned char **mime_data_ptr, SilcUInt32 *mime_data_len)
449
450   int i;
451   char header[256];
452    
453   memcpy(header, mime, 256 > mime_len ? mime_len : 256);
454   header[sizeof(header) - 1] = '\0';
455
456   /* Check for mandatory Content-Type field */
457   if (!strstr(header, MIME_CONTENT_TYPE))
458     return FALSE;
459   
460   /* Get the pointer to the data area in the object */
461   for (i = 0; i < mime_len; i++) {
462     if (mime_len >= i + 4 &&
463         mime[i    ] == '\r' && mime[i + 1] == '\n' &&
464         mime[i + 2] == '\r' && mime[i + 3] == '\n')
465       break;
466   }
467   if (i >= mime_len)
468     return FALSE;
469
470   if (mime_data_ptr)
471     *mime_data_ptr = (unsigned char *)mime + i + 4;
472   if (mime_data_len)
473     *mime_data_len = mime_len - ((mime + i + 4) - mime);
474   
475   /* Get MIME version, Content-Type and Transfer Encoding fields */
476   MIME_GET_FIELD(header, mime, mime_len,
477                  MIME_VERSION, MIME_VERSION_LEN,
478                  version, version_size);
479   MIME_GET_FIELD(header, mime, mime_len,
480                  MIME_CONTENT_TYPE, MIME_CONTENT_TYPE_LEN,
481                  content_type, content_type_size);
482   MIME_GET_FIELD(header, mime, mime_len,
483                  MIME_TRANSFER_ENCODING, MIME_TRANSFER_ENCODING_LEN,
484                  transfer_encoding, transfer_encoding_size);
485
486   return TRUE;
487 }