* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
- * along with this program. If not, see http://www.gnu.org/licenses/ .
+ * along with this program. If not, see https://www.gnu.org/licenses/ .
*
* Author: Peter Wang <novalazy@gmail.com>
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
+#include "string-util.h"
static volatile sig_atomic_t interrupted;
}
/* Call fsync() on a directory path. */
-static notmuch_bool_t
+static bool
sync_dir (const char *dir)
{
- notmuch_bool_t ret;
- int fd;
+ int fd, r;
fd = open (dir, O_RDONLY);
if (fd == -1) {
- fprintf (stderr, "Error: open() dir failed: %s\n", strerror (errno));
- return FALSE;
- }
- ret = (fsync (fd) == 0);
- if (! ret) {
- fprintf (stderr, "Error: fsync() dir failed: %s\n", strerror (errno));
+ fprintf (stderr, "Error: open %s: %s\n", dir, strerror (errno));
+ return false;
}
+
+ r = fsync (fd);
+ if (r)
+ fprintf (stderr, "Error: fsync %s: %s\n", dir, strerror (errno));
+
close (fd);
- return ret;
+
+ return r == 0;
}
/*
* Check the specified folder name does not contain a directory
* component ".." to prevent writes outside of the Maildir
- * hierarchy. Return TRUE on valid folder name, FALSE otherwise.
+ * hierarchy. Return true on valid folder name, false otherwise.
*/
-static notmuch_bool_t
+static bool
is_valid_folder_name (const char *folder)
{
const char *p = folder;
for (;;) {
if ((p[0] == '.') && (p[1] == '.') && (p[2] == '\0' || p[2] == '/'))
- return FALSE;
+ return false;
p = strchr (p, '/');
if (!p)
- return TRUE;
+ return true;
p++;
}
}
-/* Make the given directory, succeeding if it already exists. */
-static notmuch_bool_t
-make_directory (char *path, int mode)
+/*
+ * Make the given directory and its parents as necessary, using the
+ * given mode. Return true on success, false otherwise. Partial
+ * results are not cleaned up on errors.
+ */
+static bool
+mkdir_recursive (const void *ctx, const char *path, int mode)
{
- notmuch_bool_t ret;
- char *slash;
+ struct stat st;
+ int r;
+ char *parent = NULL, *slash;
- if (mkdir (path, mode) != 0)
- return (errno == EEXIST);
+ /* First check the common case: directory already exists. */
+ r = stat (path, &st);
+ if (r == 0) {
+ if (! S_ISDIR (st.st_mode)) {
+ fprintf (stderr, "Error: '%s' is not a directory: %s\n",
+ path, strerror (EEXIST));
+ return false;
+ }
- /* Sync the parent directory for durability. */
- ret = TRUE;
- slash = strrchr (path, '/');
- if (slash) {
- *slash = '\0';
- ret = sync_dir (path);
- *slash = '/';
+ return true;
+ } else if (errno != ENOENT) {
+ fprintf (stderr, "Error: stat '%s': %s\n", path, strerror (errno));
+ return false;
}
- return ret;
-}
-
-/* Make the given directory including its parent directories as necessary.
- * Return TRUE on success, FALSE on error. */
-static notmuch_bool_t
-make_directory_and_parents (char *path, int mode)
-{
- struct stat st;
- char *start;
- char *end;
- notmuch_bool_t ret;
- /* First check the common case: directory already exists. */
- if (stat (path, &st) == 0)
- return S_ISDIR (st.st_mode) ? TRUE : FALSE;
-
- for (start = path; *start != '\0'; start = end + 1) {
- /* start points to the first unprocessed character.
- * Find the next slash from start onwards. */
- end = strchr (start, '/');
-
- /* If there are no more slashes then all the parent directories
- * have been made. Now attempt to make the whole path. */
- if (end == NULL)
- return make_directory (path, mode);
-
- /* Make the path up to the next slash, unless the current
- * directory component is actually empty. */
- if (end > start) {
- *end = '\0';
- ret = make_directory (path, mode);
- *end = '/';
- if (! ret)
- return FALSE;
+ /* mkdir parents, if any */
+ slash = strrchr (path, '/');
+ if (slash && slash != path) {
+ parent = talloc_strndup (ctx, path, slash - path);
+ if (! parent) {
+ fprintf (stderr, "Error: %s\n", strerror (ENOMEM));
+ return false;
}
+
+ if (! mkdir_recursive (ctx, parent, mode))
+ return false;
+ }
+
+ if (mkdir (path, mode)) {
+ fprintf (stderr, "Error: mkdir '%s': %s\n", path, strerror (errno));
+ return false;
}
- return TRUE;
+ return parent ? sync_dir (parent) : true;
}
-/* Create the given maildir folder, i.e. dir and its subdirectories
- * 'cur', 'new', 'tmp'. */
-static notmuch_bool_t
-maildir_create_folder (void *ctx, const char *dir)
+/*
+ * Create the given maildir folder, i.e. maildir and its
+ * subdirectories cur/new/tmp. Return true on success, false
+ * otherwise. Partial results are not cleaned up on errors.
+ */
+static bool
+maildir_create_folder (const void *ctx, const char *maildir)
{
+ const char *subdirs[] = { "cur", "new", "tmp" };
const int mode = 0700;
char *subdir;
- char *tail;
-
- /* Create 'cur' directory, including parent directories. */
- subdir = talloc_asprintf (ctx, "%s/cur", dir);
- if (! subdir) {
- fprintf (stderr, "Out of memory.\n");
- return FALSE;
- }
- if (! make_directory_and_parents (subdir, mode))
- return FALSE;
-
- tail = subdir + strlen (subdir) - 3;
+ unsigned int i;
- /* Create 'new' directory. */
- strcpy (tail, "new");
- if (! make_directory (subdir, mode))
- return FALSE;
+ for (i = 0; i < ARRAY_SIZE (subdirs); i++) {
+ subdir = talloc_asprintf (ctx, "%s/%s", maildir, subdirs[i]);
+ if (! subdir) {
+ fprintf (stderr, "Error: %s\n", strerror (ENOMEM));
+ return false;
+ }
- /* Create 'tmp' directory. */
- strcpy (tail, "tmp");
- if (! make_directory (subdir, mode))
- return FALSE;
+ if (! mkdir_recursive (ctx, subdir, mode))
+ return false;
+ }
- talloc_free (subdir);
- return TRUE;
+ return true;
}
-/* Open a unique file in the 'tmp' sub-directory of dir.
- * Returns the file descriptor on success, or -1 on failure.
- * On success, file paths for the message in the 'tmp' and 'new'
- * directories are returned via tmppath and newpath,
- * and the path of the 'new' directory itself in newdir. */
-static int
-maildir_open_tmp_file (void *ctx, const char *dir,
- char **tmppath, char **newpath, char **newdir)
+/*
+ * Generate a temporary file basename, no path, do not create an
+ * actual file. Return the basename, or NULL on errors.
+ */
+static char *
+tempfilename (const void *ctx)
{
- pid_t pid;
+ char *filename;
char hostname[256];
struct timeval tv;
- char *filename;
- int fd = -1;
+ pid_t pid;
/* We follow the Dovecot file name generation algorithm. */
pid = getpid ();
safe_gethostname (hostname, sizeof (hostname));
+ gettimeofday (&tv, NULL);
+
+ filename = talloc_asprintf (ctx, "%ld.M%ldP%d.%s",
+ (long) tv.tv_sec, (long) tv.tv_usec, pid, hostname);
+ if (! filename)
+ fprintf (stderr, "Error: %s\n", strerror (ENOMEM));
+
+ return filename;
+}
+
+/*
+ * Create a unique temporary file in maildir/tmp, return fd and full
+ * path to file in *path_out, or -1 on errors (in which case *path_out
+ * is not touched).
+ */
+static int
+maildir_mktemp (const void *ctx, const char *maildir, char **path_out)
+{
+ char *filename, *path;
+ int fd;
+
do {
- gettimeofday (&tv, NULL);
- filename = talloc_asprintf (ctx, "%ld.M%ldP%d.%s",
- tv.tv_sec, tv.tv_usec, pid, hostname);
- if (! filename) {
- fprintf (stderr, "Out of memory\n");
+ filename = tempfilename (ctx);
+ if (! filename)
return -1;
- }
- *tmppath = talloc_asprintf (ctx, "%s/tmp/%s", dir, filename);
- if (! *tmppath) {
- fprintf (stderr, "Out of memory\n");
+ path = talloc_asprintf (ctx, "%s/tmp/%s", maildir, filename);
+ if (! path) {
+ fprintf (stderr, "Error: %s\n", strerror (ENOMEM));
return -1;
}
- fd = open (*tmppath, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, 0600);
+ fd = open (path, O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, 0600);
} while (fd == -1 && errno == EEXIST);
if (fd == -1) {
- fprintf (stderr, "Error: opening %s: %s\n", *tmppath, strerror (errno));
+ fprintf (stderr, "Error: open '%s': %s\n", path, strerror (errno));
return -1;
}
- *newdir = talloc_asprintf (ctx, "%s/new", dir);
- *newpath = talloc_asprintf (ctx, "%s/new/%s", dir, filename);
- if (! *newdir || ! *newpath) {
- fprintf (stderr, "Out of memory\n");
- close (fd);
- unlink (*tmppath);
- return -1;
- }
-
- talloc_free (filename);
+ *path_out = path;
return fd;
}
/*
- * Copy fdin to fdout, return TRUE on success, and FALSE on errors and
+ * Copy fdin to fdout, return true on success, and false on errors and
* empty input.
*/
-static notmuch_bool_t
+static bool
copy_fd (int fdout, int fdin)
{
- notmuch_bool_t empty = TRUE;
+ bool empty = true;
while (! interrupted) {
ssize_t remain;
continue;
fprintf (stderr, "Error: reading from standard input: %s\n",
strerror (errno));
- return FALSE;
+ return false;
}
p = buf;
if (written <= 0) {
fprintf (stderr, "Error: writing to temporary file: %s",
strerror (errno));
- return FALSE;
+ return false;
}
p += written;
remain -= written;
- empty = FALSE;
+ empty = false;
} while (remain > 0);
}
return (!interrupted && !empty);
}
-static notmuch_bool_t
-write_message (void *ctx, int fdin, const char *dir, char **newpath)
+/*
+ * Write fdin to a new temp file in maildir/tmp, return full path to
+ * the file, or NULL on errors.
+ */
+static char *
+maildir_write_tmp (const void *ctx, int fdin, const char *maildir)
{
- char *tmppath;
- char *newdir;
- char *cleanup_path;
+ char *path;
int fdout;
- fdout = maildir_open_tmp_file (ctx, dir, &tmppath, newpath, &newdir);
+ fdout = maildir_mktemp (ctx, maildir, &path);
if (fdout < 0)
- return FALSE;
-
- cleanup_path = tmppath;
+ return NULL;
if (! copy_fd (fdout, fdin))
goto FAIL;
- if (fsync (fdout) != 0) {
- fprintf (stderr, "Error: fsync failed: %s\n", strerror (errno));
+ if (fsync (fdout)) {
+ fprintf (stderr, "Error: fsync '%s': %s\n", path, strerror (errno));
goto FAIL;
}
close (fdout);
- fdout = -1;
-
- /* Atomically move the new message file from the Maildir 'tmp' directory
- * to the 'new' directory. We follow the Dovecot recommendation to
- * simply use rename() instead of link() and unlink().
- * See also: http://wiki.dovecot.org/MailboxFormat/Maildir#Mail_delivery
- */
- if (rename (tmppath, *newpath) != 0) {
- fprintf (stderr, "Error: rename() failed: %s\n", strerror (errno));
+
+ return path;
+
+FAIL:
+ close (fdout);
+ unlink (path);
+
+ return NULL;
+}
+
+/*
+ * Write fdin to a new file in maildir/new, using an intermediate temp
+ * file in maildir/tmp, return full path to the new file, or NULL on
+ * errors.
+ */
+static char *
+maildir_write_new (const void *ctx, int fdin, const char *maildir)
+{
+ char *cleanpath, *tmppath, *newpath, *newdir;
+
+ tmppath = maildir_write_tmp (ctx, fdin, maildir);
+ if (! tmppath)
+ return NULL;
+ cleanpath = tmppath;
+
+ newpath = talloc_strdup (ctx, tmppath);
+ if (! newpath) {
+ fprintf (stderr, "Error: %s\n", strerror (ENOMEM));
goto FAIL;
}
- cleanup_path = *newpath;
+ /* sanity checks needed? */
+ memcpy (newpath + strlen (maildir) + 1, "new", 3);
+
+ if (rename (tmppath, newpath)) {
+ fprintf (stderr, "Error: rename '%s' '%s': %s\n",
+ tmppath, newpath, strerror (errno));
+ goto FAIL;
+ }
+ cleanpath = newpath;
+
+ newdir = talloc_asprintf (ctx, "%s/%s", maildir, "new");
+ if (! newdir) {
+ fprintf (stderr, "Error: %s\n", strerror (ENOMEM));
+ goto FAIL;
+ }
if (! sync_dir (newdir))
goto FAIL;
- return TRUE;
+ return newpath;
- FAIL:
- if (fdout >= 0)
- close (fdout);
- unlink (cleanup_path);
- return FALSE;
+FAIL:
+ unlink (cleanpath);
+
+ return NULL;
}
-/* Add the specified message file to the notmuch database, applying tags.
- * The file is renamed to encode notmuch tags as maildir flags. */
-static void
-add_file_to_database (notmuch_database_t *notmuch, const char *path,
- tag_op_list_t *tag_ops, notmuch_bool_t synchronize_flags)
+/*
+ * Add the specified message file to the notmuch database, applying
+ * tags in tag_ops. If synchronize_flags is true, the tags are
+ * synchronized to maildir flags (which may result in message file
+ * rename).
+ *
+ * Return NOTMUCH_STATUS_SUCCESS on success, errors otherwise. If keep
+ * is true, errors in tag changes and flag syncing are ignored and
+ * success status is returned; otherwise such errors cause the message
+ * to be removed from the database. Failure to add the message to the
+ * database results in error status regardless of keep.
+ */
+static notmuch_status_t
+add_file (notmuch_database_t *notmuch, const char *path, tag_op_list_t *tag_ops,
+ bool synchronize_flags, bool keep,
+ notmuch_indexopts_t *indexopts)
{
notmuch_message_t *message;
notmuch_status_t status;
- status = notmuch_database_add_message (notmuch, path, &message);
- switch (status) {
- case NOTMUCH_STATUS_SUCCESS:
- case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
- break;
- default:
- case NOTMUCH_STATUS_FILE_NOT_EMAIL:
- case NOTMUCH_STATUS_READ_ONLY_DATABASE:
- case NOTMUCH_STATUS_XAPIAN_EXCEPTION:
- case NOTMUCH_STATUS_OUT_OF_MEMORY:
- case NOTMUCH_STATUS_FILE_ERROR:
- case NOTMUCH_STATUS_NULL_POINTER:
- case NOTMUCH_STATUS_TAG_TOO_LONG:
- case NOTMUCH_STATUS_UNBALANCED_FREEZE_THAW:
- case NOTMUCH_STATUS_UNBALANCED_ATOMIC:
- case NOTMUCH_STATUS_LAST_STATUS:
- fprintf (stderr, "Error: failed to add `%s' to notmuch database: %s\n",
- path, notmuch_status_to_string (status));
- return;
- }
-
- if (status == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) {
- /* Don't change tags of an existing message. */
- if (synchronize_flags) {
- status = notmuch_message_tags_to_maildir_flags (message);
- if (status != NOTMUCH_STATUS_SUCCESS)
- fprintf (stderr, "Error: failed to sync tags to maildir flags\n");
+ status = notmuch_database_index_file (notmuch, path, indexopts, &message);
+ if (status == NOTMUCH_STATUS_SUCCESS) {
+ status = tag_op_list_apply (message, tag_ops, 0);
+ if (status) {
+ fprintf (stderr, "%s: failed to apply tags to file '%s': %s\n",
+ keep ? "Warning" : "Error",
+ path, notmuch_status_to_string (status));
+ goto DONE;
}
+ } else if (status == NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) {
+ status = NOTMUCH_STATUS_SUCCESS;
+ } else if (status == NOTMUCH_STATUS_FILE_NOT_EMAIL) {
+ fprintf (stderr, "Error: delivery of non-mail file: '%s'\n", path);
+ goto FAIL;
} else {
- tag_op_flag_t flags = synchronize_flags ? TAG_FLAG_MAILDIR_SYNC : 0;
+ fprintf (stderr, "Error: failed to add '%s' to notmuch database: %s\n",
+ path, notmuch_status_to_string (status));
+ goto FAIL;
+ }
- tag_op_list_apply (message, tag_ops, flags);
+ if (synchronize_flags) {
+ status = notmuch_message_tags_to_maildir_flags (message);
+ if (status != NOTMUCH_STATUS_SUCCESS)
+ fprintf (stderr, "%s: failed to sync tags to maildir flags for '%s': %s\n",
+ keep ? "Warning" : "Error",
+ path, notmuch_status_to_string (status));
+
+ /*
+ * Note: Unfortunately a failed maildir flag sync might
+ * already have renamed the file, in which case the cleanup
+ * path may fail.
+ */
}
+ DONE:
notmuch_message_destroy (message);
+
+ if (status) {
+ if (keep) {
+ status = NOTMUCH_STATUS_SUCCESS;
+ } else {
+ notmuch_status_t cleanup_status;
+
+ cleanup_status = notmuch_database_remove_message (notmuch, path);
+ if (cleanup_status != NOTMUCH_STATUS_SUCCESS &&
+ cleanup_status != NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID) {
+ fprintf (stderr, "Warning: failed to remove '%s' from database "
+ "after errors: %s. Please run 'notmuch new' to fix.\n",
+ path, notmuch_status_to_string (cleanup_status));
+ }
+ }
+ }
+
+ FAIL:
+ return status;
}
int
notmuch_insert_command (notmuch_config_t *config, int argc, char *argv[])
{
+ notmuch_status_t status, close_status;
notmuch_database_t *notmuch;
struct sigaction action;
const char *db_path;
size_t new_tags_length;
tag_op_list_t *tag_ops;
char *query_string = NULL;
- const char *folder = NULL;
- notmuch_bool_t create_folder = FALSE;
- notmuch_bool_t synchronize_flags;
- const char *maildir;
+ const char *folder = "";
+ bool create_folder = false;
+ bool keep = false;
+ bool hooks = true;
+ bool synchronize_flags;
+ char *maildir;
char *newpath;
int opt_index;
unsigned int i;
notmuch_opt_desc_t options[] = {
- { NOTMUCH_OPT_STRING, &folder, "folder", 0, 0 },
- { NOTMUCH_OPT_BOOLEAN, &create_folder, "create-folder", 0, 0 },
- { NOTMUCH_OPT_END, 0, 0, 0, 0 }
+ { .opt_string = &folder, .name = "folder", .allow_empty = true },
+ { .opt_bool = &create_folder, .name = "create-folder" },
+ { .opt_bool = &keep, .name = "keep" },
+ { .opt_bool = &hooks, .name = "hooks" },
+ { .opt_inherit = notmuch_shared_indexing_options },
+ { .opt_inherit = notmuch_shared_options },
+ { }
};
opt_index = parse_arguments (argc, argv, options, 1);
if (opt_index < 0)
return EXIT_FAILURE;
+ notmuch_process_shared_options (argv[0]);
+
db_path = notmuch_config_get_database_path (config);
new_tags = notmuch_config_get_new_tags (config, &new_tags_length);
synchronize_flags = notmuch_config_get_maildir_synchronize_flags (config);
for (i = 0; i < new_tags_length; i++) {
const char *error_msg;
- error_msg = illegal_tag (new_tags[i], FALSE);
+ error_msg = illegal_tag (new_tags[i], false);
if (error_msg) {
fprintf (stderr, "Error: tag '%s' in new.tags: %s\n",
new_tags[i], error_msg);
return EXIT_FAILURE;
}
- if (tag_op_list_append (tag_ops, new_tags[i], FALSE))
+ if (tag_op_list_append (tag_ops, new_tags[i], false))
return EXIT_FAILURE;
}
return EXIT_FAILURE;
}
- if (folder == NULL) {
- maildir = db_path;
- } else {
- if (! is_valid_folder_name (folder)) {
- fprintf (stderr, "Error: invalid folder name: '%s'\n", folder);
- return EXIT_FAILURE;
- }
- maildir = talloc_asprintf (config, "%s/%s", db_path, folder);
- if (! maildir) {
- fprintf (stderr, "Out of memory\n");
- return EXIT_FAILURE;
- }
- if (create_folder && ! maildir_create_folder (config, maildir)) {
- fprintf (stderr, "Error: creating maildir %s: %s\n",
- maildir, strerror (errno));
- return EXIT_FAILURE;
- }
+ if (! is_valid_folder_name (folder)) {
+ fprintf (stderr, "Error: invalid folder name: '%s'\n", folder);
+ return EXIT_FAILURE;
+ }
+
+ maildir = talloc_asprintf (config, "%s/%s", db_path, folder);
+ if (! maildir) {
+ fprintf (stderr, "Out of memory\n");
+ return EXIT_FAILURE;
}
- /* Setup our handler for SIGINT. We do not set SA_RESTART so that copying
+ strip_trailing (maildir, '/');
+ if (create_folder && ! maildir_create_folder (config, maildir))
+ return EXIT_FAILURE;
+
+ /* Set up our handler for SIGINT. We do not set SA_RESTART so that copying
* from standard input may be interrupted. */
memset (&action, 0, sizeof (struct sigaction));
action.sa_handler = handle_sigint;
action.sa_flags = 0;
sigaction (SIGINT, &action, NULL);
- if (notmuch_database_open (notmuch_config_get_database_path (config),
- NOTMUCH_DATABASE_MODE_READ_WRITE, ¬much))
+ /* Write the message to the Maildir new directory. */
+ newpath = maildir_write_new (config, STDIN_FILENO, maildir);
+ if (! newpath) {
return EXIT_FAILURE;
+ }
- /* Write the message to the Maildir new directory. */
- if (! write_message (config, STDIN_FILENO, maildir, &newpath)) {
- notmuch_database_destroy (notmuch);
+ status = notmuch_database_open (notmuch_config_get_database_path (config),
+ NOTMUCH_DATABASE_MODE_READ_WRITE, ¬much);
+ if (status)
+ return keep ? NOTMUCH_STATUS_SUCCESS : status_to_exit (status);
+
+ notmuch_exit_if_unmatched_db_uuid (notmuch);
+
+ status = notmuch_process_shared_indexing_options (notmuch, config);
+ if (status != NOTMUCH_STATUS_SUCCESS) {
+ fprintf (stderr, "Error: Failed to process index options. (%s)\n",
+ notmuch_status_to_string (status));
return EXIT_FAILURE;
}
- /* Add the message to the index.
- * Even if adding the message to the notmuch database fails,
- * the message is on disk and we consider the delivery completed. */
- add_file_to_database (notmuch, newpath, tag_ops,
- synchronize_flags);
+ /* Index the message. */
+ status = add_file (notmuch, newpath, tag_ops, synchronize_flags, keep, indexing_cli_choices.opts);
+
+ /* Commit changes. */
+ close_status = notmuch_database_destroy (notmuch);
+ if (close_status) {
+ /* Hold on to the first error, if any. */
+ if (! status)
+ status = close_status;
+ fprintf (stderr, "%s: failed to commit database changes: %s\n",
+ keep ? "Warning" : "Error",
+ notmuch_status_to_string (close_status));
+ }
+
+ if (status) {
+ if (keep) {
+ status = NOTMUCH_STATUS_SUCCESS;
+ } else {
+ /* If maildir flag sync failed, this might fail. */
+ if (unlink (newpath)) {
+ fprintf (stderr, "Warning: failed to remove '%s' from maildir "
+ "after errors: %s. Please run 'notmuch new' to fix.\n",
+ newpath, strerror (errno));
+ }
+ }
+ }
+
+ if (hooks && status == NOTMUCH_STATUS_SUCCESS) {
+ /* Ignore hook failures. */
+ notmuch_run_hook (db_path, "post-insert");
+ }
- notmuch_database_destroy (notmuch);
- return EXIT_SUCCESS;
+ return status_to_exit (status);
}