typedef struct {
int output_is_a_tty;
int verbose;
+ const char **new_tags;
+ size_t new_tags_length;
int total_files;
int processed_files;
_filename_list_t *removed_files;
_filename_list_t *removed_directories;
+
+ notmuch_bool_t synchronize_flags;
+ _filename_list_t *message_ids_to_sync;
} add_files_state_t;
static volatile sig_atomic_t do_add_files_print_progress = 0;
list->tail = &node->next;
}
-static void
-tag_inbox_and_unread (notmuch_message_t *message)
-{
- notmuch_message_add_tag (message, "inbox");
- notmuch_message_add_tag (message, "unread");
-}
-
static void
add_files_print_progress (add_files_state_t *state)
{
int i, found = 0;
for (i = 0; i < count; i++) {
- if (entries[i]->d_type != DT_DIR)
+ if (entries[i]->d_type != DT_DIR && entries[i]->d_type != DT_UNKNOWN)
continue;
if (strcmp(entries[i]->d_name, "new") == 0 ||
notmuch_filenames_t *db_subdirs = NULL;
struct stat st;
notmuch_bool_t is_maildir, new_directory;
+ const char **tag;
if (stat (path, &st)) {
fprintf (stderr, "Error reading directory %s: %s\n",
entry = fs_entries[i];
- if (entry->d_type != DT_DIR && entry->d_type != DT_LNK)
+ /* We only want to descend into directories.
+ * But symlinks can be to directories too, of course.
+ *
+ * And if the filesystem doesn't tell us the file type in the
+ * scandir results, then it might be a directory (and if not,
+ * then we'll stat and return immediately in the next level of
+ * recursion). */
+ if (entry->d_type != DT_DIR &&
+ entry->d_type != DT_LNK &&
+ entry->d_type != DT_UNKNOWN)
+ {
continue;
+ }
/* Ignore special directories to avoid infinite recursion.
* Also ignore the .notmuch directory and any "tmp" directory
next = NULL;
}
- /* If this directory hasn't been modified since the last
- * "notmuch new", then we can skip the second pass entirely. */
- if (fs_mtime <= db_mtime)
+ /* If the directory's modification time in the filesystem is the
+ * same as what we recorded in the database the last time we
+ * scanned it, then we can skip the second pass entirely.
+ *
+ * We test for strict equality here to avoid a bug that can happen
+ * if the system clock jumps backward, (preventing new mail from
+ * being discovered until the clock catches up and the directory
+ * is modified again).
+ */
+ if (fs_mtime == db_mtime)
goto DONE;
/* Pass 2: Scan for new files, removed files, and removed directories. */
/* Check if we've walked past any names in db_files or
* db_subdirs. If so, these have been deleted. */
- while (notmuch_filenames_has_more (db_files) &&
+ while (notmuch_filenames_valid (db_files) &&
strcmp (notmuch_filenames_get (db_files), entry->d_name) < 0)
{
char *absolute = talloc_asprintf (state->removed_files,
_filename_list_add (state->removed_files, absolute);
- notmuch_filenames_advance (db_files);
+ notmuch_filenames_move_to_next (db_files);
}
- while (notmuch_filenames_has_more (db_subdirs) &&
+ while (notmuch_filenames_valid (db_subdirs) &&
strcmp (notmuch_filenames_get (db_subdirs), entry->d_name) <= 0)
{
const char *filename = notmuch_filenames_get (db_subdirs);
_filename_list_add (state->removed_directories, absolute);
}
- notmuch_filenames_advance (db_subdirs);
+ notmuch_filenames_move_to_next (db_subdirs);
}
/* If we're looking at a symlink, we only want to add it if it
- * links to a regular file, (and not to a directory, say). */
- if (entry->d_type == DT_LNK) {
+ * links to a regular file, (and not to a directory, say).
+ *
+ * Similarly, if the file is of unknown type (due to filesytem
+ * limitations), then we also need to look closer.
+ *
+ * In either case, a stat does the trick.
+ */
+ if (entry->d_type == DT_LNK || entry->d_type == DT_UNKNOWN) {
int err;
next = talloc_asprintf (notmuch, "%s/%s", path, entry->d_name);
}
/* Don't add a file that we've added before. */
- if (notmuch_filenames_has_more (db_files) &&
+ if (notmuch_filenames_valid (db_files) &&
strcmp (notmuch_filenames_get (db_files), entry->d_name) == 0)
{
- notmuch_filenames_advance (db_files);
+ notmuch_filenames_move_to_next (db_files);
continue;
}
/* success */
case NOTMUCH_STATUS_SUCCESS:
state->added_messages++;
- tag_inbox_and_unread (message);
+ notmuch_message_freeze (message);
+ for (tag=state->new_tags; *tag != NULL; tag++)
+ notmuch_message_add_tag (message, *tag);
+ if (state->synchronize_flags == TRUE)
+ notmuch_message_maildir_flags_to_tags (message);
+ notmuch_message_thaw (message);
break;
/* Non-fatal issues (go on to next file) */
case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
- /* Stay silent on this one. */
+ /* Defer sync of maildir flags until after old filenames
+ * are removed in the case of a rename. */
+ if (state->synchronize_flags == TRUE)
+ _filename_list_add (state->message_ids_to_sync,
+ notmuch_message_get_message_id (message));
break;
case NOTMUCH_STATUS_FILE_NOT_EMAIL:
fprintf (stderr, "Note: Ignoring non-mail file: %s\n",
next = NULL;
}
+ if (interrupted)
+ goto DONE;
+
/* Now that we've walked the whole filesystem list, anything left
* over in the database lists has been deleted. */
- while (notmuch_filenames_has_more (db_files))
+ while (notmuch_filenames_valid (db_files))
{
char *absolute = talloc_asprintf (state->removed_files,
"%s/%s", path,
_filename_list_add (state->removed_files, absolute);
- notmuch_filenames_advance (db_files);
+ notmuch_filenames_move_to_next (db_files);
}
- while (notmuch_filenames_has_more (db_subdirs))
+ while (notmuch_filenames_valid (db_subdirs))
{
char *absolute = talloc_asprintf (state->removed_directories,
"%s/%s", path,
_filename_list_add (state->removed_directories, absolute);
- notmuch_filenames_advance (db_subdirs);
+ notmuch_filenames_move_to_next (db_subdirs);
}
if (! interrupted) {
directory = notmuch_database_get_directory (notmuch, path);
for (files = notmuch_directory_get_child_files (directory);
- notmuch_filenames_has_more (files);
- notmuch_filenames_advance (files))
+ notmuch_filenames_valid (files);
+ notmuch_filenames_move_to_next (files))
{
absolute = talloc_asprintf (ctx, "%s/%s", path,
notmuch_filenames_get (files));
}
for (subdirs = notmuch_directory_get_child_directories (directory);
- notmuch_filenames_has_more (subdirs);
- notmuch_filenames_advance (subdirs))
+ notmuch_filenames_valid (subdirs);
+ notmuch_filenames_move_to_next (subdirs))
{
absolute = talloc_asprintf (ctx, "%s/%s", path,
notmuch_filenames_get (subdirs));
if (config == NULL)
return 1;
+ add_files_state.new_tags = notmuch_config_get_new_tags (config, &add_files_state.new_tags_length);
+ add_files_state.synchronize_flags = notmuch_config_get_maildir_synchronize_flags (config);
+ add_files_state.message_ids_to_sync = _filename_list_create (ctx);
db_path = notmuch_config_get_database_path (config);
dot_notmuch_path = talloc_asprintf (ctx, "%s/%s", db_path, ".notmuch");
talloc_free (add_files_state.removed_files);
talloc_free (add_files_state.removed_directories);
+ /* Now that removals are done (hence the database is aware of all
+ * renames), we can synchronize maildir_flags to tags for all
+ * messages that had new filenames appear on this run. */
+ if (add_files_state.synchronize_flags) {
+ _filename_node_t *node;
+ notmuch_message_t *message;
+ for (node = add_files_state.message_ids_to_sync->head;
+ node;
+ node = node->next)
+ {
+ message = notmuch_database_find_message (notmuch, node->filename);
+ notmuch_message_maildir_flags_to_tags (message);
+ notmuch_message_destroy (message);
+ }
+ }
+
+ talloc_free (add_files_state.message_ids_to_sync);
+ add_files_state.message_ids_to_sync = NULL;
+
gettimeofday (&tv_now, NULL);
elapsed = notmuch_time_elapsed (add_files_state.tv_start,
tv_now);
projects / notmuch / blobdiff