cli/insert: abstract temporary filename generation
[notmuch] / notmuch-insert.c
1 /* notmuch - Not much of an email program, (just index and search)
2  *
3  * Copyright © 2013 Peter Wang
4  *
5  * Based in part on notmuch-deliver
6  * Copyright © 2010 Ali Polatel
7  *
8  * This program is free software: you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation, either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program.  If not, see http://www.gnu.org/licenses/ .
20  *
21  * Author: Peter Wang <novalazy@gmail.com>
22  */
23
24 #include "notmuch-client.h"
25 #include "tag-util.h"
26
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <fcntl.h>
30
31 static volatile sig_atomic_t interrupted;
32
33 static void
34 handle_sigint (unused (int sig))
35 {
36     static char msg[] = "Stopping...         \n";
37
38     /* This write is "opportunistic", so it's okay to ignore the
39      * result.  It is not required for correctness, and if it does
40      * fail or produce a short write, we want to get out of the signal
41      * handler as quickly as possible, not retry it. */
42     IGNORE_RESULT (write (2, msg, sizeof (msg) - 1));
43     interrupted = 1;
44 }
45
46 /* Like gethostname but guarantees that a null-terminated hostname is
47  * returned, even if it has to make one up. Invalid characters are
48  * substituted such that the hostname can be used within a filename.
49  */
50 static void
51 safe_gethostname (char *hostname, size_t len)
52 {
53     char *p;
54
55     if (gethostname (hostname, len) == -1) {
56         strncpy (hostname, "unknown", len);
57     }
58     hostname[len - 1] = '\0';
59
60     for (p = hostname; *p != '\0'; p++) {
61         if (*p == '/' || *p == ':')
62             *p = '_';
63     }
64 }
65
66 /* Call fsync() on a directory path. */
67 static notmuch_bool_t
68 sync_dir (const char *dir)
69 {
70     int fd, r;
71
72     fd = open (dir, O_RDONLY);
73     if (fd == -1) {
74         fprintf (stderr, "Error: open %s: %s\n", dir, strerror (errno));
75         return FALSE;
76     }
77
78     r = fsync (fd);
79     if (r)
80         fprintf (stderr, "Error: fsync %s: %s\n", dir, strerror (errno));
81
82     close (fd);
83
84     return r == 0;
85 }
86
87 /*
88  * Check the specified folder name does not contain a directory
89  * component ".." to prevent writes outside of the Maildir
90  * hierarchy. Return TRUE on valid folder name, FALSE otherwise.
91  */
92 static notmuch_bool_t
93 is_valid_folder_name (const char *folder)
94 {
95     const char *p = folder;
96
97     for (;;) {
98         if ((p[0] == '.') && (p[1] == '.') && (p[2] == '\0' || p[2] == '/'))
99             return FALSE;
100         p = strchr (p, '/');
101         if (!p)
102             return TRUE;
103         p++;
104     }
105 }
106
107 /*
108  * Make the given directory and its parents as necessary, using the
109  * given mode. Return TRUE on success, FALSE otherwise. Partial
110  * results are not cleaned up on errors.
111  */
112 static notmuch_bool_t
113 mkdir_recursive (const void *ctx, const char *path, int mode)
114 {
115     struct stat st;
116     int r;
117     char *parent = NULL, *slash;
118
119     /* First check the common case: directory already exists. */
120     r = stat (path, &st);
121     if (r == 0) {
122         if (! S_ISDIR (st.st_mode)) {
123             fprintf (stderr, "Error: '%s' is not a directory: %s\n",
124                      path, strerror (EEXIST));
125             return FALSE;
126         }
127
128         return TRUE;
129     } else if (errno != ENOENT) {
130         fprintf (stderr, "Error: stat '%s': %s\n", path, strerror (errno));
131         return FALSE;
132     }
133
134     /* mkdir parents, if any */
135     slash = strrchr (path, '/');
136     if (slash && slash != path) {
137         parent = talloc_strndup (ctx, path, slash - path);
138         if (! parent) {
139             fprintf (stderr, "Error: %s\n", strerror (ENOMEM));
140             return FALSE;
141         }
142
143         if (! mkdir_recursive (ctx, parent, mode))
144             return FALSE;
145     }
146
147     if (mkdir (path, mode)) {
148         fprintf (stderr, "Error: mkdir '%s': %s\n", path, strerror (errno));
149         return FALSE;
150     }
151
152     return parent ? sync_dir (parent) : TRUE;
153 }
154
155 /*
156  * Create the given maildir folder, i.e. maildir and its
157  * subdirectories cur/new/tmp. Return TRUE on success, FALSE
158  * otherwise. Partial results are not cleaned up on errors.
159  */
160 static notmuch_bool_t
161 maildir_create_folder (const void *ctx, const char *maildir)
162 {
163     const char *subdirs[] = { "cur", "new", "tmp" };
164     const int mode = 0700;
165     char *subdir;
166     unsigned int i;
167
168     for (i = 0; i < ARRAY_SIZE (subdirs); i++) {
169         subdir = talloc_asprintf (ctx, "%s/%s", maildir, subdirs[i]);
170         if (! subdir) {
171             fprintf (stderr, "Error: %s\n", strerror (ENOMEM));
172             return FALSE;
173         }
174
175         if (! mkdir_recursive (ctx, subdir, mode))
176             return FALSE;
177     }
178
179     return TRUE;
180 }
181
182 /*
183  * Generate a temporary file basename, no path, do not create an
184  * actual file. Return the basename, or NULL on errors.
185  */
186 static char *
187 tempfilename (const void *ctx)
188 {
189     char *filename;
190     char hostname[256];
191     struct timeval tv;
192     pid_t pid;
193
194     /* We follow the Dovecot file name generation algorithm. */
195     pid = getpid ();
196     safe_gethostname (hostname, sizeof (hostname));
197     gettimeofday (&tv, NULL);
198
199     filename = talloc_asprintf (ctx, "%ld.M%ldP%d.%s",
200                                 tv.tv_sec, tv.tv_usec, pid, hostname);
201     if (! filename)
202         fprintf (stderr, "Error: %s\n", strerror (ENOMEM));
203
204     return filename;
205 }
206
207 /* Open a unique file in the 'tmp' sub-directory of dir.
208  * Returns the file descriptor on success, or -1 on failure.
209  * On success, file paths for the message in the 'tmp' and 'new'
210  * directories are returned via tmppath and newpath,
211  * and the path of the 'new' directory itself in newdir. */
212 static int
213 maildir_open_tmp_file (void *ctx, const char *dir,
214                        char **tmppath, char **newpath, char **newdir)
215 {
216     char *filename;
217     int fd = -1;
218
219     do {
220         filename = tempfilename (ctx);
221         if (! filename)
222             return -1;
223
224         *tmppath = talloc_asprintf (ctx, "%s/tmp/%s", dir, filename);
225         if (! *tmppath) {
226             fprintf (stderr, "Out of memory\n");
227             return -1;
228         }
229
230         fd = open (*tmppath, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, 0600);
231     } while (fd == -1 && errno == EEXIST);
232
233     if (fd == -1) {
234         fprintf (stderr, "Error: opening %s: %s\n", *tmppath, strerror (errno));
235         return -1;
236     }
237
238     *newdir = talloc_asprintf (ctx, "%s/new", dir);
239     *newpath = talloc_asprintf (ctx, "%s/new/%s", dir, filename);
240     if (! *newdir || ! *newpath) {
241         fprintf (stderr, "Out of memory\n");
242         close (fd);
243         unlink (*tmppath);
244         return -1;
245     }
246
247     talloc_free (filename);
248
249     return fd;
250 }
251
252 /*
253  * Copy fdin to fdout, return TRUE on success, and FALSE on errors and
254  * empty input.
255  */
256 static notmuch_bool_t
257 copy_fd (int fdout, int fdin)
258 {
259     notmuch_bool_t empty = TRUE;
260
261     while (! interrupted) {
262         ssize_t remain;
263         char buf[4096];
264         char *p;
265
266         remain = read (fdin, buf, sizeof (buf));
267         if (remain == 0)
268             break;
269         if (remain < 0) {
270             if (errno == EINTR)
271                 continue;
272             fprintf (stderr, "Error: reading from standard input: %s\n",
273                      strerror (errno));
274             return FALSE;
275         }
276
277         p = buf;
278         do {
279             ssize_t written = write (fdout, p, remain);
280             if (written < 0 && errno == EINTR)
281                 continue;
282             if (written <= 0) {
283                 fprintf (stderr, "Error: writing to temporary file: %s",
284                          strerror (errno));
285                 return FALSE;
286             }
287             p += written;
288             remain -= written;
289             empty = FALSE;
290         } while (remain > 0);
291     }
292
293     return (!interrupted && !empty);
294 }
295
296 static notmuch_bool_t
297 write_message (void *ctx, int fdin, const char *dir, char **newpath)
298 {
299     char *tmppath;
300     char *newdir;
301     char *cleanup_path;
302     int fdout;
303
304     fdout = maildir_open_tmp_file (ctx, dir, &tmppath, newpath, &newdir);
305     if (fdout < 0)
306         return FALSE;
307
308     cleanup_path = tmppath;
309
310     if (! copy_fd (fdout, fdin))
311         goto FAIL;
312
313     if (fsync (fdout) != 0) {
314         fprintf (stderr, "Error: fsync failed: %s\n", strerror (errno));
315         goto FAIL;
316     }
317
318     close (fdout);
319     fdout = -1;
320
321     /* Atomically move the new message file from the Maildir 'tmp' directory
322      * to the 'new' directory.  We follow the Dovecot recommendation to
323      * simply use rename() instead of link() and unlink().
324      * See also: http://wiki.dovecot.org/MailboxFormat/Maildir#Mail_delivery
325      */
326     if (rename (tmppath, *newpath) != 0) {
327         fprintf (stderr, "Error: rename() failed: %s\n", strerror (errno));
328         goto FAIL;
329     }
330
331     cleanup_path = *newpath;
332
333     if (! sync_dir (newdir))
334         goto FAIL;
335
336     return TRUE;
337
338   FAIL:
339     if (fdout >= 0)
340         close (fdout);
341     unlink (cleanup_path);
342     return FALSE;
343 }
344
345 /* Add the specified message file to the notmuch database, applying tags.
346  * The file is renamed to encode notmuch tags as maildir flags. */
347 static void
348 add_file_to_database (notmuch_database_t *notmuch, const char *path,
349                       tag_op_list_t *tag_ops, notmuch_bool_t synchronize_flags)
350 {
351     notmuch_message_t *message;
352     notmuch_status_t status;
353
354     status = notmuch_database_add_message (notmuch, path, &message);
355     switch (status) {
356     case NOTMUCH_STATUS_SUCCESS:
357     case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
358         break;
359     default:
360     case NOTMUCH_STATUS_FILE_NOT_EMAIL:
361     case NOTMUCH_STATUS_READ_ONLY_DATABASE:
362     case NOTMUCH_STATUS_XAPIAN_EXCEPTION:
363     case NOTMUCH_STATUS_OUT_OF_MEMORY:
364     case NOTMUCH_STATUS_FILE_ERROR:
365     case NOTMUCH_STATUS_NULL_POINTER:
366     case NOTMUCH_STATUS_TAG_TOO_LONG:
367     case NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW:
368     case NOTMUCH_STATUS_UNBALANCED_ATOMIC:
369     case NOTMUCH_STATUS_LAST_STATUS:
370         fprintf (stderr, "Error: failed to add `%s' to notmuch database: %s\n",
371                  path, notmuch_status_to_string (status));
372         return;
373     }
374
375     if (status == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) {
376         /* Don't change tags of an existing message. */
377         if (synchronize_flags) {
378             status = notmuch_message_tags_to_maildir_flags (message);
379             if (status != NOTMUCH_STATUS_SUCCESS)
380                 fprintf (stderr, "Error: failed to sync tags to maildir flags\n");
381         }
382     } else {
383         tag_op_flag_t flags = synchronize_flags ? TAG_FLAG_MAILDIR_SYNC : 0;
384
385         tag_op_list_apply (message, tag_ops, flags);
386     }
387
388     notmuch_message_destroy (message);
389 }
390
391 int
392 notmuch_insert_command (notmuch_config_t *config, int argc, char *argv[])
393 {
394     notmuch_database_t *notmuch;
395     struct sigaction action;
396     const char *db_path;
397     const char **new_tags;
398     size_t new_tags_length;
399     tag_op_list_t *tag_ops;
400     char *query_string = NULL;
401     const char *folder = NULL;
402     notmuch_bool_t create_folder = FALSE;
403     notmuch_bool_t synchronize_flags;
404     const char *maildir;
405     char *newpath;
406     int opt_index;
407     unsigned int i;
408
409     notmuch_opt_desc_t options[] = {
410         { NOTMUCH_OPT_STRING, &folder, "folder", 0, 0 },
411         { NOTMUCH_OPT_BOOLEAN, &create_folder, "create-folder", 0, 0 },
412         { NOTMUCH_OPT_END, 0, 0, 0, 0 }
413     };
414
415     opt_index = parse_arguments (argc, argv, options, 1);
416     if (opt_index < 0)
417         return EXIT_FAILURE;
418
419     db_path = notmuch_config_get_database_path (config);
420     new_tags = notmuch_config_get_new_tags (config, &new_tags_length);
421     synchronize_flags = notmuch_config_get_maildir_synchronize_flags (config);
422
423     tag_ops = tag_op_list_create (config);
424     if (tag_ops == NULL) {
425         fprintf (stderr, "Out of memory.\n");
426         return EXIT_FAILURE;
427     }
428     for (i = 0; i < new_tags_length; i++) {
429         const char *error_msg;
430
431         error_msg = illegal_tag (new_tags[i], FALSE);
432         if (error_msg) {
433             fprintf (stderr, "Error: tag '%s' in new.tags: %s\n",
434                      new_tags[i],  error_msg);
435             return EXIT_FAILURE;
436         }
437
438         if (tag_op_list_append (tag_ops, new_tags[i], FALSE))
439             return EXIT_FAILURE;
440     }
441
442     if (parse_tag_command_line (config, argc - opt_index, argv + opt_index,
443                                 &query_string, tag_ops))
444         return EXIT_FAILURE;
445
446     if (*query_string != '\0') {
447         fprintf (stderr, "Error: unexpected query string: %s\n", query_string);
448         return EXIT_FAILURE;
449     }
450
451     if (folder == NULL) {
452         maildir = db_path;
453     } else {
454         if (! is_valid_folder_name (folder)) {
455             fprintf (stderr, "Error: invalid folder name: '%s'\n", folder);
456             return EXIT_FAILURE;
457         }
458         maildir = talloc_asprintf (config, "%s/%s", db_path, folder);
459         if (! maildir) {
460             fprintf (stderr, "Out of memory\n");
461             return EXIT_FAILURE;
462         }
463         if (create_folder && ! maildir_create_folder (config, maildir))
464             return EXIT_FAILURE;
465     }
466
467     /* Setup our handler for SIGINT. We do not set SA_RESTART so that copying
468      * from standard input may be interrupted. */
469     memset (&action, 0, sizeof (struct sigaction));
470     action.sa_handler = handle_sigint;
471     sigemptyset (&action.sa_mask);
472     action.sa_flags = 0;
473     sigaction (SIGINT, &action, NULL);
474
475     if (notmuch_database_open (notmuch_config_get_database_path (config),
476                                NOTMUCH_DATABASE_MODE_READ_WRITE, &notmuch))
477         return EXIT_FAILURE;
478
479     /* Write the message to the Maildir new directory. */
480     if (! write_message (config, STDIN_FILENO, maildir, &newpath)) {
481         notmuch_database_destroy (notmuch);
482         return EXIT_FAILURE;
483     }
484
485     /* Add the message to the index.
486      * Even if adding the message to the notmuch database fails,
487      * the message is on disk and we consider the delivery completed. */
488     add_file_to_database (notmuch, newpath, tag_ops,
489                                     synchronize_flags);
490
491     notmuch_database_destroy (notmuch);
492     return EXIT_SUCCESS;
493 }