cli/insert: rename file copy function
[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     notmuch_bool_t ret;
71     int fd;
72
73     fd = open (dir, O_RDONLY);
74     if (fd == -1) {
75         fprintf (stderr, "Error: open() dir failed: %s\n", strerror (errno));
76         return FALSE;
77     }
78     ret = (fsync (fd) == 0);
79     if (! ret) {
80         fprintf (stderr, "Error: fsync() dir failed: %s\n", strerror (errno));
81     }
82     close (fd);
83     return ret;
84 }
85
86 /*
87  * Check the specified folder name does not contain a directory
88  * component ".." to prevent writes outside of the Maildir
89  * hierarchy. Return TRUE on valid folder name, FALSE otherwise.
90  */
91 static notmuch_bool_t
92 is_valid_folder_name (const char *folder)
93 {
94     const char *p = folder;
95
96     for (;;) {
97         if ((p[0] == '.') && (p[1] == '.') && (p[2] == '\0' || p[2] == '/'))
98             return FALSE;
99         p = strchr (p, '/');
100         if (!p)
101             return TRUE;
102         p++;
103     }
104 }
105
106 /* Make the given directory, succeeding if it already exists. */
107 static notmuch_bool_t
108 make_directory (char *path, int mode)
109 {
110     notmuch_bool_t ret;
111     char *slash;
112
113     if (mkdir (path, mode) != 0)
114         return (errno == EEXIST);
115
116     /* Sync the parent directory for durability. */
117     ret = TRUE;
118     slash = strrchr (path, '/');
119     if (slash) {
120         *slash = '\0';
121         ret = sync_dir (path);
122         *slash = '/';
123     }
124     return ret;
125 }
126
127 /* Make the given directory including its parent directories as necessary.
128  * Return TRUE on success, FALSE on error. */
129 static notmuch_bool_t
130 make_directory_and_parents (char *path, int mode)
131 {
132     struct stat st;
133     char *start;
134     char *end;
135     notmuch_bool_t ret;
136
137     /* First check the common case: directory already exists. */
138     if (stat (path, &st) == 0)
139         return S_ISDIR (st.st_mode) ? TRUE : FALSE;
140
141     for (start = path; *start != '\0'; start = end + 1) {
142         /* start points to the first unprocessed character.
143          * Find the next slash from start onwards. */
144         end = strchr (start, '/');
145
146         /* If there are no more slashes then all the parent directories
147          * have been made.  Now attempt to make the whole path. */
148         if (end == NULL)
149             return make_directory (path, mode);
150
151         /* Make the path up to the next slash, unless the current
152          * directory component is actually empty. */
153         if (end > start) {
154             *end = '\0';
155             ret = make_directory (path, mode);
156             *end = '/';
157             if (! ret)
158                 return FALSE;
159         }
160     }
161
162     return TRUE;
163 }
164
165 /* Create the given maildir folder, i.e. dir and its subdirectories
166  * 'cur', 'new', 'tmp'. */
167 static notmuch_bool_t
168 maildir_create_folder (void *ctx, const char *dir)
169 {
170     const int mode = 0700;
171     char *subdir;
172     char *tail;
173
174     /* Create 'cur' directory, including parent directories. */
175     subdir = talloc_asprintf (ctx, "%s/cur", dir);
176     if (! subdir) {
177         fprintf (stderr, "Out of memory.\n");
178         return FALSE;
179     }
180     if (! make_directory_and_parents (subdir, mode))
181         return FALSE;
182
183     tail = subdir + strlen (subdir) - 3;
184
185     /* Create 'new' directory. */
186     strcpy (tail, "new");
187     if (! make_directory (subdir, mode))
188         return FALSE;
189
190     /* Create 'tmp' directory. */
191     strcpy (tail, "tmp");
192     if (! make_directory (subdir, mode))
193         return FALSE;
194
195     talloc_free (subdir);
196     return TRUE;
197 }
198
199 /* Open a unique file in the 'tmp' sub-directory of dir.
200  * Returns the file descriptor on success, or -1 on failure.
201  * On success, file paths for the message in the 'tmp' and 'new'
202  * directories are returned via tmppath and newpath,
203  * and the path of the 'new' directory itself in newdir. */
204 static int
205 maildir_open_tmp_file (void *ctx, const char *dir,
206                        char **tmppath, char **newpath, char **newdir)
207 {
208     pid_t pid;
209     char hostname[256];
210     struct timeval tv;
211     char *filename;
212     int fd = -1;
213
214     /* We follow the Dovecot file name generation algorithm. */
215     pid = getpid ();
216     safe_gethostname (hostname, sizeof (hostname));
217     do {
218         gettimeofday (&tv, NULL);
219         filename = talloc_asprintf (ctx, "%ld.M%ldP%d.%s",
220                                     tv.tv_sec, tv.tv_usec, pid, hostname);
221         if (! filename) {
222             fprintf (stderr, "Out of memory\n");
223             return -1;
224         }
225
226         *tmppath = talloc_asprintf (ctx, "%s/tmp/%s", dir, filename);
227         if (! *tmppath) {
228             fprintf (stderr, "Out of memory\n");
229             return -1;
230         }
231
232         fd = open (*tmppath, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, 0600);
233     } while (fd == -1 && errno == EEXIST);
234
235     if (fd == -1) {
236         fprintf (stderr, "Error: opening %s: %s\n", *tmppath, strerror (errno));
237         return -1;
238     }
239
240     *newdir = talloc_asprintf (ctx, "%s/new", dir);
241     *newpath = talloc_asprintf (ctx, "%s/new/%s", dir, filename);
242     if (! *newdir || ! *newpath) {
243         fprintf (stderr, "Out of memory\n");
244         close (fd);
245         unlink (*tmppath);
246         return -1;
247     }
248
249     talloc_free (filename);
250
251     return fd;
252 }
253
254 /*
255  * Copy fdin to fdout, return TRUE on success, and FALSE on errors and
256  * empty input.
257  */
258 static notmuch_bool_t
259 copy_fd (int fdout, int fdin)
260 {
261     notmuch_bool_t empty = TRUE;
262
263     while (! interrupted) {
264         ssize_t remain;
265         char buf[4096];
266         char *p;
267
268         remain = read (fdin, buf, sizeof (buf));
269         if (remain == 0)
270             break;
271         if (remain < 0) {
272             if (errno == EINTR)
273                 continue;
274             fprintf (stderr, "Error: reading from standard input: %s\n",
275                      strerror (errno));
276             return FALSE;
277         }
278
279         p = buf;
280         do {
281             ssize_t written = write (fdout, p, remain);
282             if (written < 0 && errno == EINTR)
283                 continue;
284             if (written <= 0) {
285                 fprintf (stderr, "Error: writing to temporary file: %s",
286                          strerror (errno));
287                 return FALSE;
288             }
289             p += written;
290             remain -= written;
291             empty = FALSE;
292         } while (remain > 0);
293     }
294
295     return (!interrupted && !empty);
296 }
297
298 static notmuch_bool_t
299 write_message (void *ctx, int fdin, const char *dir, char **newpath)
300 {
301     char *tmppath;
302     char *newdir;
303     char *cleanup_path;
304     int fdout;
305
306     fdout = maildir_open_tmp_file (ctx, dir, &tmppath, newpath, &newdir);
307     if (fdout < 0)
308         return FALSE;
309
310     cleanup_path = tmppath;
311
312     if (! copy_fd (fdout, fdin))
313         goto FAIL;
314
315     if (fsync (fdout) != 0) {
316         fprintf (stderr, "Error: fsync failed: %s\n", strerror (errno));
317         goto FAIL;
318     }
319
320     close (fdout);
321     fdout = -1;
322
323     /* Atomically move the new message file from the Maildir 'tmp' directory
324      * to the 'new' directory.  We follow the Dovecot recommendation to
325      * simply use rename() instead of link() and unlink().
326      * See also: http://wiki.dovecot.org/MailboxFormat/Maildir#Mail_delivery
327      */
328     if (rename (tmppath, *newpath) != 0) {
329         fprintf (stderr, "Error: rename() failed: %s\n", strerror (errno));
330         goto FAIL;
331     }
332
333     cleanup_path = *newpath;
334
335     if (! sync_dir (newdir))
336         goto FAIL;
337
338     return TRUE;
339
340   FAIL:
341     if (fdout >= 0)
342         close (fdout);
343     unlink (cleanup_path);
344     return FALSE;
345 }
346
347 /* Add the specified message file to the notmuch database, applying tags.
348  * The file is renamed to encode notmuch tags as maildir flags. */
349 static void
350 add_file_to_database (notmuch_database_t *notmuch, const char *path,
351                       tag_op_list_t *tag_ops, notmuch_bool_t synchronize_flags)
352 {
353     notmuch_message_t *message;
354     notmuch_status_t status;
355
356     status = notmuch_database_add_message (notmuch, path, &message);
357     switch (status) {
358     case NOTMUCH_STATUS_SUCCESS:
359     case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
360         break;
361     default:
362     case NOTMUCH_STATUS_FILE_NOT_EMAIL:
363     case NOTMUCH_STATUS_READ_ONLY_DATABASE:
364     case NOTMUCH_STATUS_XAPIAN_EXCEPTION:
365     case NOTMUCH_STATUS_OUT_OF_MEMORY:
366     case NOTMUCH_STATUS_FILE_ERROR:
367     case NOTMUCH_STATUS_NULL_POINTER:
368     case NOTMUCH_STATUS_TAG_TOO_LONG:
369     case NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW:
370     case NOTMUCH_STATUS_UNBALANCED_ATOMIC:
371     case NOTMUCH_STATUS_LAST_STATUS:
372         fprintf (stderr, "Error: failed to add `%s' to notmuch database: %s\n",
373                  path, notmuch_status_to_string (status));
374         return;
375     }
376
377     if (status == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) {
378         /* Don't change tags of an existing message. */
379         if (synchronize_flags) {
380             status = notmuch_message_tags_to_maildir_flags (message);
381             if (status != NOTMUCH_STATUS_SUCCESS)
382                 fprintf (stderr, "Error: failed to sync tags to maildir flags\n");
383         }
384     } else {
385         tag_op_flag_t flags = synchronize_flags ? TAG_FLAG_MAILDIR_SYNC : 0;
386
387         tag_op_list_apply (message, tag_ops, flags);
388     }
389
390     notmuch_message_destroy (message);
391 }
392
393 int
394 notmuch_insert_command (notmuch_config_t *config, int argc, char *argv[])
395 {
396     notmuch_database_t *notmuch;
397     struct sigaction action;
398     const char *db_path;
399     const char **new_tags;
400     size_t new_tags_length;
401     tag_op_list_t *tag_ops;
402     char *query_string = NULL;
403     const char *folder = NULL;
404     notmuch_bool_t create_folder = FALSE;
405     notmuch_bool_t synchronize_flags;
406     const char *maildir;
407     char *newpath;
408     int opt_index;
409     unsigned int i;
410
411     notmuch_opt_desc_t options[] = {
412         { NOTMUCH_OPT_STRING, &folder, "folder", 0, 0 },
413         { NOTMUCH_OPT_BOOLEAN, &create_folder, "create-folder", 0, 0 },
414         { NOTMUCH_OPT_END, 0, 0, 0, 0 }
415     };
416
417     opt_index = parse_arguments (argc, argv, options, 1);
418     if (opt_index < 0)
419         return EXIT_FAILURE;
420
421     db_path = notmuch_config_get_database_path (config);
422     new_tags = notmuch_config_get_new_tags (config, &new_tags_length);
423     synchronize_flags = notmuch_config_get_maildir_synchronize_flags (config);
424
425     tag_ops = tag_op_list_create (config);
426     if (tag_ops == NULL) {
427         fprintf (stderr, "Out of memory.\n");
428         return EXIT_FAILURE;
429     }
430     for (i = 0; i < new_tags_length; i++) {
431         const char *error_msg;
432
433         error_msg = illegal_tag (new_tags[i], FALSE);
434         if (error_msg) {
435             fprintf (stderr, "Error: tag '%s' in new.tags: %s\n",
436                      new_tags[i],  error_msg);
437             return EXIT_FAILURE;
438         }
439
440         if (tag_op_list_append (tag_ops, new_tags[i], FALSE))
441             return EXIT_FAILURE;
442     }
443
444     if (parse_tag_command_line (config, argc - opt_index, argv + opt_index,
445                                 &query_string, tag_ops))
446         return EXIT_FAILURE;
447
448     if (*query_string != '\0') {
449         fprintf (stderr, "Error: unexpected query string: %s\n", query_string);
450         return EXIT_FAILURE;
451     }
452
453     if (folder == NULL) {
454         maildir = db_path;
455     } else {
456         if (! is_valid_folder_name (folder)) {
457             fprintf (stderr, "Error: invalid folder name: '%s'\n", folder);
458             return EXIT_FAILURE;
459         }
460         maildir = talloc_asprintf (config, "%s/%s", db_path, folder);
461         if (! maildir) {
462             fprintf (stderr, "Out of memory\n");
463             return EXIT_FAILURE;
464         }
465         if (create_folder && ! maildir_create_folder (config, maildir)) {
466             fprintf (stderr, "Error: creating maildir %s: %s\n",
467                      maildir, strerror (errno));
468             return EXIT_FAILURE;
469         }
470     }
471
472     /* Setup our handler for SIGINT. We do not set SA_RESTART so that copying
473      * from standard input may be interrupted. */
474     memset (&action, 0, sizeof (struct sigaction));
475     action.sa_handler = handle_sigint;
476     sigemptyset (&action.sa_mask);
477     action.sa_flags = 0;
478     sigaction (SIGINT, &action, NULL);
479
480     if (notmuch_database_open (notmuch_config_get_database_path (config),
481                                NOTMUCH_DATABASE_MODE_READ_WRITE, &notmuch))
482         return EXIT_FAILURE;
483
484     /* Write the message to the Maildir new directory. */
485     if (! write_message (config, STDIN_FILENO, maildir, &newpath)) {
486         notmuch_database_destroy (notmuch);
487         return EXIT_FAILURE;
488     }
489
490     /* Add the message to the index.
491      * Even if adding the message to the notmuch database fails,
492      * the message is on disk and we consider the delivery completed. */
493     add_file_to_database (notmuch, newpath, tag_ops,
494                                     synchronize_flags);
495
496     notmuch_database_destroy (notmuch);
497     return EXIT_SUCCESS;
498 }