1 /* message.c - Utility functions for parsing an email message for notmuch.
3 * Copyright © 2009 Carl Worth
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.
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.
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/ .
18 * Author: Carl Worth <cworth@cworth.org>
23 #include "notmuch-private.h"
25 #include <gmime/gmime.h>
27 #include <glib.h> /* GHashTable */
29 struct _notmuch_message_file {
30 /* open stream to (possibly gzipped) file */
34 /* Cache for decoded headers */
37 GMimeMessage *message;
41 _notmuch_message_file_destructor (notmuch_message_file_t *message)
44 g_hash_table_destroy (message->headers);
47 g_object_unref (message->message);
50 g_object_unref (message->stream);
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)
61 notmuch_message_file_t *message;
63 message = talloc_zero (ctx, notmuch_message_file_t);
64 if (unlikely (message == NULL))
67 message->filename = talloc_strdup (message, filename);
68 if (message->filename == NULL)
71 talloc_set_destructor (message, _notmuch_message_file_destructor);
73 message->stream = g_mime_stream_gzfile_open (filename);
74 if (message->stream == NULL)
80 _notmuch_database_log (notmuch, "Error opening %s: %s\n",
81 filename, strerror (errno));
82 _notmuch_message_file_close (message);
87 notmuch_message_file_t *
88 _notmuch_message_file_open (notmuch_database_t *notmuch,
91 return _notmuch_message_file_open_ctx (notmuch, NULL, filename);
95 _notmuch_message_file_get_filename (notmuch_message_file_t *message_file)
97 return message_file->filename;
101 _notmuch_message_file_close (notmuch_message_file_t *message)
103 talloc_free (message);
107 _is_mbox (GMimeStream *stream)
113 if (g_mime_stream_read (stream, from_buf, sizeof (from_buf)) == sizeof (from_buf) &&
114 strncmp (from_buf, "From ", 5) == 0)
117 g_mime_stream_reset (stream);
123 _notmuch_message_file_parse (notmuch_message_file_t *message)
126 notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
127 static int initialized = 0;
130 if (message->message)
131 return NOTMUCH_STATUS_SUCCESS;
133 is_mbox = _is_mbox (message->stream);
140 message->headers = g_hash_table_new_full (strcase_hash, strcase_equal,
142 if (! message->headers)
143 return NOTMUCH_STATUS_OUT_OF_MEMORY;
145 parser = g_mime_parser_new_with_stream (message->stream);
146 g_mime_parser_set_scan_from (parser, is_mbox);
148 message->message = g_mime_parser_construct_message (parser, NULL);
149 if (! message->message) {
150 status = NOTMUCH_STATUS_FILE_NOT_EMAIL;
154 if (is_mbox && ! g_mime_parser_eos (parser)) {
156 * This is a multi-message mbox. (For historical reasons, we
157 * do support single-message mboxes.)
159 status = NOTMUCH_STATUS_FILE_NOT_EMAIL;
163 g_mime_stream_reset (message->stream);
164 g_object_unref (parser);
167 g_hash_table_destroy (message->headers);
168 message->headers = NULL;
170 if (message->message) {
171 g_object_unref (message->message);
172 message->message = NULL;
181 _notmuch_message_file_get_mime_message (notmuch_message_file_t *message,
182 GMimeMessage **mime_message)
184 notmuch_status_t status;
186 status = _notmuch_message_file_parse (message);
190 *mime_message = message->message;
192 return NOTMUCH_STATUS_SUCCESS;
196 * Get all instances of a header decoded and concatenated.
198 * The result must be freed using g_free().
200 * Return NULL on errors, empty string for non-existing headers.
204 _extend_header (char *combined, const char *value)
208 decoded = g_mime_utils_header_decode_text (NULL, value);
218 char *tmp = g_strdup_printf ("%s %s", combined, decoded);
235 _notmuch_message_file_get_combined_header (notmuch_message_file_t *message,
238 char *combined = NULL;
239 GMimeHeaderList *headers;
241 headers = g_mime_object_get_header_list (GMIME_OBJECT (message->message));
246 for (int i = 0; i < g_mime_header_list_get_count (headers); i++) {
248 GMimeHeader *g_header = g_mime_header_list_get_header_at (headers, i);
250 if (strcasecmp (g_mime_header_get_name (g_header), header) != 0)
253 /* GMime retains ownership of value, we hope */
254 value = g_mime_header_get_value (g_header);
256 combined = _extend_header (combined, value);
259 /* Return empty string for non-existing headers. */
261 combined = g_strdup ("");
267 _notmuch_message_file_get_header (notmuch_message_file_t *message,
273 if (_notmuch_message_file_parse (message))
276 /* If we have a cached decoded value, use it. */
277 value = g_hash_table_lookup (message->headers, header);
281 if (strcasecmp (header, "received") == 0) {
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.
287 decoded = _notmuch_message_file_get_combined_header (message, header);
289 value = g_mime_object_get_header (GMIME_OBJECT (message->message),
292 decoded = g_mime_utils_header_decode_text (NULL, value);
294 decoded = g_strdup ("");
300 /* Cache the decoded value. We also own the strings. */
301 g_hash_table_insert (message->headers, xstrdup (header), decoded);
307 _notmuch_message_file_get_headers (notmuch_message_file_t *message_file,
308 const char **from_out,
309 const char **subject_out,
311 const char **date_out,
312 char **message_id_out)
314 notmuch_status_t ret;
316 const char *from, *to, *subject, *date;
317 char *message_id = NULL;
319 /* Parse message up front to get better error status. */
320 ret = _notmuch_message_file_parse (message_file);
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.
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");
334 if ((from == NULL || *from == '\0') &&
335 (subject == NULL || *subject == '\0') &&
336 (to == NULL || *to == '\0')) {
337 ret = NOTMUCH_STATUS_FILE_NOT_EMAIL;
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).
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);
348 /* So the header value isn't RFC-compliant, but it's
349 * better than no message-id at all.
351 if (message_id == NULL)
352 message_id = talloc_strdup (message_file, header);
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.
359 char *sha1 = _notmuch_sha1_of_file (_notmuch_message_file_get_filename (message_file));
361 /* If that failed too, something is really wrong. Give up. */
363 ret = NOTMUCH_STATUS_FILE_ERROR;
367 message_id = talloc_asprintf (message_file, "notmuch-sha1-%s", sha1);
371 if (ret == NOTMUCH_STATUS_SUCCESS) {
375 *subject_out = subject;
381 *message_id_out = message_id;