do_add_files_print_progress = 1;
}
+static volatile sig_atomic_t interrupted;
+
+static void
+handle_sigint (unused (int sig))
+{
+ static char msg[] = "Stopping... \n";
+ write(2, msg, sizeof(msg)-1);
+ interrupted = 1;
+}
+
static void
tag_inbox_and_unread (notmuch_message_t *message)
{
fflush (stdout);
}
+static int ino_cmp(const struct dirent **a, const struct dirent **b)
+{
+ return ((*a)->d_ino < (*b)->d_ino) ? -1 : 1;
+}
+
/* Examine 'path' recursively as follows:
*
* o Ask the filesystem for the mtime of 'path' (path_mtime)
static notmuch_status_t
add_files_recursive (notmuch_database_t *notmuch,
const char *path,
+ const char *tag,
struct stat *st,
add_files_state_t *state)
{
DIR *dir = NULL;
- struct dirent *e, *entry = NULL;
- int entry_length;
- int err;
+ struct dirent *entry = NULL;
char *next = NULL;
time_t path_mtime, path_dbtime;
notmuch_status_t status, ret = NOTMUCH_STATUS_SUCCESS;
notmuch_message_t *message = NULL;
+ struct dirent **namelist = NULL;
+ int num_entries;
/* If we're told to, we bail out on encountering a read-only
* directory, (with this being a clear clue from the user to
path_mtime = st->st_mtime;
path_dbtime = notmuch_database_get_timestamp (notmuch, path);
+ num_entries = scandir (path, &namelist, 0, ino_cmp);
- dir = opendir (path);
- if (dir == NULL) {
+ if (num_entries == -1) {
fprintf (stderr, "Error opening directory %s: %s\n",
path, strerror (errno));
ret = NOTMUCH_STATUS_FILE_ERROR;
goto DONE;
}
- entry_length = offsetof (struct dirent, d_name) +
- pathconf (path, _PC_NAME_MAX) + 1;
- entry = malloc (entry_length);
-
- while (1) {
- err = readdir_r (dir, entry, &e);
- if (err) {
- fprintf (stderr, "Error reading directory: %s\n",
- strerror (errno));
- ret = NOTMUCH_STATUS_FILE_ERROR;
- goto DONE;
- }
+ int i=0;
- if (e == NULL)
+ while (!interrupted) {
+ if (i == num_entries)
break;
+ entry= namelist[i++];
+
/* If this directory hasn't been modified since the last
* add_files, then we only need to look further for
* sub-directories. */
if (S_ISREG (st->st_mode)) {
/* If the file hasn't been modified since the last
* add_files, then we need not look at it. */
- if (st->st_mtime > path_dbtime) {
+ if (path_dbtime == 0 || st->st_mtime > path_dbtime) {
state->processed_files++;
status = notmuch_database_add_message (notmuch, next, &message);
case NOTMUCH_STATUS_SUCCESS:
state->added_messages++;
tag_inbox_and_unread (message);
+ notmuch_message_add_tag (message, tag);
break;
/* Non-fatal issues (go on to next file) */
case NOTMUCH_STATUS_DUPLICATE_MESSAGE_ID:
}
}
} else if (S_ISDIR (st->st_mode)) {
- status = add_files_recursive (notmuch, next, st, state);
+ if ((strcmp (entry->d_name, "cur") == 0) ||
+ (strcmp (entry->d_name, "new") == 0) ||
+ (strcmp (entry->d_name, "tmp") == 0)) {
+ status = add_files_recursive (notmuch, next, tag, st, state);
+ } else {
+ status = add_files_recursive (notmuch, next, entry->d_name, st, state);
+ }
if (status && ret == NOTMUCH_STATUS_SUCCESS)
ret = status;
}
free (entry);
if (dir)
closedir (dir);
+ if (namelist)
+ free (namelist);
return ret;
}
timerval.it_value.tv_usec = 0;
setitimer (ITIMER_REAL, &timerval, NULL);
- status = add_files_recursive (notmuch, path, &st, state);
+ status = add_files_recursive (notmuch, path, basename(path), &st, state);
/* Now stop the timer. */
timerval.it_interval.tv_sec = 0;
/* XXX: This should be merged with the add_files function since it
* shares a lot of logic with it. */
-/* Recursively count all regular files in path and all sub-direcotries
+/* Recursively count all regular files in path and all sub-directories
* of path. The result is added to *count (which should be
* initialized to zero by the top-level caller before calling
* count_files). */
static void
count_files (const char *path, int *count)
{
- DIR *dir;
- struct dirent *e, *entry = NULL;
- int entry_length;
- int err;
+ struct dirent *entry = NULL;
char *next;
struct stat st;
+ struct dirent **namelist = NULL;
+ int n_entries = scandir (path, &namelist, 0, ino_cmp);
+ int i = 0;
- dir = opendir (path);
-
- if (dir == NULL) {
+ if (n_entries == -1) {
fprintf (stderr, "Warning: failed to open directory %s: %s\n",
path, strerror (errno));
goto DONE;
}
- entry_length = offsetof (struct dirent, d_name) +
- pathconf (path, _PC_NAME_MAX) + 1;
- entry = malloc (entry_length);
-
- while (1) {
- err = readdir_r (dir, entry, &e);
- if (err) {
- fprintf (stderr, "Error reading directory: %s\n",
- strerror (errno));
- free (entry);
- goto DONE;
- }
-
- if (e == NULL)
+ while (!interrupted) {
+ if (i == n_entries)
break;
+ entry= namelist[i++];
+
/* Ignore special directories to avoid infinite recursion.
* Also ignore the .notmuch directory.
*/
DONE:
if (entry)
free (entry);
-
- closedir (dir);
+ if (namelist)
+ free (namelist);
}
int
struct stat st;
const char *db_path;
char *dot_notmuch_path;
- int new_database = 0;
+ struct sigaction action;
+
+ /* Setup our handler for SIGINT */
+ memset (&action, 0, sizeof (struct sigaction));
+ action.sa_handler = handle_sigint;
+ sigemptyset (&action.sa_mask);
+ action.sa_flags = SA_RESTART;
+ sigaction (SIGINT, &action, NULL);
config = notmuch_config_open (ctx, NULL, NULL);
if (config == NULL)
dot_notmuch_path = talloc_asprintf (ctx, "%s/%s", db_path, ".notmuch");
if (stat (dot_notmuch_path, &st)) {
- new_database = 1;
+ int count;
+
+ count = 0;
+ count_files (db_path, &count);
+ if (interrupted)
+ return 1;
+
+ printf ("Found %d total files. \n", count);
notmuch = notmuch_database_create (db_path);
+ add_files_state.ignore_read_only_directories = FALSE;
+ add_files_state.total_files = count;
} else {
notmuch = notmuch_database_open (db_path);
+ add_files_state.ignore_read_only_directories = TRUE;
+ add_files_state.total_files = 0;
}
if (notmuch == NULL)
talloc_free (dot_notmuch_path);
dot_notmuch_path = NULL;
- if (new_database) {
- int count;
- count_files (db_path, &count);
- add_files_state.ignore_read_only_directories = FALSE;
- add_files_state.total_files = count;
- } else {
- add_files_state.ignore_read_only_directories = TRUE;
- add_files_state.total_files = 0;
- }
-
add_files_state.saw_read_only_directory = FALSE;
- add_files_state.total_files = 0;
add_files_state.processed_files = 0;
add_files_state.added_messages = 0;
gettimeofday (&add_files_state.tv_start, NULL);
if (elapsed > 1 && ! add_files_state.saw_read_only_directory) {
printf ("\nTip: If you have any sub-directories that are archives (that is,\n"
- "they will never receive new mail), marking these directores as\n"
+ "they will never receive new mail), marking these directories as\n"
"read-only (chmod u-w /path/to/dir) will make \"notmuch new\"\n"
"much more efficient (it won't even look in those directories).\n");
}
notmuch_database_close (notmuch);
- return ret;
+ return ret || interrupted;
}
projects / notmuch / blobdiff