git.notmuchmail.org Git - notmuch/blob - 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 }