2005-03-18 [paul] 1.0.3cvs2.4
[claws.git] / src / unmime.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2005 Hiroyuki Yamamoto
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include "config.h"
22 #endif
23
24 #include <glib.h>
25 #include <string.h>
26 #include <ctype.h>
27
28 #include "codeconv.h"
29 #include "base64.h"
30 #include "quoted-printable.h"
31
32 #define ENCODED_WORD_BEGIN      "=?"
33 #define ENCODED_WORD_END        "?="
34
35 /* Decodes headers based on RFC2045 and RFC2047. */
36
37 gchar *unmime_header(const gchar *encoded_str)
38 {
39         const gchar *p = encoded_str;
40         const gchar *eword_begin_p, *encoding_begin_p, *text_begin_p,
41                     *eword_end_p;
42         gchar charset[32];
43         gchar encoding;
44         gchar *conv_str;
45         GString *outbuf;
46         gchar *out_str;
47         gsize out_len;
48
49         outbuf = g_string_sized_new(strlen(encoded_str) * 2);
50
51         while (*p != '\0') {
52                 gchar *decoded_text = NULL;
53                 gint len;
54
55                 eword_begin_p = strstr(p, ENCODED_WORD_BEGIN);
56                 if (!eword_begin_p) {
57                         g_string_append(outbuf, p);
58                         break;
59                 }
60                 encoding_begin_p = strchr(eword_begin_p + 2, '?');
61                 if (!encoding_begin_p) {
62                         g_string_append(outbuf, p);
63                         break;
64                 }
65                 text_begin_p = strchr(encoding_begin_p + 1, '?');
66                 if (!text_begin_p) {
67                         g_string_append(outbuf, p);
68                         break;
69                 }
70                 eword_end_p = strstr(text_begin_p + 1, ENCODED_WORD_END);
71                 if (!eword_end_p) {
72                         g_string_append(outbuf, p);
73                         break;
74                 }
75
76                 if (p == encoded_str) {
77                         g_string_append_len(outbuf, p, eword_begin_p - p);
78                         p = eword_begin_p;
79                 } else {
80                         /* ignore spaces between encoded words */
81                         const gchar *sp;
82
83                         for (sp = p; sp < eword_begin_p; sp++) {
84                                 if (!g_ascii_isspace(*sp)) {
85                                         g_string_append_len
86                                                 (outbuf, p, eword_begin_p - p);
87                                         p = eword_begin_p;
88                                         break;
89                                 }
90                         }
91                 }
92
93                 len = MIN(sizeof(charset) - 1,
94                           encoding_begin_p - (eword_begin_p + 2));
95                 memcpy(charset, eword_begin_p + 2, len);
96                 charset[len] = '\0';
97                 encoding = g_ascii_toupper(*(encoding_begin_p + 1));
98
99                 if (encoding == 'B') {
100                         decoded_text = g_malloc
101                                 (eword_end_p - (text_begin_p + 1) + 1);
102                         len = base64_decode(decoded_text, text_begin_p + 1,
103                                             eword_end_p - (text_begin_p + 1));
104                         decoded_text[len] = '\0';
105                 } else if (encoding == 'Q') {
106                         decoded_text = g_malloc
107                                 (eword_end_p - (text_begin_p + 1) + 1);
108                         len = qp_decode_q_encoding
109                                 (decoded_text, text_begin_p + 1,
110                                  eword_end_p - (text_begin_p + 1));
111                 } else {
112                         g_string_append_len(outbuf, p, eword_end_p + 2 - p);
113                         p = eword_end_p + 2;
114                         continue;
115                 }
116
117                 /* convert to UTF-8 */
118                 conv_str = conv_codeset_strdup(decoded_text, charset, NULL);
119                 if (!conv_str) {
120                         conv_str = g_malloc(len + 1);
121                         conv_utf8todisp(conv_str, len + 1, decoded_text);
122                 }
123                 g_string_append(outbuf, conv_str);
124                 g_free(conv_str);
125
126                 g_free(decoded_text);
127
128                 p = eword_end_p + 2;
129         }
130
131         out_str = outbuf->str;
132         out_len = outbuf->len;
133         g_string_free(outbuf, FALSE);
134
135         return g_realloc(out_str, out_len + 1);
136 }