replace glob impl with fts

Author: Cryptkeeper

include/deng.h

@@ -11,7 +11,7 @@ struct index_s;
 /// @enum deng_notif_t
 /// @brief Notification events for the file search process
 enum deng_notif_t {
-  DENG_NOTIF_DIR_DONE,  ///< Occurs when a directory has been fully processed
+  DENG_NOTIF_FILE_FOUND,///< Occurs when a file will be processed
   DENG_NOTIF_STAGE_DONE,///< Occurs when a stage has been fully processed
 };
 

include/fs.h

@@ -3,44 +3,35 @@
 #ifndef FSAUTOPROC_FS_H
 #define FSAUTOPROC_FS_H
 
-#include <stdbool.h>
 #include <stdint.h>
 
+/// @struct fsstat_s
+/// @brief Stat structure for storing the last modified time and file size.
+struct fsstat_s {
+  uint64_t lmod;///< Last modified time in milliseconds since epoch
+  uint64_t fsze;///< File size in bytes
+};
+
 /// @typedef fswalkfn_t
 /// @brief Callback function used by `fswalk` to process files and directories.
 /// @param fp The file or directory path to process
+/// @param st File stat information
 /// @param udata User data passed to the callback function
 /// @return 0 if the walk should continue, otherwise a non-zero value to stop
-typedef int (*fswalkfn_t)(const char* fp, void* udata);
+typedef int (*fswalkfn_t)(const char* fp, const struct fsstat_s* st,
+                          void* udata);
 
 /// @brief Recursively walks the single directory described by \p dir and calls
-/// \p filefn for each file found and \p dirfn for each directory encountered.
+/// \p filefn for each file found.
 /// @param dir The directory to walk
 /// @param filefn The function to call for each file found. The filepath is
 /// passed as the first argument. If the function returns a non-zero value, the
 /// walk is terminated and the same value is returned by `fswalk`.
-/// @param dirfn The function to call for each directory found. The directory
-/// path is passed as the first argument. If the function returns a non-zero
-/// value, the walk is terminated and the same value is returned by `fswalk`.
 /// @param udata User data to pass to \p filefn and \p dirfn
 /// @return If successful, 0 is returned. An internal `fswalk` error will return
 /// a value of -1 and `errno` is set. Otherwise the return value of the first
 /// non-zero \p filefn or \p dirfn call is returned.
-int fswalk(const char* dir, fswalkfn_t filefn, fswalkfn_t dirfn, void* udata);
-
-/// @struct fsstat_s
-/// @brief Stat structure for storing the last modified time and file size.
-struct fsstat_s {
-  uint64_t lmod; ///< Last modified time in milliseconds since epoch
-  uint64_t fsze; ///< File size in bytes
-};
-
-/// @brief `fsstateql()` compares the fields of two `struct fsstat_s` values for
-/// equality. Two structs with the same values are considered equal.
-/// @param a The first `struct fsstat_s` to compare
-/// @param b The second `struct fsstat_s` to compare
-/// @return Returns true if the two `struct fsstat_s` values are equal.
-bool fsstateql(const struct fsstat_s* a, const struct fsstat_s* b);
+int fswalk(const char* dir, fswalkfn_t filefn, void* udata);
 
 /// @brief Populates all fields of a given \p fsstat_s structure for the file
 /// described by the filepath \p fp.

include/index.h

@@ -3,6 +3,7 @@
 #ifndef FSAUTOPROC_INDEX_H
 #define FSAUTOPROC_INDEX_H
 
+#include <stdint.h>
 #include <stdio.h>
 
 #include "fs.h"
@@ -80,7 +81,7 @@ int indexread(struct index_s* idx, FILE* s);
 /// @return The pointer to the new node in the index map, otherwise NULL is
 /// returned and `errno` is set.
 struct inode_s* indexput(struct index_s* idx, const char* fp, uint64_t fphash,
-                         struct fsstat_s st);
+                         const struct fsstat_s* st);
 
 /// @brief Frees all nodes in the index map.
 /// @param idx The index to free

src/deng.c

@@ -9,22 +9,12 @@
 
 #include "fs.h"
 #include "index.h"
-#include "je.h"
 #include "log.h"
 
