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 const char *prefix = notmuch_config_get (notmuch, NOTMUCH_CONFIG_MAIL_ROOT);
72 if (*filename == '/') {
73 if (strncmp (filename, prefix, strlen (prefix)) != 0) {
74 _notmuch_database_log (notmuch, "Error opening %s: path outside mail root\n",
79 message->filename = talloc_strdup (message, filename);
81 message->filename = talloc_asprintf (message, "%s/%s", prefix, filename);
84 if (message->filename == NULL)
87 talloc_set_destructor (message, _notmuch_message_file_destructor);
89 message->stream = g_mime_stream_gzfile_open (message->filename);
90 if (message->stream == NULL)
97 _notmuch_database_log (notmuch, "Error opening %s: %s\n",
98 filename, strerror (errno));
99 _notmuch_message_file_close (message);
104 notmuch_message_file_t *
105 _notmuch_message_file_open (notmuch_database_t *notmuch,
106 const char *filename)
108 return _notmuch_message_file_open_ctx (notmuch, NULL, filename);
112 _notmuch_message_file_get_filename (notmuch_message_file_t *message_file)
114 return message_file->filename;
118 _notmuch_message_file_close (notmuch_message_file_t *message)
120 talloc_free (message);
124 _is_mbox (GMimeStream *stream)
130 if (g_mime_stream_read (stream, from_buf, sizeof (from_buf)) == sizeof (from_buf) &&
131 strncmp (from_buf, "From ", 5) == 0)
134 g_mime_stream_reset (stream);
140 _notmuch_message_file_parse (notmuch_message_file_t *message)
143 notmuch_status_t status = NOTMUCH_STATUS_SUCCESS;
146 if (message->message)
147 return NOTMUCH_STATUS_SUCCESS;
149 is_mbox = _is_mbox (message->stream);
153 message->headers = g_hash_table_new_full (strcase_hash, strcase_equal,
155 if (! message->headers)
156 return NOTMUCH_STATUS_OUT_OF_MEMORY;
158 parser = g_mime_parser_new_with_stream (message->stream);
159 g_mime_parser_set_scan_from (parser, is_mbox);
161 message->message = g_mime_parser_construct_message (parser, NULL);
162 if (! message->message) {
163 status = NOTMUCH_STATUS_FILE_NOT_EMAIL;
167 if (is_mbox && ! g_mime_parser_eos (parser)) {
169 * This is a multi-message mbox. (For historical reasons, we
170 * do support single-message mboxes.)
172 status = NOTMUCH_STATUS_FILE_NOT_EMAIL;
176 g_mime_stream_reset (message->stream);
177 g_object_unref (parser);
180 g_hash_table_destroy (message->headers);
181 message->headers = NULL;
183 if (message->message) {
184 g_object_unref (message->message);
185 message->message = NULL;
194 _notmuch_message_file_get_mime_message (notmuch_message_file_t *message,
195 GMimeMessage **mime_message)
197 notmuch_status_t status;
199 status = _notmuch_message_file_parse (message);
203 *mime_message = message->message;
205 return NOTMUCH_STATUS_SUCCESS;
209 * Get all instances of a header decoded and concatenated.
211 * The result must be freed using g_free().
213 * Return NULL on errors, empty string for non-existing headers.
217 _extend_header (char *combined, const char *value)
221 decoded = g_mime_utils_header_decode_text (NULL, value);
231 char *tmp = g_strdup_printf ("%s %s", combined, decoded);
248 _notmuch_message_file_get_combined_header (notmuch_message_file_t *message,
251 char *combined = NULL;
252 GMimeHeaderList *headers;
254 headers = g_mime_object_get_header_list (GMIME_OBJECT (message->message));
259 for (int i = 0; i < g_mime_header_list_get_count (headers); i++) {
261 GMimeHeader *g_header = g_mime_header_list_get_header_at (headers, i);
263 if (strcasecmp (g_mime_header_get_name (g_header), header) != 0)
266 /* GMime retains ownership of value, we hope */
267 value = g_mime_header_get_value (g_header);
269 combined = _extend_header (combined, value);
272 /* Return empty string for non-existing headers. */
274 combined = g_strdup ("");
280 _notmuch_message_file_get_header (notmuch_message_file_t *message,
286 if (_notmuch_message_file_parse (message))
289 /* If we have a cached decoded value, use it. */
290 value = g_hash_table_lookup (message->headers, header);
294 if (strcasecmp (header, "received") == 0 ||
295 strcasecmp (header, "delivered-to") == 0) {
297 * The Received: header is special. We concatenate all instances of the
298 * header as we use this when analyzing the path the mail has taken
299 * from sender to recipient.
301 * Similarly, multiple instances of Delivered-To may be present. We
302 * concatenate them so the one with highest priority may be picked (eg.
303 * primary_email before other_email).
305 decoded = _notmuch_message_file_get_combined_header (message, header);
307 value = g_mime_object_get_header (GMIME_OBJECT (message->message),
310 decoded = g_mime_utils_header_decode_text (NULL, value);
312 decoded = g_strdup ("");
318 /* Cache the decoded value. We also own the strings. */
319 g_hash_table_insert (message->headers, xstrdup (header), decoded);
325 _notmuch_message_file_get_headers (notmuch_message_file_t *message_file,
326 const char **from_out,
327 const char **subject_out,
329 const char **date_out,
330 char **message_id_out)
332 notmuch_status_t ret;
334 const char *from, *to, *subject, *date;
335 char *message_id = NULL;
337 /* Parse message up front to get better error status. */
338 ret = _notmuch_message_file_parse (message_file);
342 /* Before we do any real work, (especially before doing a
343 * potential SHA-1 computation on the entire file's contents),
344 * let's make sure that what we're looking at looks like an
345 * actual email message.
347 from = _notmuch_message_file_get_header (message_file, "from");
348 subject = _notmuch_message_file_get_header (message_file, "subject");
349 to = _notmuch_message_file_get_header (message_file, "to");
350 date = _notmuch_message_file_get_header (message_file, "date");
352 if ((from == NULL || *from == '\0') &&
353 (subject == NULL || *subject == '\0') &&
354 (to == NULL || *to == '\0')) {
355 ret = NOTMUCH_STATUS_FILE_NOT_EMAIL;
359 /* Now that we're sure it's mail, the first order of business
360 * is to find a message ID (or else create one ourselves).
362 header = _notmuch_message_file_get_header (message_file, "message-id");
363 if (header && *header != '\0') {
364 message_id = _notmuch_message_id_parse (message_file, header, NULL);
366 /* So the header value isn't RFC-compliant, but it's
367 * better than no message-id at all.
369 if (message_id == NULL)
370 message_id = talloc_strdup (message_file, header);
373 if (message_id == NULL ) {
374 /* No message-id at all, let's generate one by taking a
375 * hash over the file's contents.
377 char *sha1 = _notmuch_sha1_of_file (_notmuch_message_file_get_filename (message_file));
379 /* If that failed too, something is really wrong. Give up. */
381 ret = NOTMUCH_STATUS_FILE_ERROR;
385 message_id = talloc_asprintf (message_file, "notmuch-sha1-%s", sha1);
389 if (ret == NOTMUCH_STATUS_SUCCESS) {
393 *subject_out = subject;
399 *message_id_out = message_id;