Merge branch 'release'
[notmuch] / lib / message-file.c
1 /* message.c - Utility functions for parsing an email message for notmuch.
2  *
3  * Copyright © 2009 Carl Worth
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 3 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, see http://www.gnu.org/licenses/ .
17  *
18  * Author: Carl Worth <cworth@cworth.org>
19  */
20
21 #include <stdarg.h>
22
23 #include "notmuch-private.h"
24
25 #include <gmime/gmime.h>
26
27 #include <glib.h> /* GHashTable */
28
29 typedef struct {
30     char *str;
31     size_t size;
32     size_t len;
33 } header_value_closure_t;
34
35 struct _notmuch_message_file {
36     /* File object */
37     FILE *file;
38
39     /* Header storage */
40     int restrict_headers;
41     GHashTable *headers;
42     int broken_headers;
43     int good_headers;
44     size_t header_size; /* Length of full message header in bytes. */
45
46     /* Parsing state */
47     char *line;
48     size_t line_size;
49     header_value_closure_t value;
50
51     int parsing_started;
52     int parsing_finished;
53 };
54
55 static int
56 strcase_equal (const void *a, const void *b)
57 {
58     return strcasecmp (a, b) == 0;
59 }
60
61 static unsigned int
62 strcase_hash (const void *ptr)
63 {
64     const char *s = ptr;
65
66     /* This is the djb2 hash. */
67     unsigned int hash = 5381;
68     while (s && *s) {
69         hash = ((hash << 5) + hash) + tolower (*s);
70         s++;
71     }
72
73     return hash;
74 }
75
76 static int
77 _notmuch_message_file_destructor (notmuch_message_file_t *message)
78 {
79     if (message->line)
80         free (message->line);
81
82     if (message->value.size)
83         free (message->value.str);
84
85     if (message->headers)
86         g_hash_table_destroy (message->headers);
87
88     if (message->file)
89         fclose (message->file);
90
91     return 0;
92 }
93
94 /* Create a new notmuch_message_file_t for 'filename' with 'ctx' as
95  * the talloc owner. */
96 notmuch_message_file_t *
97 _notmuch_message_file_open_ctx (void *ctx, const char *filename)
98 {
99     notmuch_message_file_t *message;
100
101     message = talloc_zero (ctx, notmuch_message_file_t);
102     if (unlikely (message == NULL))
103         return NULL;
104
105     talloc_set_destructor (message, _notmuch_message_file_destructor);
106
107     message->file = fopen (filename, "r");
108     if (message->file == NULL)
109         goto FAIL;
110
111     message->headers = g_hash_table_new_full (strcase_hash,
112                                               strcase_equal,
113                                               free,
114                                               g_free);
115
116     message->parsing_started = 0;
117     message->parsing_finished = 0;
118
119     return message;
120
121   FAIL:
122     fprintf (stderr, "Error opening %s: %s\n", filename, strerror (errno));
123     notmuch_message_file_close (message);
124
125     return NULL;
126 }
127
128 notmuch_message_file_t *
129 notmuch_message_file_open (const char *filename)
130 {
131     return _notmuch_message_file_open_ctx (NULL, filename);
132 }
133
134 void
135 notmuch_message_file_close (notmuch_message_file_t *message)
136 {
137     talloc_free (message);
138 }
139
140 void
141 notmuch_message_file_restrict_headersv (notmuch_message_file_t *message,
142                                         va_list va_headers)
143 {
144     char *header;
145
146     if (message->parsing_started)
147         INTERNAL_ERROR ("notmuch_message_file_restrict_headers called after parsing has started");
148
149     while (1) {
150         header = va_arg (va_headers, char*);
151         if (header == NULL)
152             break;
153         g_hash_table_insert (message->headers,
154                              xstrdup (header), NULL);
155     }
156
157     message->restrict_headers = 1;
158 }
159
160 void
161 notmuch_message_file_restrict_headers (notmuch_message_file_t *message, ...)
162 {
163     va_list va_headers;
164
165     va_start (va_headers, message);
166
167     notmuch_message_file_restrict_headersv (message, va_headers);
168 }
169
170 static void
171 copy_header_unfolding (header_value_closure_t *value,
172                        const char *chunk)
173 {
174     char *last;
175
176     if (chunk == NULL)
177         return;
178
179     while (*chunk == ' ' || *chunk == '\t')
180         chunk++;
181
182     if (value->len + 1 + strlen (chunk) + 1 > value->size) {
183         unsigned int new_size = value->size;
184         if (value->size == 0)
185             new_size = strlen (chunk) + 1;
186         else
187             while (value->len + 1 + strlen (chunk) + 1 > new_size)
188                 new_size *= 2;
189         value->str = xrealloc (value->str, new_size);
190         value->size = new_size;
191     }
192
193     last = value->str + value->len;
194     if (value->len) {
195         *last = ' ';
196         last++;
197         value->len++;
198     }
199
200     strcpy (last, chunk);
201     value->len += strlen (chunk);
202
203     last = value->str + value->len - 1;
204     if (*last == '\n') {
205         *last = '\0';
206         value->len--;
207     }
208 }
209
210 /* As a special-case, a value of NULL for header_desired will force
211  * the entire header to be parsed if it is not parsed already. This is
212  * used by the _notmuch_message_file_get_headers_end function.
213  * Another special case is the Received: header. For this header we
214  * want to concatenate all instances of the header instead of just
215  * hashing the first instance as we use this when analyzing the path
216  * the mail has taken from sender to recipient.
217  */
218 const char *
219 notmuch_message_file_get_header (notmuch_message_file_t *message,
220                                  const char *header_desired)
221 {
222     int contains;
223     char *header, *decoded_value, *header_sofar, *combined_header;
224     const char *s, *colon;
225     int match, newhdr, hdrsofar, is_received;
226     static int initialized = 0;
227
228     is_received = (strcmp(header_desired,"received") == 0);
229
230     if (! initialized) {
231         g_mime_init (0);
232         initialized = 1;
233     }
234
235     message->parsing_started = 1;
236
237     if (header_desired == NULL)
238         contains = 0;
239     else
240         contains = g_hash_table_lookup_extended (message->headers,
241                                                  header_desired, NULL,
242                                                  (gpointer *) &decoded_value);
243
244     if (contains && decoded_value)
245         return decoded_value;
246
247     if (message->parsing_finished)
248         return "";
249
250 #define NEXT_HEADER_LINE(closure)                               \
251     while (1) {                                                 \
252         ssize_t bytes_read = getline (&message->line,           \
253                                       &message->line_size,      \
254                                       message->file);           \
255         if (bytes_read == -1) {                                 \
256             message->parsing_finished = 1;                      \
257             break;                                              \
258         }                                                       \
259         if (*message->line == '\n') {                           \
260             message->parsing_finished = 1;                      \
261             break;                                              \
262         }                                                       \
263         if (closure &&                                          \
264             (*message->line == ' ' || *message->line == '\t'))  \
265         {                                                       \
266             copy_header_unfolding ((closure), message->line);   \
267         }                                                       \
268         if (*message->line == ' ' || *message->line == '\t')    \
269             message->header_size += strlen (message->line);     \
270         else                                                    \
271             break;                                              \
272     }
273
274     if (message->line == NULL)
275         NEXT_HEADER_LINE (NULL);
276
277     while (1) {
278
279         if (message->parsing_finished)
280             break;
281
282         colon = strchr (message->line, ':');
283
284         if (colon == NULL) {
285             message->broken_headers++;
286             /* A simple heuristic for giving up on things that just
287              * don't look like mail messages. */
288             if (message->broken_headers >= 10 &&
289                 message->good_headers < 5)
290             {
291                 message->parsing_finished = 1;
292                 break;
293             }
294             NEXT_HEADER_LINE (NULL);
295             continue;
296         }
297
298         message->header_size += strlen (message->line);
299
300         message->good_headers++;
301
302         header = xstrndup (message->line, colon - message->line);
303
304         if (message->restrict_headers &&
305             ! g_hash_table_lookup_extended (message->headers,
306                                             header, NULL, NULL))
307         {
308             free (header);
309             NEXT_HEADER_LINE (NULL);
310             continue;
311         }
312
313         s = colon + 1;
314         while (*s == ' ' || *s == '\t')
315             s++;
316
317         message->value.len = 0;
318         copy_header_unfolding (&message->value, s);
319
320         NEXT_HEADER_LINE (&message->value);
321
322         if (header_desired == NULL)
323             match = 0;
324         else
325             match = (strcasecmp (header, header_desired) == 0);
326
327         decoded_value = g_mime_utils_header_decode_text (message->value.str);
328         header_sofar = (char *)g_hash_table_lookup (message->headers, header);
329         /* we treat the Received: header special - we want to concat ALL of 
330          * the Received: headers we encounter.
331          * for everything else we return the first instance of a header */
332         if (strcasecmp(header, "received") == 0) {
333             if (header_sofar == NULL) {
334                 /* first Received: header we encountered; just add it */
335                 g_hash_table_insert (message->headers, header, decoded_value);
336             } else {
337                 /* we need to add the header to those we already collected */
338                 newhdr = strlen(decoded_value);
339                 hdrsofar = strlen(header_sofar);
340                 combined_header = g_malloc(hdrsofar + newhdr + 2);
341                 strncpy(combined_header,header_sofar,hdrsofar);
342                 *(combined_header+hdrsofar) = ' ';
343                 strncpy(combined_header+hdrsofar+1,decoded_value,newhdr+1);
344                 g_free (decoded_value);
345                 g_hash_table_insert (message->headers, header, combined_header);
346             }
347         } else {
348             if (header_sofar == NULL) {
349                 /* Only insert if we don't have a value for this header, yet. */
350                 g_hash_table_insert (message->headers, header, decoded_value);
351             } else {
352                 free (header);
353                 g_free (decoded_value);
354                 decoded_value = header_sofar;
355             }
356         }
357         /* if we found a match we can bail - unless of course we are
358          * collecting all the Received: headers */
359         if (match && !is_received)
360             return decoded_value;
361     }
362
363     if (message->parsing_finished) {
364         fclose (message->file);
365         message->file = NULL;
366     }
367
368     if (message->line)
369         free (message->line);
370     message->line = NULL;
371
372     if (message->value.size) {
373         free (message->value.str);
374         message->value.str = NULL;
375         message->value.size = 0;
376         message->value.len = 0;
377     }
378
379     /* For the Received: header we actually might end up here even
380      * though we found the header (as we force continued parsing
381      * in that case). So let's check if that's the header we were
382      * looking for and return the value that we found (if any)
383      */
384     if (is_received)
385         return (char *)g_hash_table_lookup (message->headers, "received");
386
387     /* We've parsed all headers and never found the one we're looking
388      * for. It's probably just not there, but let's check that we
389      * didn't make a mistake preventing us from seeing it. */
390     if (message->restrict_headers && header_desired &&
391         ! g_hash_table_lookup_extended (message->headers,
392                                         header_desired, NULL, NULL))
393     {
394         INTERNAL_ERROR ("Attempt to get header \"%s\" which was not\n"
395                         "included in call to notmuch_message_file_restrict_headers\n",
396                         header_desired);
397     }
398
399     return "";
400 }