From 383f245d39b8b806a4b6ce4dea7b0ab7f1658450 Mon Sep 17 00:00:00 2001 From: NotZed Date: Thu, 20 Apr 2000 23:48:45 +0000 Subject: MERGE NEW_PARSER branch into HEAD, fixed conflicts. 2000-04-20 NotZed * MERGE NEW_PARSER branch into HEAD, fixed conflicts. * gmime-content-field.c (_print_parameter): Duh, removed again (@@#$@ cvs merge). * camel-mime-utils.c (header_content_type_is): Constify. (header_content_type_unref): Killed a couple warnings. * camel-folder.c (_init): Removed more log crap. * providers/Makefile.am (SUBDIRS): Removed nntp, pending fixes for summary changes. * providers/mbox/camel-mbox-folder.c (_get_message_by_number): Fixed for new summary interface. Added a warning for using this broken api. (_get_message_by_uid): Fixed for message new with session vanishing. svn path=/trunk/; revision=2531 --- camel/camel-mime-utils.c | 1870 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1870 insertions(+) create mode 100644 camel/camel-mime-utils.c (limited to 'camel/camel-mime-utils.c') diff --git a/camel/camel-mime-utils.c b/camel/camel-mime-utils.c new file mode 100644 index 0000000000..d3e2406f1a --- /dev/null +++ b/camel/camel-mime-utils.c @@ -0,0 +1,1870 @@ +/* + * Copyright (C) 2000 Helix Code Inc. + * + * Authors: Michael Zucchi + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public License + * as published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#include + +#include +#include +#include +#include +#include + +#include + +#include +#include + +#include + +#include "camel-mime-utils.h" + +#define d(x) +#define d2(x) + +static char *base64_alphabet = +"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + +static unsigned char tohex[16] = { + '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' +}; + +static unsigned char camel_mime_special_table[256] = { + 5, 5, 5, 5, 5, 5, 5, 5, 5,167, 7, 5, 5, 39, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 178,128,140,128,128,128,128,128,140,140,128,128,140,128,136,132, + 128,128,128,128,128,128,128,128,128,128,204,140,140, 4,140,132, + 140,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, + 128,128,128,128,128,128,128,128,128,128,128,172,172,172,128,128, + 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, + 128,128,128,128,128,128,128,128,128,128,128,128,128,128,128, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +}; + +static unsigned char camel_mime_base64_rank[256] = { + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255, 62,255,255,255, 63, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,255,255,255, 0,255,255, + 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,255,255,255,255,255, + 255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, + 255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255, +}; + +/* + if any of these change, then the tables above should be regenerated + by compiling this with -DBUILD_TABLE, and running. + + gcc -o buildtable `glib-config --cflags --libs` -DBUILD_TABLE camel-mime-utils.c + ./buildtable + +*/ +enum { + IS_CTRL = 1<<0, + IS_LWSP = 1<<1, + IS_TSPECIAL = 1<<2, + IS_SPECIAL = 1<<3, + IS_SPACE = 1<<4, + IS_DSPECIAL = 1<<5, + IS_COLON = 1<<6, /* rather wasteful of space ... */ + IS_QPSAFE = 1<<7 +}; + +#define is_ctrl(x) ((camel_mime_special_table[(unsigned char)(x)] & IS_CTRL) != 0) +#define is_lwsp(x) ((camel_mime_special_table[(unsigned char)(x)] & IS_LWSP) != 0) +#define is_tspecial(x) ((camel_mime_special_table[(unsigned char)(x)] & IS_TSPECIAL) != 0) +#define is_type(x, t) ((camel_mime_special_table[(unsigned char)(x)] & (t)) != 0) +#define is_ttoken(x) ((camel_mime_special_table[(unsigned char)(x)] & (IS_TSPECIAL|IS_LWSP|IS_CTRL)) == 0) +#define is_atom(x) ((camel_mime_special_table[(unsigned char)(x)] & (IS_SPECIAL|IS_SPACE|IS_CTRL)) == 0) +#define is_dtext(x) ((camel_mime_special_table[(unsigned char)(x)] & IS_DSPECIAL) == 0) +#define is_fieldname(x) ((camel_mime_special_table[(unsigned char)(x)] & (IS_CTRL|IS_SPACE|IS_COLON)) == 0) +#define is_qpsafe(x) ((camel_mime_special_table[(unsigned char)(x)] & IS_QPSAFE) != 0) + +/* only needs to be run to rebuild the tables above */ +#ifdef BUILD_TABLE + +#define CHARS_LWSP " \t\n\r" +#define CHARS_TSPECIAL "()<>@,;:\\\"/[]?=" +#define CHARS_SPECIAL "()<>@,;:\\\".[]" +#define CHARS_CSPECIAL "()\\\r" /* not in comments */ +#define CHARS_DSPECIAL "[]\\\r \t" /* not in domains */ + +static void +header_init_bits(unsigned char bit, unsigned char bitcopy, int remove, unsigned char *vals, int len) +{ + int i; + + if (!remove) { + for (i=0;i=33 && i<=60) || (i>=62 && i<=126) || i==32 || i==9) camel_mime_special_table[i] |= IS_QPSAFE; +} + +void +base64_init(void) +{ + int i; + + memset(camel_mime_base64_rank, 0xff, sizeof(camel_mime_base64_rank)); + for (i=0;i<64;i++) { + camel_mime_base64_rank[(unsigned int)base64_alphabet[i]] = i; + } + camel_mime_base64_rank['='] = 0; +} + +int main(int argc, char **argv) +{ + int i; + void run_test(void); + + header_decode_init(); + base64_init(); + + printf("static unsigned char camel_mime_special_table[256] = {\n\t"); + for (i=0;i<256;i++) { + printf("%3d,", camel_mime_special_table[i]); + if ((i&15) == 15) { + printf("\n"); + if (i!=255) { + printf("\t"); + } + } + } + printf("};\n"); + + printf("static unsigned char camel_mime_base64_rank[256] = {\n\t"); + for (i=0;i<256;i++) { + printf("%3d,", camel_mime_base64_rank[i]); + if ((i&15) == 15) { + printf("\n"); + if (i!=255) { + printf("\t"); + } + } + } + printf("};\n"); + + run_test(); + + return 0; +} + +#endif + + +/* call this when finished encoding everything, to + flush off the last little bit */ +int +base64_encode_close(unsigned char *in, int inlen, unsigned char *out, int *state, int *save) +{ + int c1, c2; + unsigned char *outptr = out; + + if (inlen>0) + outptr += base64_encode_step(in, inlen, outptr, state, save); + + c1 = ((char *)save)[1]; + c2 = ((char *)save)[2]; + + switch (((char *)save)[0]) { + case 2: + outptr[2] = base64_alphabet [ ( (c2 &0x0f) << 2 ) ]; + goto skip; + case 1: + outptr[2] = '='; + skip: + outptr[0] = base64_alphabet [ c1 >> 2 ]; + outptr[1] = base64_alphabet [ c2 >> 4 | ( (c1&0x3) << 4 )]; + outptr[3] = '='; + outptr += 4; + break; + } + *outptr++ = '\n'; + + *save = 0; + *state = 0; + + return outptr-out; +} + +/* + performs an 'encode step', only encodes blocks of 3 characters to the + output at a time, saves left-over state in state and save (initialise to + 0 on first invocation). +*/ +int +base64_encode_step(unsigned char *in, int len, unsigned char *out, int *state, int *save) +{ + register unsigned char *inptr, *outptr; + + if (len<=0) + return 0; + + inptr = in; + outptr = out; + + d(printf("we have %d chars, and %d saved chars\n", len, ((char *)save)[0])); + + if (len + ((char *)save)[0] > 2) { + unsigned char *inend = in+len-2; + register int c1, c2, c3; + register int already; + + already = *state; + + switch (((char *)save)[0]) { + case 1: c1 = ((char *)save)[1]; goto skip1; + case 2: c1 = ((char *)save)[1]; + c2 = ((char *)save)[2]; goto skip2; + } + + /* yes, we jump into the loop, no i'm not going to change it, its beautiful! */ + while (inptr < inend) { + c1 = *inptr++; + skip1: + c2 = *inptr++; + skip2: + c3 = *inptr++; + *outptr++ = base64_alphabet [ c1 >> 2 ]; + *outptr++ = base64_alphabet [ c2 >> 4 | ( (c1&0x3) << 4 ) ]; + *outptr++ = base64_alphabet [ ( (c2 &0x0f) << 2 ) | (c3 >> 6) ]; + *outptr++ = base64_alphabet [ c3 & 0x3f ]; + /* this is a bit ugly ... */ + if ((++already)>=19) { + *outptr++='\n'; + already = 0; + } + } + + ((char *)save)[0] = 0; + len = 2-(inptr-inend); + *state = already; + } + + d(printf("state = %d, len = %d\n", + (int)((char *)save)[0], + len)); + + if (len>0) { + register char *saveout; + + /* points to the slot for the next char to save */ + saveout = & (((char *)save)[1]) + ((char *)save)[0]; + + /* len can only be 0 1 or 2 */ + switch(len) { + case 2: *saveout++ = *inptr++; + case 1: *saveout++ = *inptr++; + } + ((char *)save)[0]+=len; + } + + d(printf("mode = %d\nc1 = %c\nc2 = %c\n", + (int)((char *)save)[0], + (int)((char *)save)[1], + (int)((char *)save)[2])); + + return outptr-out; +} + +int +base64_decode_step(unsigned char *in, int len, unsigned char *out, int *state, unsigned int *save) +{ + register unsigned char *inptr, *outptr; + unsigned char *inend, c; + register unsigned int v; + int i; + + inend = in+len; + outptr = out; + + /* convert 4 base64 bytes to 3 normal bytes */ + v=*save; + i=*state; + inptr = in; + while (inptr>16; + *outptr++ = v>>8; + *outptr++ = v; + i=0; + } + } + } + + *save = v; + *state = i; + + /* quick scan back for '=' on the end somewhere */ + /* fortunately we can drop 1 output char for each trailing = (upto 2) */ + i=2; + while (inptr>in && i) { + inptr--; + if (camel_mime_base64_rank[*inptr] != 0xff) { + if (*inptr == '=') + outptr--; + i--; + } + } + + /* if i!= 0 then there is a truncation error! */ + return outptr-out; +} + +int +quoted_encode_close(unsigned char *in, int len, unsigned char *out, int *state, int *save) +{ + register unsigned char *outptr = out; + + if (len>0) + outptr += quoted_encode_step(in, len, outptr, state, save); + + /* hmm, not sure if this should really be added here, we dont want + to add it to the content, afterall ...? */ + *outptr++ = '\n'; + + *save = 0; + *state = 0; + + return outptr-out; +} + +/* + FIXME: does not handle trailing spaces/tabs before end of line +*/ +int +quoted_encode_step(unsigned char *in, int len, unsigned char *out, int *state, int *save) +{ + register unsigned char *inptr, *outptr, *inend; + unsigned char c; + register int sofar = *state; + + inptr = in; + inend = in+len; + outptr = out; + while (inptr74) { + *outptr++='='; + *outptr++='\n'; + sofar = 1; + } + *outptr++=c; + } else { + if ((++sofar)>72) { + *outptr++='='; + *outptr++='\n'; + sofar = 3; + } + *outptr++ = '='; + *outptr++ = tohex[(c>>4) & 0xf]; + *outptr++ = tohex[c & 0xf]; + } + } + *state = sofar; + return outptr-out; +} + +/* + FIXME: this does not strip trailing spaces from lines (as it should, rfc 2045, section 6.7) + Should it also canonicalise the end of line to CR LF?? + + Note: Trailing rubbish (at the end of input), like = or =x or =\r will be lost. +*/ + +int +quoted_decode_step(unsigned char *in, int len, unsigned char *out, int *savestate, int *saveme) +{ + register unsigned char *inptr, *outptr; + unsigned char *inend, c; + int state, save; + + inend = in+len; + outptr = out; + + d(printf("quoted-printable, decoding text '%.*s'\n", len, in)); + + state = *savestate; + save = *saveme; + inptr = in; + while (inptr='A'?save-'A'+10:save-'0')&0x0f) << 4) + | ((c>='A'?c-'A'+10:c-'0')&0x0f); + } else if (c=='\n' && save == '\r') { + /* soft break ... canonical end of line */ + } else { + /* just output the data */ + *outptr++ = '='; + *outptr++ = save; + *outptr++ = c; + } + state = 0; + break; +#ifdef CANONICALISE_EOL + case 3: + /* convert \r -> to \r\n, leaves \r\n alone */ + c = *inptr++; + if (c=='\n') { + *outptr++ = '\r'; + *outptr++ = c; + } else { + *outptr++ = '\r'; + *outptr++ = '\n'; + *outptr++ = c; + } + state = 0; + break; +#endif + } + } + + *savestate = state; + *saveme = save; + + return outptr-out; +} + +/* + this is for the "Q" encoding of international words, + which is slightly different than plain quoted-printable +*/ +int +quoted_decode(unsigned char *in, int len, unsigned char *out) +{ + register unsigned char *inptr, *outptr; + unsigned char *inend, c, c1; + int ret = 0; + + inend = in+len; + outptr = out; + + d(printf("decoding text '%.*s'\n", len, in)); + + inptr = in; + while (inptr=2) { + c = toupper(*inptr++); + c1 = toupper(*inptr++); + *outptr++ = (((c>='A'?c-'A'+10:c-'0')&0x0f) << 4) + | ((c1>='A'?c1-'A'+10:c1-'0')&0x0f); + } else { + ret = -1; + break; + } + } else if (c=='_') { + *outptr++ = 0x20; + } else if (c==' ' || c==0x09) { + /* FIXME: this is an error! ignore for now ... */ + ret = -1; + break; + } else { + *outptr++ = c; + } + } + if (ret==0) { + return outptr-out; + } + return -1; +} + + +static void +header_decode_lwsp(const char **in) +{ + const char *inptr = *in; + char c; + + d2(printf("is ws: '%s'\n", *in)); + + while (is_lwsp(*inptr) || *inptr =='(') { + while (is_lwsp(*inptr)) { + d2(printf("(%c)", *inptr)); + inptr++; + } + d2(printf("\n")); + + /* check for comments */ + if (*inptr == '(') { + int depth = 1; + inptr++; + while (depth && (c=*inptr)) { + if (c=='\\' && inptr[1]) { + inptr++; + } else if (c=='(') { + depth++; + } else if (c==')') { + depth--; + } + inptr++; + } + } + } + *in = inptr; +} + +char * +g_strdup_len(const char *start, int len) +{ + char *d = g_malloc(len+1); + memcpy(d, start, len); + d[len] = 0; + return d; +} + + +/* decode rfc 2047 encoded string segment */ +char * +rfc2047_decode_word(char *in, int len) +{ + char *inptr = in+2; + char *inend = in+len-2; + char *encname; + int tmplen; + int ret; + char *decword = NULL; + char *decoded = NULL; + char *outbase = NULL; + char *inbuf, *outbuf; + int inlen, outlen; + iconv_t ic; + + d(printf("decoding '%.*s'\n", len, in)); + + /* just make sure we're not passed shit */ + if (len<7 + || !(in[0]=='=' && in[1]=='?' && in[len-1]=='=' && in[len-2]=='?')) { + d(printf("invalid\n")); + return NULL; + } + + inptr = memchr(inptr, '?', inend-inptr); + if (inptr!=NULL + && inptr0) { + /* yuck, all this snot is to setup iconv! */ + tmplen = inptr-in-3; + encname = alloca(tmplen+1); + encname[tmplen]=0; + memcpy(encname, in+2, tmplen); + + inbuf = decword; + + outlen = inlen*6; + outbase = g_malloc(outlen); + outbuf = outbase; + + ic = iconv_open("utf-8", encname); + ret = iconv(ic, (const char **)&inbuf, &inlen, &outbuf, &outlen); + iconv_close(ic); + if (ret>=0) { + *outbuf = 0; + decoded = outbase; + outbase = NULL; + } + } + } + free(outbase); + free(decword); + + d(printf("decoded '%s'\n", decoded)); + + return decoded; +} + +char * +decode_coded_string(char *in) +{ + return rfc2047_decode_word(in, strlen(in)); +} + +/* grrr, glib should have this ! */ +GString * +g_string_append_len(GString *st, char *s, int l) +{ + char *tmp; + + tmp = alloca(l+1); + tmp[l]=0; + memcpy(tmp, s, l); + return g_string_append(st, tmp); +} + +/* decodes a simple text, rfc822 */ +char * +header_decode_text(char *in, int inlen) +{ + GString *out; + char *inptr = in; + char *inend = in+inlen; + char *encstart, *encend; + char *decword; + + out = g_string_new(""); + while ( (encstart = strstr(inptr, "=?")) + && (encend = strstr(encstart+2, "?=")) ) { + + decword = rfc2047_decode_word(encstart, encend-encstart+2); + if (decword) { + g_string_append_len(out, inptr, encstart-inptr); + g_string_append_len(out, decword, strlen(decword)); + free(decword); + } else { + g_string_append_len(out, inptr, encend-inptr+2); + } + inptr = encend+2; + } + g_string_append_len(out, inptr, inend-inptr); + + inptr = out->str; + g_string_free(out, FALSE); + return inptr; +} + +char * +header_decode_string(const char *in) +{ + if (in == NULL) + return NULL; + return header_decode_text(in, strlen(in)); +} + + +/* these are all internal parser functions */ + +char * +header_decode_token(const char **in) +{ + const char *inptr = *in; + const char *start; + + header_decode_lwsp(&inptr); + start = inptr; + while (is_ttoken(*inptr)) + inptr++; + if (inptr>start) { + *in = inptr; + return g_strdup_len(start, inptr-start); + } else { + return NULL; + } +} + +/* + <"> * ( \, cr / \ ) <"> +*/ +static char * +header_decode_quoted_string(const char **in) +{ + const char *inptr = *in; + char *out = NULL, *outptr; + int outlen; + int c; + + header_decode_lwsp(&inptr); + if (*inptr == '"') { + const char *intmp; + int skip = 0; + + /* first, calc length */ + inptr++; + intmp = inptr; + while ( (c = *intmp++) && c!= '"' ) { + if (c=='\\' && *intmp) { + intmp++; + skip++; + } + } + outlen = intmp-inptr-skip; + out = outptr = g_malloc(outlen+1); + while ( (c = *inptr++) && c!= '"' ) { + if (c=='\\' && *inptr) { + c = *inptr++; + } + *outptr++ = c; + } + *outptr = 0; + } + *in = inptr; + return out; +} + +static char * +header_decode_atom(const char **in) +{ + const char *inptr = *in, *start; + + header_decode_lwsp(&inptr); + start = inptr; + while (is_atom(*inptr)) + inptr++; + *in = inptr; + if (inptr > start) + return g_strdup_len(start, inptr-start); + else + return NULL; +} + +static char * +header_decode_word(const char **in) +{ + const char *inptr = *in; + + header_decode_lwsp(&inptr); + if (*inptr == '"') { + *in = inptr; + return header_decode_quoted_string(in); + } else { + *in = inptr; + return header_decode_atom(in); + } +} + +static char * +header_decode_value(const char **in) +{ + const char *inptr = *in; + + header_decode_lwsp(&inptr); + if (*inptr == '"') { + d(printf("decoding quoted string\n")); + return header_decode_quoted_string(in); + } else if (is_ttoken(*inptr)) { + d(printf("decoding token\n")); + /* this may not have the right specials for all params? */ + return header_decode_token(in); + } + return NULL; +} + +/* shoudl this return -1 for no int? */ +static int +header_decode_int(const char **in) +{ + const char *inptr = *in; + int c, v=0; + + header_decode_lwsp(&inptr); + while ( (c=*inptr++ & 0xff) + && isdigit(c) ) { + v = v*10+(c-'0'); + } + *in = inptr-1; + return v; +} + +static int +header_decode_param(const char **in, char **paramp, char **valuep) +{ + const char *inptr = *in; + char *param, *value=NULL; + + param = header_decode_token(&inptr); + header_decode_lwsp(&inptr); + if (*inptr == '=') { + inptr++; + value = header_decode_value(&inptr); + } + + if (param && value) { + *paramp = param; + *valuep = value; + *in = inptr; + return 0; + } else { + g_free(param); + g_free(value); + return 1; + } +} + +char * +header_param(struct _header_param *p, char *name) +{ + while (p && strcasecmp(p->name, name) != 0) + p = p->next; + if (p) + return p->value; + return NULL; +} + +struct _header_param * +header_set_param(struct _header_param **l, const char *name, const char *value) +{ + struct _header_param *p = (struct _header_param *)l, *pn; + + while (p->next) { + pn = p->next; + if (!strcasecmp(pn->name, name)) { + g_free(pn->value); + pn->value = g_strdup(value); + return pn; + } + p = pn; + } + + pn = g_malloc(sizeof(*pn)); + pn->next = 0; + pn->name = g_strdup(name); + pn->value = g_strdup(value); + p->next = pn; + + return pn; +} + +const char * +header_content_type_param(struct _header_content_type *t, const char *name) +{ + if (t==NULL) + return NULL; + return header_param(t->params, name); +} + +void header_content_type_set_param(struct _header_content_type *t, const char *name, const char *value) +{ + header_set_param(&t->params, name, value); +} + +/** + * header_content_type_is: + * @ct: A content type specifier, or #NULL. + * @type: A type to check against. + * @subtype: A subtype to check against, or "*" to match any subtype. + * + * Returns #TRUE if the content type @ct is of type @type/@subtype. + * The subtype of "*" will match any subtype. If @ct is #NULL, then + * it will match the type "text/plain". + * + * Return value: #TRUE or #FALSE depending on the matching of the type. + **/ +int +header_content_type_is(struct _header_content_type *ct, const char *type, const char *subtype) +{ + /* no type == text/plain or text/"*" */ + if (ct==NULL) { + return (!strcasecmp(type, "text") + && (!strcasecmp(subtype, "plain") + || !strcasecmp(subtype, "*"))); + } + + return ((!strcasecmp(ct->type, type) + && (!strcasecmp(ct->subtype, subtype) + || !strcasecmp("*", subtype)))); +} + +void +header_param_list_free(struct _header_param *p) +{ + struct _header_param *n; + + while (p) { + n = p->next; + g_free(p->name); + g_free(p->value); + g_free(p); + p = n; + } +} + +struct _header_content_type * +header_content_type_new(const char *type, const char *subtype) +{ + struct _header_content_type *t = g_malloc(sizeof(*t)); + + t->type = type; + t->subtype = subtype; + t->params = NULL; + t->refcount = 1; + return t; +} + +void +header_content_type_ref(struct _header_content_type *ct) +{ + if (ct) + ct->refcount++; +} + + +void +header_content_type_unref(struct _header_content_type *ct) +{ + if (ct) { + if (ct->refcount <= 1) { + header_param_list_free(ct->params); + g_free(ct->type); + g_free(ct->subtype); + g_free(ct); + } else { + ct->refcount--; + } + } +} + +/* for decoding email addresses, canonically */ +static char * +header_decode_domain(const char **in) +{ + const char *inptr = *in, *start; + int go = TRUE; + GString *domain = g_string_new(""); + + /* domain ref | domain literal */ + header_decode_lwsp(&inptr); + while (go) { + if (*inptr == '[') { /* domain literal */ + g_string_append(domain, "[ "); + inptr++; + header_decode_lwsp(&inptr); + start = inptr; + while (is_dtext(*inptr)) { + g_string_append_c(domain, *inptr); + inptr++; + } + if (*inptr == ']') { + g_string_append(domain, " ]"); + inptr++; + } else { + g_warning("closing ']' not found in domain: %s", *in); + } + } else { + char *a = header_decode_atom(&inptr); + if (a) { + g_string_append(domain, a); + } else { + g_warning("missing atom from domain-ref"); + break; + } + } + header_decode_lwsp(&inptr); + if (*inptr == '.') { /* next sub-domain? */ + g_string_append(domain, " . "); + inptr++; + header_decode_lwsp(&inptr); + } else + go = FALSE; + } + + *in = inptr; + + /* FIXME:L free string header */ + return domain->str; +} + +static char * +header_decode_addrspec(const char **in) +{ + const char *inptr = *in; + char *word; + GString *addr = g_string_new(""); + + header_decode_lwsp(&inptr); + + /* addr-spec */ + word = header_decode_word(&inptr); + if (word) { + g_string_append(addr, word); + header_decode_lwsp(&inptr); + while (*inptr == '.' && word) { + inptr++; + g_string_append_c(addr, '.'); + word = header_decode_word(&inptr); + if (word) { + g_string_append(addr, word); + header_decode_lwsp(&inptr); + } else { + g_warning("Invalid address spec: %s", *in); + } + } + if (*inptr == '@') { + inptr++; + g_string_append_c(addr, '@'); + word = header_decode_domain(&inptr); + if (word) { + g_string_append(addr, word); + } else { + g_warning("Invalid address, missing domain: %s", *in); + } + } else { + g_warning("Invalid addr-spec, missing @: %s", *in); + } + } else { + g_warning("invalid addr-spec, no local part"); + } + + /* FIXME: return null on error? */ + + *in = inptr; + word = addr->str; + g_string_free(addr, FALSE); + return word; +} + +/* + address: + word *('.' word) @ domain | + *(word) '<' [ *('@' domain ) ':' ] word *( '.' word) @ domain | + + 1*word ':' [ word ... etc (mailbox, as above) ] ';' + */ + +/* mailbox: + word *( '.' word ) '@' domain + *(word) '<' [ *('@' domain ) ':' ] word *( '.' word) @ domain + */ + +/* FIXME: what does this return? */ + +static void +header_decode_mailbox(const char **in) +{ + const char *inptr = *in; + char *pre; + int closeme = FALSE; + GString *addr; + + addr = g_string_new(""); + + /* for each address */ + pre = header_decode_word(&inptr); + header_decode_lwsp(&inptr); + if (!(*inptr == '.' || *inptr == '@' || *inptr==',' || *inptr=='\0')) { /* ',' and '\0' required incase it is a simple address, no @ domain part (buggy writer) */ + /* FIXME: rfc 2047 decode each word */ + while (pre) { + /* rfc_decode(pre) */ + pre = header_decode_word(&inptr); + } + header_decode_lwsp(&inptr); + if (*inptr == '<') { + closeme = TRUE; + inptr++; + header_decode_lwsp(&inptr); + if (*inptr == '@') { + while (*inptr == '@') { + inptr++; + header_decode_domain(&inptr); + header_decode_lwsp(&inptr); + if (*inptr == ',') { + inptr++; + header_decode_lwsp(&inptr); + } + } + if (*inptr == ':') { + inptr++; + } else { + g_warning("broken route-address, missing ':': %s", *in); + } + } + pre = header_decode_word(&inptr); + header_decode_lwsp(&inptr); + } else { + g_warning("broken address? %s", *in); + } + } + + if (pre) { + g_string_append(addr, pre); + } else { + g_warning("No local-part for email address: %s", *in); + } + + /* should be at word '.' localpart */ + while (*inptr == '.' && pre) { + inptr++; + pre = header_decode_word(&inptr); + g_string_append_c(addr, '.'); + g_string_append(addr, pre); + header_decode_lwsp(&inptr); + } + + /* now at '@' domain part */ + if (*inptr == '@') { + char *dom; + + inptr++; + g_string_append_c(addr, '@'); + dom = header_decode_domain(&inptr); + g_string_append(addr, dom); + } else { + g_warning("invalid address, no '@' domain part at %c: %s", *inptr, *in); + } + + if (closeme) { + header_decode_lwsp(&inptr); + if (*inptr == '>') { + inptr++; + } else { + g_warning("invalid route address, no closing '>': %s", *in); + } + } + + *in = inptr; + + d(printf("got mailbox: %s\n", addr->str)); +} + +/* FIXME: what does this return? */ +static void +header_decode_address(const char **in) +{ + const char *inptr = *in; + char *pre; + GString *group = g_string_new(""); + + /* pre-scan, trying to work out format, discard results */ + header_decode_lwsp(&inptr); + while ( (pre = header_decode_word(&inptr)) ) { + g_string_append(group, pre); + g_string_append(group, " "); + g_free(pre); + } + header_decode_lwsp(&inptr); + if (*inptr == ':') { + d(printf("group detected: %s\n", group->str)); + /* that was a group spec, scan mailbox's */ + inptr++; + /* FIXME: check rfc 2047 encodings of words, here or above in the loop */ + header_decode_lwsp(&inptr); + if (*inptr != ';') { + int go = TRUE; + do { + header_decode_mailbox(&inptr); + header_decode_lwsp(&inptr); + if (*inptr == ',') + inptr++; + else + go = FALSE; + } while (go); + if (*inptr == ';') { + inptr++; + } else { + g_warning("Invalid group spec, missing closing ';': %s", *in); + } + } else { + inptr++; + } + *in = inptr; +/* } else if (*inptr == '.' || *inptr == '<' || *inptr == '@') {*/ + } else { + /* back-track, and rescan. not worth the code duplication to do this faster */ + /* this will detect invalid input */ + header_decode_mailbox(in); + }/* else { + g_warning("Cannot scan address at '%c': %s", *inptr, *in); + }*/ + + /* FIXME: store gropu somewhere */ + g_string_free(group, TRUE); +} + +char * +header_msgid_decode(const char *in) +{ + const char *inptr = in; + char *msgid = NULL; + + d(printf("decoding Message-ID: '%s'\n", in)); + + if (in == NULL) + return NULL; + + header_decode_lwsp(&inptr); + if (*inptr == '<') { + inptr++; + header_decode_lwsp(&inptr); + msgid = header_decode_addrspec(&inptr); + if (msgid) { + header_decode_lwsp(&inptr); + if (*inptr == '>') { + inptr++; + } else { + g_warning("Missing closing '>' on message id: %s", in); + } + } else { + g_warning("Cannot find message id in: %s", in); + } + } else { + g_warning("missing opening '<' on message id: %s", in); + } + + if (msgid) { + d(printf("Got message id: %s\n", msgid)); + } + return msgid; +} + +void +header_to_decode(const char *in) +{ + const char *inptr = in, *last; + + d(printf("decoding To: '%s'\n", in)); + + if (in == NULL) + return NULL; + + do { + last = inptr; + header_decode_address(&inptr); + header_decode_lwsp(&inptr); + if (*inptr == ',') + inptr++; + else + break; + } while (inptr != last); + + if (*inptr) { + g_warning("Invalid input detected at %c (%d): %s\n or at: %s", *inptr, inptr-in, in, inptr); + } + + if (inptr == last) { + g_warning("detected invalid input loop at : %s", last); + } +} + +void +header_mime_decode(const char *in) +{ + const char *inptr = in; + int major=-1, minor=-1; + + d(printf("decoding MIME-Version: '%s'\n", in)); + + if (in == NULL) + return NULL; + + header_decode_lwsp(&inptr); + if (isdigit(*inptr)) { + major = header_decode_int(&inptr); + header_decode_lwsp(&inptr); + if (*inptr == '.') { + inptr++; + header_decode_lwsp(&inptr); + if (isdigit(*inptr)) + minor = header_decode_int(&inptr); + } + } + + d(printf("major = %d, minor = %d\n", major, minor)); +} + +struct _header_param * +header_param_list_decode(const char **in) +{ + const char *inptr = *in; + struct _header_param *head = NULL, *tail = NULL; + + header_decode_lwsp(&inptr); + while (*inptr == ';') { + char *param, *value; + struct _header_param *p; + + inptr++; + /* invalid format? */ + if (header_decode_param(&inptr, ¶m, &value) != 0) + break; + + p = g_malloc(sizeof(*p)); + p->name = param; + p->value = value; + p->next = NULL; + if (head == NULL) + head = p; + if (tail) + tail->next = p; + tail = p; + header_decode_lwsp(&inptr); + } + *in = inptr; + return head; +} + +struct _header_content_type * +header_content_type_decode(const char *in) +{ + const char *inptr = in; + char *type, *subtype = NULL; + struct _header_content_type *t = NULL; + + if (in==NULL) + return NULL; + + type = header_decode_token(&inptr); + header_decode_lwsp(&inptr); + if (type) { + if (*inptr == '/') { + inptr++; + subtype = header_decode_token(&inptr); + } + if (subtype == NULL && (!strcasecmp(type, "text"))) { + g_warning("text type with no subtype, resorting to text/plain: %s", in); + subtype = g_strdup("plain"); + } + if (subtype == NULL) { + g_warning("MIME type with no subtype: %s", in); + } + + t = header_content_type_new(type, subtype); + t->params = header_param_list_decode(&inptr); + } else { + g_free(type); + d(printf("cannot find MIME type in header (2) '%s'", in)); + } + return t; +} + +void +header_content_type_dump(struct _header_content_type *ct) +{ + struct _header_param *p; + + printf("Content-Type: "); + if (ct==NULL) { + printf("\n"); + return; + } + printf("%s / %s", ct->type, ct->subtype); + p = ct->params; + if (p) { + while (p) { + printf(";\n\t%s=\"%s\"", p->name, p->value); + p = p->next; + } + } + printf("\n"); +} + +char * +header_content_encoding_decode(const char *in) +{ + if (in) + return header_decode_token(&in); + return NULL; +} + +CamelMimeDisposition *header_disposition_decode(const char *in) +{ + CamelMimeDisposition *d = NULL; + const char *inptr = in; + + if (in == NULL) + return NULL; + + d = g_malloc(sizeof(*d)); + d->refcount = 1; + d->disposition = header_decode_token(&inptr); + if (d->disposition == NULL) + g_warning("Empty disposition type"); + d->params = header_param_list_decode(&inptr); + return d; +} + +void header_disposition_ref(CamelMimeDisposition *d) +{ + if (d) + d->refcount++; +} +void header_disposition_unref(CamelMimeDisposition *d) +{ + if (d) { + if (d->refcount<=1) { + header_param_list_free(d->params); + g_free(d->disposition); + g_free(d); + } else { + d->refcount--; + } + } +} + +/* hrm, is there a library for this shit? */ +static struct { + char *name; + int offset; +} tz_offsets [] = { + { "UT", 0 }, + { "GMT", 0 }, + { "EST", -500 }, /* these are all US timezones. bloody yanks */ + { "EDT", -400 }, + { "CST", -600 }, + { "CDT", -500 }, + { "MST", -700 }, + { "MDT", -600 }, + { "PST", -800 }, + { "PDT", -700 }, + { "Z", 0 }, + { "A", -100 }, + { "M", -1200 }, + { "N", 100 }, + { "Y", 1200 }, +}; + +static char *tz_months [] = { + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nove", "Dec" +}; + +char * +header_format_date(time_t time, int offset) +{ + struct tm tm; + + d(printf("offset = %d\n", offset)); + + d(printf("converting date %s", ctime(&time))); + + time += ((offset / 100) * (60*60)) + (offset % 100)*60; + + d(printf("converting date %s", ctime(&time))); + + memcpy(&tm, gmtime(&time), sizeof(tm)); + + return g_strdup_printf("%02d %s %04d %02d:%02d:%02d %c%04d", + tm.tm_mday, tz_months[tm.tm_mon], + tm.tm_year + 1900, + tm.tm_hour, tm.tm_min, tm.tm_sec, + offset>=0?'+':'-', + offset); +} + +/* convert a date to time_t representation */ +/* this is an awful mess oh well */ +time_t +header_decode_date(const char *in, int *saveoffset) +{ + const char *inptr = in; + char *monthname; + int year, offset = 0; + struct tm tm; + int i; + time_t t; + + if (in == NULL) { + if (*saveoffset) + *saveoffset = 0; + return 0; + } + + d(printf("\ndecoding date '%s'\n", inptr)); + + memset(&tm, 0, sizeof(tm)); + + header_decode_lwsp(&inptr); + if (!isdigit(*inptr)) { + char *day = header_decode_token(&inptr); + /* we dont really care about the day, its only for display */ + if (day) { + d(printf("got day: %s\n", day)); + g_free(day); + header_decode_lwsp(&inptr); + if (*inptr == ',') + inptr++; + else + g_warning("day not followed by ','"); + } + } + tm.tm_mday = header_decode_int(&inptr); + monthname = header_decode_token(&inptr); + if (monthname) { + for (i=0;ivalue; + while (*p) { + if (!isascii(*p)) { + g_warning("Appending header violates rfc: %s: %s", h->name, h->value); + return; + } + p++; + } +} +#endif + +void +header_raw_append_parse(struct _header_raw **list, const char *header, int offset) +{ + register const char *in; + int fieldlen; + char *name; + + in = header; + while (is_fieldname(*in)) + in++; + fieldlen = in-header; + while (is_lwsp(*in)) + in++; + if (fieldlen == 0 || *in != ':') { + printf("Invalid header line: '%s'\n", header); + return; + } + in++; + name = alloca(fieldlen+1); + memcpy(name, header, fieldlen); + name[fieldlen] = 0; + + header_raw_append(list, name, in, offset); +} + +void +header_raw_append(struct _header_raw **list, const char *name, const char *value, int offset) +{ + struct _header_raw *l, *n; + + d(printf("Header: %s: %s\n", name, value)); + + n = g_malloc(sizeof(*n)); + n->next = NULL; + n->name = g_strdup(name); + n->value = g_strdup(value); + n->offset = offset; +#ifdef CHECKS + check_header(n); +#endif + l = (struct _header_raw *)list; + while (l->next) { + l = l->next; + } + l->next = n; + + /* debug */ +#if 0 + if (!strcasecmp(name, "To")) { + printf("- Decoding To\n"); + header_to_decode(value); + } else if (!strcasecmp(name, "Content-type")) { + printf("- Decoding content-type\n"); + header_content_type_dump(header_content_type_decode(value)); + } else if (!strcasecmp(name, "MIME-Version")) { + printf("- Decoding mime version\n"); + header_mime_decode(value); + } +#endif +} + +static struct _header_raw * +header_raw_find_node(struct _header_raw **list, const char *name) +{ + struct _header_raw *l; + + l = *list; + while (l) { + if (!strcasecmp(l->name, name)) + break; + l = l->next; + } + return l; +} + +const char * +header_raw_find(struct _header_raw **list, const char *name, int *offset) +{ + struct _header_raw *l; + + l = header_raw_find_node(list, name); + if (l) { + if (offset) + *offset = l->offset; + return l->value; + } else + return NULL; +} + +static void +header_raw_free(struct _header_raw *l) +{ + g_free(l->name); + g_free(l->value); + g_free(l); +} + +void +header_raw_remove(struct _header_raw **list, const char *name) +{ + struct _header_raw *l, *p; + + /* the next pointer is at the head of the structure, so this is safe */ + p = (struct _header_raw *)list; + l = *list; + while (l) { + if (!strcasecmp(l->name, name)) { + p->next = l->next; + header_raw_free(l); + l = p->next; + } else { + p = l; + l = l->next; + } + } +} + +void +header_raw_replace(struct _header_raw **list, const char *name, const char *value, int offset) +{ + header_raw_remove(list, name); + header_raw_append(list, name, value, offset); +} + +void +header_raw_clear(struct _header_raw **list) +{ + struct _header_raw *l, *n; + l = *list; + while (l) { + n = l->next; + header_raw_free(l); + l = n; + } + *list = NULL; +} + + + +#ifdef BUILD_TABLE + +/* for debugging tests */ +/* should also have some regression tests somewhere */ + +void run_test(void) +{ + char *to = "gnome hacker dudes: license-discuss@opensource.org, + \"Richard M. Stallman\" , + Barry Chester , + Michael Zucchi , + Miguel de Icaza ;, + zucchi@zedzone.mmc.com.au, \"Foo bar\" , + "; + + header_to_decode(to); + + header_mime_decode("1.0"); + header_mime_decode("1.3 (produced by metasend V1.0)"); + header_mime_decode("(produced by metasend V1.0) 5.2"); + header_mime_decode("7(produced by metasend 1.0) . (produced by helix/send/1.0) 9 . 5"); + header_mime_decode("3."); + header_mime_decode("."); + header_mime_decode(".5"); + header_mime_decode("c.d"); + header_mime_decode(""); + + header_msgid_decode(" <\"L3x2i1.0.Nm5.Xd-Wu\"@lists.redhat.com>"); + header_msgid_decode("<200001180446.PAA02065@beaker.htb.com.au>"); + +} + +#endif /* BUILD_TABLE */ -- cgit v1.2.3