notmuch-mutt: replace shell pipeline with internal pipe processing
[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 https://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 struct _notmuch_message_file {
30     /* open stream to (possibly gzipped) file */
31     GMimeStream *stream;
32     char *filename;
33
34     /* Cache for decoded headers */
35     GHashTable *headers;
36
37     GMimeMessage *message;
38 };
39
40 static int
41 _notmuch_message_file_destructor (notmuch_message_file_t *message)
42 {
43     if (message->headers)
44         g_hash_table_destroy (message->headers);
45
46     if (message->message)
47         g_object_unref (message->message);
48
49     if (message->stream)
50         g_object_unref (message->stream);
51
52     return 0;
53 }
54
55 /* Create a new notmuch_message_file_t for 'filename' with 'ctx' as
56  * the talloc owner. */
57 notmuch_message_file_t *
58 _notmuch_message_file_open_ctx (notmuch_database_t *notmuch,
59                                 void *ctx, const char *filename)
60 {
61     notmuch_message_file_t *message;
62
63     message = talloc_zero (ctx, notmuch_message_file_t);
64     if (unlikely (message == NULL))
65         return NULL;
66
67     message->filename = talloc_strdup (message, filename);
68     if (message->filename == NULL)
69         goto FAIL;
70
71     talloc_set_destructor (message, _notmuch_message_file_destructor);
72
73     message->stream = g_mime_stream_gzfile_open (filename);
74     if (message->stream == NULL)
75         goto FAIL;
76
77     return message;
78
79   FAIL:
80     _notmuch_database_log (notmuch, "Error opening %s: %s\n",
81                            filename, strerror (errno));
82     _notmuch_message_file_close (message);
83
84     return NULL;
85 }
86
87 notmuch_message_file_t *
88 _notmuch_message_file_open (notmuch_database_t *notmuch,
89                             const char *filename)
90 {
91     return _notmuch_message_file_open_ctx (notmuch, NULL, filename);
92 }
93
94 const char *
95 _notmuch_message_file_get_filename (notmuch_message_file_t *message_file)
96 {
97     return message_file->filename;
98 }
99
100 void
101 _notmuch_message_file_close (notmuch_message_file_t *message)
102 {
103     talloc_free (message);
104 }
105
106 static bool
107 _is_mbox (GMimeStream *stream)
108 {
109     char from_buf[5];
110     bool ret = false;
111
112     /* Is this mbox? */
113     if (g_mime_stream_read (stream, from_buf, sizeof (from_buf)) == sizeof (from_buf) &&
114         strncmp (from_buf, "From ", 5) == 0)
115         ret = true;
116
117     g_mime_stream_reset (stream);
118
119     return ret;
120 }
121
122 notmuch_status_t
123 _notmuch_message_file_parse (notmuch_message_file_t *message)
124 {
125     GMimeParser *parser;
126     notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
127     static int initialized = 0;
128     bool is_mbox;
129
130     if (message->message)
131         return NOTMUCH_STATUS_SUCCESS;
132
133     is_mbox = _is_mbox (message->stream);
134
135     if (! initialized) {
136         g_mime_init ();
137         initialized = 1;
138     }
139
140     message->headers = g_hash_table_new_full (strcase_hash, strcase_equal,
141                                               free, g_free);
142     if (! message->headers)
143         return NOTMUCH_STATUS_OUT_OF_MEMORY;
144
145     parser = g_mime_parser_new_with_stream (message->stream);
146     g_mime_parser_set_scan_from (parser, is_mbox);
147
148     message->message = g_mime_parser_construct_message (parser, NULL);
149     if (! message->message) {
150         status = NOTMUCH_STATUS_FILE_NOT_EMAIL;
151         goto DONE;
152     }
153
154     if (is_mbox && ! g_mime_parser_eos (parser)) {
155         /*
156          * This is a multi-message mbox. (For historical reasons, we
157          * do support single-message mboxes.)
158          */
159         status = NOTMUCH_STATUS_FILE_NOT_EMAIL;
160     }
161
162   DONE:
163     g_mime_stream_reset (message->stream);
164     g_object_unref (parser);
165
166     if (status) {
167         g_hash_table_destroy (message->headers);
168         message->headers = NULL;
169
170         if (message->message) {
171             g_object_unref (message->message);
172             message->message = NULL;
173         }
174
175     }
176
177     return status;
178 }
179
180 notmuch_status_t
181 _notmuch_message_file_get_mime_message (notmuch_message_file_t *message,
182                                         GMimeMessage **mime_message)
183 {
184     notmuch_status_t status;
185
186     status = _notmuch_message_file_parse (message);
187     if (status)
188         return status;
189
190     *mime_message = message->message;
191
192     return NOTMUCH_STATUS_SUCCESS;
193 }
194
195 /*
196  * Get all instances of a header decoded and concatenated.
197  *
198  * The result must be freed using g_free().
199  *
200  * Return NULL on errors, empty string for non-existing headers.
201  */
202
203 static char *
204 _extend_header (char *combined, const char *value)
205 {
206     char *decoded;
207
208     decoded = g_mime_utils_header_decode_text (NULL, value);
209     if (! decoded) {
210         if (combined) {
211             g_free (combined);
212             combined = NULL;
213         }
214         goto DONE;
215     }
216
217     if (combined) {
218         char *tmp = g_strdup_printf ("%s %s", combined, decoded);
219         g_free (decoded);
220         g_free (combined);
221         if (! tmp) {
222             combined = NULL;
223             goto DONE;
224         }
225
226         combined = tmp;
227     } else {
228         combined = decoded;
229     }
230   DONE:
231     return combined;
232 }
233
234 static char *
235 _notmuch_message_file_get_combined_header (notmuch_message_file_t *message,
236                                            const char *header)
237 {
238     char *combined = NULL;
239     GMimeHeaderList *headers;
240
241     headers = g_mime_object_get_header_list (GMIME_OBJECT (message->message));
242     if (! headers)
243         return NULL;
244
245
246     for (int i = 0; i < g_mime_header_list_get_count (headers); i++) {
247         const char *value;
248         GMimeHeader *g_header = g_mime_header_list_get_header_at (headers, i);
249
250         if (strcasecmp (g_mime_header_get_name (g_header), header) != 0)
251             continue;
252
253         /* GMime retains ownership of value, we hope */
254         value = g_mime_header_get_value (g_header);
255
256         combined = _extend_header (combined, value);
257     }
258
259     /* Return empty string for non-existing headers. */
260     if (! combined)
261         combined = g_strdup ("");
262
263     return combined;
264 }
265
266 const char *
267 _notmuch_message_file_get_header (notmuch_message_file_t *message,
268                                   const char *header)
269 {
270     const char *value;
271     char *decoded;
272
273     if (_notmuch_message_file_parse (message))
274         return NULL;
275
276     /* If we have a cached decoded value, use it. */
277     value = g_hash_table_lookup (message->headers, header);
278     if (value)
279         return value;
280
281     if (strcasecmp (header, "received") == 0) {
282         /*
283          * The Received: header is special. We concatenate all
284          * instances of the header as we use this when analyzing the
285          * path the mail has taken from sender to recipient.
286          */
287         decoded = _notmuch_message_file_get_combined_header (message, header);
288     } else {
289         value = g_mime_object_get_header (GMIME_OBJECT (message->message),
290                                           header);
291         if (value)
292             decoded = g_mime_utils_header_decode_text (NULL, value);
293         else
294             decoded = g_strdup ("");
295     }
296
297     if (! decoded)
298         return NULL;
299
300     /* Cache the decoded value. We also own the strings. */
301     g_hash_table_insert (message->headers, xstrdup (header), decoded);
302
303     return decoded;
304 }
305
306 notmuch_status_t
307 _notmuch_message_file_get_headers (notmuch_message_file_t *message_file,
308                                    const char **from_out,
309                                    const char **subject_out,
310                                    const char **to_out,
311                                    const char **date_out,
312                                    char **message_id_out)
313 {
314     notmuch_status_t ret;
315     const char *header;
316     const char *from, *to, *subject, *date;
317     char *message_id = NULL;
318
319     /* Parse message up front to get better error status. */
320     ret = _notmuch_message_file_parse (message_file);
321     if (ret)
322         goto DONE;
323
324     /* Before we do any real work, (especially before doing a
325      * potential SHA-1 computation on the entire file's contents),
326      * let's make sure that what we're looking at looks like an
327      * actual email message.
328      */
329     from = _notmuch_message_file_get_header (message_file, "from");
330     subject = _notmuch_message_file_get_header (message_file, "subject");
331     to = _notmuch_message_file_get_header (message_file, "to");
332     date = _notmuch_message_file_get_header (message_file, "date");
333
334     if ((from == NULL || *from == '\0') &&
335         (subject == NULL || *subject == '\0') &&
336         (to == NULL || *to == '\0')) {
337         ret = NOTMUCH_STATUS_FILE_NOT_EMAIL;
338         goto DONE;
339     }
340
341     /* Now that we're sure it's mail, the first order of business
342      * is to find a message ID (or else create one ourselves).
343      */
344     header = _notmuch_message_file_get_header (message_file, "message-id");
345     if (header && *header != '\0') {
346         message_id = _notmuch_message_id_parse (message_file, header, NULL);
347
348         /* So the header value isn't RFC-compliant, but it's
349          * better than no message-id at all.
350          */
351         if (message_id == NULL)
352             message_id = talloc_strdup (message_file, header);
353     }
354
355     if (message_id == NULL ) {
356         /* No message-id at all, let's generate one by taking a
357          * hash over the file's contents.
358          */
359         char *sha1 = _notmuch_sha1_of_file (_notmuch_message_file_get_filename (message_file));
360
361         /* If that failed too, something is really wrong. Give up. */
362         if (sha1 == NULL) {
363             ret = NOTMUCH_STATUS_FILE_ERROR;
364             goto DONE;
365         }
366
367         message_id = talloc_asprintf (message_file, "notmuch-sha1-%s", sha1);
368         free (sha1);
369     }
370   DONE:
371     if (ret == NOTMUCH_STATUS_SUCCESS) {
372         if (from_out)
373             *from_out = from;
374         if (subject_out)
375             *subject_out = subject;
376         if (to_out)
377             *to_out = to;
378         if (date_out)
379             *date_out = date;
380         if (message_id_out)
381             *message_id_out = message_id;
382     }
383     return ret;
384 }