-#define SL_OVERRIDE
-#define SLX_REALLOC je_realloc
-#define SLX_FREE je_free
-#define SLX_STRDUP je_strdup
-
-#define SL_IMPL
-#include "sl.h"
-
 /// @struct deng_state_s
 /// @brief Search state context provided to the diff engine as user data which
 /// is passed to the file event hook functions.
 struct deng_state_s {
-  slist_t dirqueue;                ///< Processing directory queue
   deng_filter_t ffn;               ///< File filter function
   const struct deng_hooks_s* hooks;///< File event hook functions
   const struct index_s* lastmap;   ///< Previous index state
@@ -54,14 +44,14 @@ struct deng_state_s {
 /// files are indexed. This function may trigger new (NEW), modified (MOD),
 /// and unmodified (NOP) events for each file in the directory tree.
 /// @param fp The file path to process
+/// @param st The file stat information
 /// @param udata The diff engine state context
 /// @return 0 if successful, otherwise a non-zero error code.
-static int stagepre(const char* fp, void* udata) {
+static int stagepre(const char* fp, const struct fsstat_s* st, void* udata) {
   struct deng_state_s* mach = (struct deng_state_s*) udata;
-  if (mach->ffn != NULL && mach->ffn(fp)) return 0;
+  notifyhook(mach, DENG_NOTIF_FILE_FOUND);
 
-  struct fsstat_s st = {0};
-  if (fsstat(fp, &st)) return -1;
+  if (mach->ffn != NULL && mach->ffn(fp)) return 0;// skip filtered files
 
   const uint64_t fphash = indexhash(fp);
 
@@ -74,9 +64,8 @@ static int stagepre(const char* fp, void* udata) {
     if ((curr = indexput(mach->thismap, fp, fphash, st)) == NULL) return -1;
 
   if (prev != NULL) {
-    if (!fsstateql(&prev->st, &curr->st)) {
+    if (prev->st.lmod != st->lmod || prev->st.fsze != st->fsze)
       callevent(mach, DENG_FEVENT_MOD, curr);
-    }
   } else {
     callevent(mach, DENG_FEVENT_NEW, curr);
   }
@@ -88,67 +77,44 @@ static int stagepre(const char* fp, void* udata) {
 /// files are indexed. This function may trigger new (NEW) and modified (MOD)
 /// events for each file in the directory tree.
 /// @param fp The file path to process
+/// @param st The file stat information
 /// @param udata The diff engine state context
 /// @return 0 if successful, otherwise a non-zero error code.
-static int stagepost(const char* fp, void* udata) {
+static int stagepost(const char* fp, const struct fsstat_s* st, void* udata) {
   struct deng_state_s* mach = (struct deng_state_s*) udata;
-  if (mach->ffn != NULL && mach->ffn(fp)) return 0;
+  notifyhook(mach, DENG_NOTIF_FILE_FOUND);
+
+  if (mach->ffn != NULL && mach->ffn(fp)) return 0;// skip filtered files
 
   const uint64_t fphash = indexhash(fp);
 
   struct inode_s* curr = indexfind(mach->thismap, fp, fphash);
   if (curr != NULL) {
-    // check if the file was modified during the command execution
-    struct fsstat_s mod = {0};
-    if (fsstat(fp, &mod)) return -1;
-    curr->st = mod;// update the file info in the current index
+    curr->st = *st;// update the file info in the current index
     return 0;
   }
 
-  struct fsstat_s st = {0};
-  if (fsstat(fp, &st)) return -1;
   if ((curr = indexput(mach->thismap, fp, fphash, st)) == NULL) return -1;
   callevent(mach, DENG_FEVENT_NEW, curr);
 
   return 0;
 }
 
-/// @brief Pushes a directory path onto the directory queue for processing.
-/// @param fp The directory path to push
-/// @param udata The diff engine state context
-/// @return 0 if successful, otherwise a non-zero error code.
-static int dqpush(const char* fp, void* udata) {
-  struct deng_state_s* mach = (struct deng_state_s*) udata;
-  int err;
-  if ((err = sladd(&mach->dirqueue, fp)))
-    log_error("error pushing directory `%s`", fp);
-  return err;
-}
-
-/// @brief Resets the directory queue to the initial search path, and invokes
-/// the `filefn` function for each file in the directory tree, recursively.
+/// @brief Walks the directory tree starting at \p sd and invokes the provided
+/// file function \p filefn for each file found. After the walk is complete,
+/// the stage done notification is triggered.
 /// @param mach The diff engine state context
 /// @param sd The initial search directory path
 /// @param filefn The function to invoke for each file in the directory tree
 /// @return 0 if successful, otherwise a non-zero error code.
 static int execstage(struct deng_state_s* mach, const char* sd,
                      fswalkfn_t filefn) {
-  slfree(&mach->dirqueue);
-  mach->dirqueue = (slist_t){0};
-  if (sladd(&mach->dirqueue, sd)) return -1;
-
-  char* dir;
-  while ((dir = slpop(&mach->dirqueue)) != NULL) {
-    int err;
-    if ((err = fswalk(dir, filefn, dqpush, (void*) mach))) {
-      log_error("file func for `%s` returned %d", dir, err);
-      return -1;
-    }
-    notifyhook(mach, DENG_NOTIF_DIR_DONE);
-    je_free(dir);
+  int err;
+  if ((err = fswalk(sd, filefn, (void*) mach))) {
+    log_error("file func for `%s` returned %d", sd, err);
+    return -1;
   }
   notifyhook(mach, DENG_NOTIF_STAGE_DONE);
-
   return 0;
 }
 
@@ -180,12 +146,11 @@ int dengsearch(const char* sd, deng_filter_t filter,
   assert(old != NULL);
   assert(new != NULL);
 
-  struct deng_state_s mach = {{0}, filter, hooks, old, new};
+  struct deng_state_s mach = {filter, hooks, old, new};
   int err;
   if ((err = execstage(&mach, sd, stagepre))) goto ret;
   if ((err = checkremoved(&mach))) goto ret;
   if ((err = execstage(&mach, sd, stagepost))) goto ret;
 ret:
-  slfree(&mach.dirqueue);
   return err;
 }

src/fs.c

@@ -3,7 +3,8 @@
 #include "fs.h"
 
 #include <assert.h>
-#include <glob.h>
+#include <errno.h>
+#include <fts.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/stat.h>
@@ -13,59 +14,51 @@
 
 #include "log.h"
 
-/// @brief Error callback implementation for glob search. Logs each error using
-/// the \p log_error macro.
-/// @param epath The path that caused the error.
-/// @param errno The error number.
-/// @return Always returns 0 to continue the glob scan.
-static int fswalkerr(const char* epath, const int errno) {
-  log_error("error accessing `%s`: %d", epath, errno);
-  return 0; /* continue glob scan */
-}
-
-int fswalk(const char* dir, fswalkfn_t filefn, fswalkfn_t dirfn, void* udata) {
-  char pattern[256]; /* glob pattern format buffer */
-  glob_t gres = {0}; /* glob search results */
-  int ret;           /* glob return value */
-
-  // ensure pattern has capacity for dir + wildcard suffix
-  assert(strlen(dir) < sizeof(pattern));
-  snprintf(pattern, sizeof(pattern), "%s/*", dir);
-
-  if ((ret = glob(pattern, GLOB_MARK | GLOB_TILDE, fswalkerr, &gres))) {
-    globfree(&gres);
-    if (ret == GLOB_NOMATCH) return 0;
-    return -1;
-  }
-
+/// @brief Internal helper function to process a single file entry from the FTS
+/// walk. The file's last modified time and size are extracted from the stat
+/// structure and passed to the user-defined callback function.
+/// @param ent The FTSENT file entry to process
+/// @param filefn The user-defined callback function to invoke for the file
+/// @param udata User data pointer to pass to the callback function
+/// @return The return value of the user-defined callback function
+static int fsprocent(FTSENT* ent, fswalkfn_t filefn, void* udata) {
 #if defined(__FreeBSD__) || defined(__APPLE__)
-  const int mc = gres.gl_matchc;
+  const struct timespec ts = ent->fts_statp->st_mtimespec; /* last modified */
 #else
-  const int mc = gres.gl_pathc;
+  const struct timespec ts = ent->fts_statp->st_mtim; /* last modified */
 #endif
+  struct fsstat_s st = {0};
+  st.lmod = ts.tv_sec * 1000 + ts.tv_nsec / 1000000; /* convert to millis */
+  st.fsze = ent->fts_statp->st_size;                 /* copy file size */
+  return filefn(ent->fts_path, &st, udata);
+}
 
-  // invoke process function for each result
+int fswalk(const char* dir, fswalkfn_t filefn, void* udata) {
+  char* const paths[] = {(char*) dir, NULL};
+  FTS* ftsp = fts_open(paths, FTS_LOGICAL, NULL);
+  if (ftsp == NULL) {
+    log_error("fts_open error on `%s`: %s", dir, strerror(errno));
+    return -1;
+  }
   int err = 0;
-  for (int i = 0; i < mc; i++) {
-    char* fp = gres.gl_pathv[i];
-    const size_t len = strlen(fp);
-    if (fp[len - 1] == '/') {// if directory, invoke directory function
-      fp[len - 1] = '\0';    // remove the trailing slash generated by GLOB_MARK
-      if ((err = dirfn(fp, udata))) goto doret;
-    } else if ((err = filefn(gres.gl_pathv[i], udata))) {
-      goto doret;
+  FTSENT* ent;
+  while ((ent = fts_read(ftsp)) != NULL) {
+    if (ent->fts_info == FTS_ERR) {// handle error entries
+      log_error("fts_read error on `%s`: %s", ent->fts_path,
+                strerror(ent->fts_errno));
+    } else if (ent->fts_info == FTS_F) {
+      if ((err = fsprocent(ent, filefn, udata))) goto doret;
     }
   }
-
+  if (errno) {// fts_read will set errno if an error occurred
+    log_error("fts_read error on `%s`: %s", dir, strerror(errno));
+    err = -1;
+  }
 doret:
-  globfree(&gres);
+  fts_close(ftsp);
   return err;
 }
 
-bool fsstateql(const struct fsstat_s* a, const struct fsstat_s* b) {
-  return a->lmod == b->lmod && a->fsze == b->fsze;
-}
-
 int fsstat(const char* fp, struct fsstat_s* s) {
   struct stat st = {0};
   if (stat(fp, &st)) return -1;

src/index.c

@@ -81,7 +81,7 @@ int indexread(struct index_s* idx, FILE* s) {
   while (fscanf(s, "%[^,],%" PRIu64 ",%" PRIu64 "\n", fp, &st.lmod, &st.fsze) ==
          3) {
     const uint64_t fphash = indexhash(fp);
-    if (indexput(idx, fp, fphash, st) == NULL) return -1;
+    if (indexput(idx, fp, fphash, &st) == NULL) return -1;
   }
   return 0;
 }
@@ -101,14 +101,14 @@ static void indexappend(struct ibucket_s* bucket, struct inode_s* node) {
 }
 
 struct inode_s* indexput(struct index_s* idx, const char* fp,
-                         const uint64_t fphash, const struct fsstat_s st) {
+                         const uint64_t fphash, const struct fsstat_s* st) {
   struct inode_s* node = je_malloc(sizeof(struct inode_s));
   if (node == NULL) return NULL;
   if ((fp = je_strdup(fp)) == NULL) {// duplicate filepath string
     je_free(node);
     return NULL;
   }
-  *node = (struct inode_s) {(char*) fp, fphash, st, NULL};
+  *node = (struct inode_s) {(char*) fp, fphash, *st, NULL};
   struct ibucket_s* bucket = &idx->buckets[indexbucket(node->fphash)];
   indexappend(bucket, node);
   idx->size++;

src/lcmd.c

@@ -18,9 +18,16 @@
 #include "fd.h"
 #include "je.h"
 #include "log.h"
-#include "sl.h"
 #include "tm.h"
 
+#define SL_OVERRIDE
+#define SLX_REALLOC je_realloc
+#define SLX_FREE je_free
+#define SLX_STRDUP je_strdup
+
+#define SL_IMPL
+#include "sl.h"
+
 /// @brief Frees the memory allocated for a single command set entry struct.
 /// @param cmd Command set entry to free
 static void lcmdfree(struct lcmdset_s* cmd) {

src/main.c

@@ -251,7 +251,8 @@ static bool filterjunk(const char* fp) {
   if (junk) {
     if (initargs.verbose) log_info("[j] %s", fp);
   } else {
-    indexput(&goodmap, fp, fphash, (struct fsstat_s) {0});// mark as known good
+    const struct fsstat_s st = {0};
+    indexput(&goodmap, fp, fphash, &st);// mark as known good
   }
   return junk;
 }
@@ -263,7 +264,7 @@ static bool filterjunk(const char* fp) {
 /// @param notif The notification type
 static void onnotify(const enum deng_notif_t notif) {
   switch (notif) {
-    case DENG_NOTIF_DIR_DONE:
+    case DENG_NOTIF_FILE_FOUND:
       printprogbar(thismap.size, lastmap.size);
       break;
     case DENG_NOTIF_STAGE_DONE: