Deal with $hostname and $shorthost
[apps/madmutt.git] / lib-mime / mime.cpkg
1 /*
2  *  This program is free software; you can redistribute it and/or modify
3  *  it under the terms of the GNU General Public License as published by
4  *  the Free Software Foundation; either version 2 of the License, or (at
5  *  your option) any later version.
6  *
7  *  This program is distributed in the hope that it will be useful, but
8  *  WITHOUT ANY WARRANTY; without even the implied warranty of
9  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
10  *  General Public License for more details.
11  *
12  *  You should have received a copy of the GNU General Public License
13  *  along with this program; if not, write to the Free Software
14  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
15  *  MA 02110-1301, USA.
16  *
17  *  Copyright © 2006 Pierre Habouzit
18  */
19 /*
20  * Copyright notice from original mutt:
21  * Copyright (C) 1996-2000 Michael R. Elkins <me@mutt.org>
22  * Copyright (C) 1999-2000 Thomas Roessler <roessler@does-not-exist.org>
23  */
24
25 #include <lib-lib/lib-lib.h>
26 #include <lib-lua/lib-lua.h>
27 #include "mime.h"
28 @import "../lib-lua/base.cpkg"
29
30 #define BOUNDARYLEN 16
31 const char MimeSpecials[] = "@.,;:<>[]\\\"()?/= \t";
32
33 const char *BodyTypes[] = {
34     "x-unknown",
35     "audio",
36     "application",
37     "image",
38     "message",
39     "model",
40     "multipart",
41     "text",
42     "video",
43 };
44
45 const char *BodyEncodings[] = {
46     "x-unknown",
47     "7bit",
48     "8bit",
49     "quoted-printable",
50     "base64",
51     "binary",
52     "x-uuencoded",
53 };
54
55 @package Mime {
56     /*
57      ** .pp
58      ** ``$spam_separator'' controls what happens when multiple spam headers
59      ** are matched: if \fIunset\fP, each successive header will overwrite any
60      ** previous matches value for the spam label. If \fIset\fP, each successive
61      ** match will append to the previous, using ``$spam_separator'' as a
62      ** separator.
63      */
64     string_t spam_separator = m_strdup(",");
65 };
66
67 /****************************************************************************/
68 /* rfc822 header parameters                                                 */
69 /****************************************************************************/
70
71 char *parameter_getval(parameter_t *parm, const char *s)
72 {
73     while (parm) {
74         if (!ascii_strcasecmp(parm->attribute, s))
75             return parm->value;
76         parm = parm->next;
77     }
78     return NULL;
79 }
80
81 void parameter_setval(parameter_t **p, const char *attribute, const char *value)
82 {
83     while (*p) {
84         if (!ascii_strcasecmp(attribute, (*p)->attribute)) {
85             if (value) {
86                 m_strreplace(&(*p)->value, value);
87             } else {
88                 parameter_t *q = parameter_list_pop(p);
89                 parameter_delete(&q);
90             }
91             return;
92         }
93         p = &(*p)->next;
94     }
95
96     if (value) {
97         (*p) = parameter_new();
98         (*p)->attribute = m_strdup(attribute);
99         (*p)->value = m_strdup(value);
100     }
101 }
102
103 void parameter_delval(parameter_t **p, const char *attribute)
104 {
105     while (*p) {
106         if (!ascii_strcasecmp(attribute, (*p)->attribute)) {
107             parameter_t *q = parameter_list_pop(p);
108             parameter_delete(&q);
109             return;
110         }
111
112         p = &(*p)->next;
113     }
114 }
115
116 int parameter_equal(const parameter_t *p1, const parameter_t *p2)
117 {
118     while (p1 && p2) {
119         if (m_strcmp(p1->attribute, p2->attribute)
120         ||  m_strcmp(p1->value, p2->value))
121             return 0;
122
123         p1 = p1->next;
124         p2 = p2->next;
125     }
126
127     if (p1 || p2)
128         return 0;
129
130     return 1;
131 }
132
133 void parameter_set_boundary(parameter_t **parm)
134 {
135     char rs[BOUNDARYLEN + 1];
136     int i;
137
138     for (i = 0; i < BOUNDARYLEN; i++) {
139         rs[i] = __m_b64chars[lrand48() % sizeof(__m_b64chars)];
140     }
141     rs[BOUNDARYLEN] = '\0';
142
143     parameter_setval(parm, "boundary", rs);
144 }
145
146
147 /****************************************************************************/
148 /* XXX                                                                      */
149 /****************************************************************************/
150
151 void envelope_wipe(ENVELOPE *p)
152 {
153     address_list_wipe(&p->return_path);
154     address_list_wipe(&p->from);
155     address_list_wipe(&p->to);
156     address_list_wipe(&p->cc);
157     address_list_wipe(&p->bcc);
158     address_list_wipe(&p->sender);
159     address_list_wipe(&p->reply_to);
160     address_list_wipe(&p->mail_followup_to);
161
162     p_delete(&p->list_post);
163     p_delete(&p->subject);
164     /* real_subj is just an offset to subject and shouldn't be freed */
165     p_delete(&p->message_id);
166     p_delete(&p->supersedes);
167     p_delete(&p->date);
168     p_delete(&p->x_label);
169     p_delete(&p->organization);
170 #ifdef USE_NNTP
171     p_delete(&p->newsgroups);
172     p_delete(&p->xref);
173     p_delete(&p->followup_to);
174     p_delete(&p->x_comment_to);
175 #endif
176
177     mutt_buffer_free (&p->spam);
178     string_list_wipe(&p->references);
179     string_list_wipe(&p->in_reply_to);
180     string_list_wipe(&p->userhdrs);
181 }
182
183 void body_wipe(BODY *b)
184 {
185     if (b->parameter)
186         parameter_list_wipe(&b->parameter);
187
188     if (b->unlink && b->filename) {
189         unlink (b->filename);
190     }
191
192     p_delete(&b->filename);
193     p_delete(&b->content);
194     p_delete(&b->xtype);
195     p_delete(&b->subtype);
196     p_delete(&b->description);
197     p_delete(&b->form_name);
198
199     if (b->hdr) {
200         /* Don't free twice (b->hdr->content = b->parts) */
201         b->hdr->content = NULL;
202         header_delete(&b->hdr);
203     }
204
205     if (b->parts)
206         body_list_wipe(&b->parts);
207 }
208
209 void header_wipe(HEADER *h)
210 {
211     envelope_delete(&h->env);
212     body_list_wipe(&h->content);
213     p_delete(&h->maildir_flags);
214     p_delete(&h->tree);
215     p_delete(&h->path);
216     string_list_wipe(&h->chain);
217     p_delete(&h->data);
218 }
219
220
221 /****************************************************************************/
222 /* misc functions                                                           */
223 /****************************************************************************/
224
225 int mutt_is_message_type(BODY *b)
226 {
227     int tok;
228
229     if (b->type != TYPEMESSAGE)
230         return 0;
231
232     tok = mime_which_token(b->subtype, -1);
233     return tok == MIME_RFC822 || tok == MIME_NEWS;
234 }
235
236 int mutt_is_text_part(BODY * b)
237 {
238     char *s = b->subtype;
239
240     if (mutt_is_application_pgp(b))
241         return 0;
242
243     switch (b->type) {
244       case TYPETEXT:
245         return 1;
246
247       case TYPEMESSAGE:
248         return mime_which_token(s, -1) == MIME_DELIVERY_STATUS;
249
250       case TYPEAPPLICATION:
251         return mime_which_token(s, -1) == MIME_PGP_KEYS;
252
253       default:
254         return 0;
255     }
256 }
257
258 /* vim:set ft=c: */