Added the -v option in the help and the man page.
[finddup.git] / finddup.c
index 8f2b6c9..b1a8474 100644 (file)
--- a/finddup.c
+++ b/finddup.c
@@ -23,7 +23,7 @@
  *
  */
 
-#define VERSION_NUMBER "0.9"
+#define VERSION_NUMBER "1.1"
 
 #define _BSD_SOURCE
 
@@ -71,6 +71,9 @@ int same_inodes_are_different = 0; /* 1 means that comparison between
                                       two files with same inode will
                                       always be false */
 
+int sort_by_time = 0; /* 1 means to sort files in each group according
+                         to the modification time */
+
 /********************************************************************/
 
 /* malloc with error checking.  */
@@ -78,7 +81,8 @@ int same_inodes_are_different = 0; /* 1 means that comparison between
 void *safe_malloc(size_t n) {
   void *p = malloc(n);
   if (!p && n != 0) {
-    printf("Can not allocate memory: %s\n", strerror(errno));
+    fprintf(stderr,
+            "finddup: Can not allocate memory: %s\n", strerror(errno));
     exit(EXIT_FAILURE);
   }
   return p;
@@ -99,6 +103,7 @@ struct file_node {
   struct file_node *next;
   char *name;
   size_t size;
+  time_t atime, mtime, ctime;
   ino_t inode;
   int group_id; /* one per identical file content */
   int dir_id; /* 1 for DIR1, and 2 for DIR2 */
@@ -158,7 +163,7 @@ int same_content(struct file_node *f1, struct file_node *f2,
         }
       } else {
         fprintf(stderr,
-                "Different read size without error on files of same size.\n");
+                "finddup: Different read size without error on files of same size.\n");
         exit(EXIT_FAILURE);
       }
     }
@@ -166,14 +171,14 @@ int same_content(struct file_node *f1, struct file_node *f2,
 
     if(fd1 < 0) {
       fprintf(stderr,
-              "Can not open \"%s\" error: %s\n",
+              "finddup: Can not open \"%s\" error: %s\n",
               f1->name,
               strerror(errno));
     }
 
     if(fd2 < 0) {
       fprintf(stderr,
-              "Can not open \"%s\" error: %s\n",
+              "finddup: Can not open \"%s\" error: %s\n",
               f2->name,
               strerror(errno));
     }
@@ -193,7 +198,7 @@ int same_files(struct file_node *f1, struct file_node *f2,
 
 /**********************************************************************/
 
-struct file_node *scan_directory(struct file_node *tail, const char *name) {
+struct file_node *scan_directory_rec(struct file_node *tail, const char *name) {
   DIR *dir;
   struct dirent *dir_e;
   struct stat sb;
@@ -201,7 +206,7 @@ struct file_node *scan_directory(struct file_node *tail, const char *name) {
   char subname[PATH_MAX + 1];
 
   if(lstat(name, &sb) != 0) {
-    fprintf(stderr, "Can not stat \"%s\": %s\n", name, strerror(errno));
+    fprintf(stderr, "finddup: Can not stat \"%s\": %s\n", name, strerror(errno));
     exit(EXIT_FAILURE);
   }
 
@@ -215,7 +220,7 @@ struct file_node *scan_directory(struct file_node *tail, const char *name) {
     while((dir_e = readdir(dir))) {
       if(!ignore_entry(dir_e->d_name)) {
         snprintf(subname, PATH_MAX, "%s/%s", name, dir_e->d_name);
-        tail = scan_directory(tail, subname);
+        tail = scan_directory_rec(tail, subname);
       }
     }
     closedir(dir);
@@ -227,6 +232,9 @@ struct file_node *scan_directory(struct file_node *tail, const char *name) {
           tmp->next = tail;
           tmp->name = strdup(name);
           tmp->size = sb.st_size;
+          tmp->atime = sb.st_atime;
+          tmp->mtime = sb.st_mtime;
+          tmp->ctime = sb.st_ctime;
           tmp->inode = sb.st_ino;
           tmp->group_id = -1;
           tmp->dir_id = -1;
@@ -239,6 +247,26 @@ struct file_node *scan_directory(struct file_node *tail, const char *name) {
   return tail;
 }
 
+struct file_node *scan_directory(struct file_node *tail, const char *name) {
+  struct file_node *result;
+  int length;
+
+  if(show_progress) {
+    fprintf(stderr, "Scanning '%s' ... ", name);
+  }
+
+  result = scan_directory_rec(tail, name);
+  length = file_list_length(result);
+
+  if(show_progress) {
+    fprintf(stderr, "done (%d file%s).\n",
+            length, (length > 1 ? "s" : ""));
+  }
+
+
+  return result;
+}
+
 void print_file(struct file_node *node) {
   char tmp[PATH_MAX + 1];
   if(show_realpaths) {
@@ -249,9 +277,10 @@ void print_file(struct file_node *node) {
         printf("%s\n", tmp);
       }
     } else {
-      printf("Can not get the realpath of \"%s\": %s\n",
-             node->name,
-             strerror(errno));
+      fprintf(stderr,
+              "finddup: Can not get the realpath of \"%s\": %s\n",
+              node->name,
+              strerror(errno));
       exit(EXIT_FAILURE);
     }
   } else {
@@ -274,12 +303,22 @@ int compare_nodes(const void *x1, const void *x2) {
   } else if((*f1)->group_id > (*f2)->group_id) {
     return 1;
   } else {
-    if((*f1)->dir_id < (*f2)->dir_id) {
-      return -1;
-    } else if((*f1)->dir_id > (*f2)->dir_id) {
-      return 1;
+    if(sort_by_time) {
+      if((*f1)->mtime < (*f2)->mtime) {
+        return -1;
+      } else if((*f1)->mtime > (*f2)->mtime) {
+        return 1;
+      } else {
+        return 0;
+      }
     } else {
-      return 0;
+      if((*f1)->dir_id < (*f2)->dir_id) {
+        return -1;
+      } else if((*f1)->dir_id > (*f2)->dir_id) {
+        return 1;
+      } else {
+        return 0;
+      }
     }
   }
 }
@@ -337,15 +376,17 @@ struct progress_state {
 };
 
 void print_progress(struct progress_state *state) {
-  int position, k;
+  int position, k, normalizer;
   struct winsize win;
   char buffer[PROGRESS_BUFFER_SIZE];
   char *s;
 
+  normalizer = (state->nb_values > 1 ? state->nb_values - 1 : 1);
+
   if(show_progress) {
     /* We use the previous bar_width to compute the position, so that
        we avoid doing too many ioctls */
-    position = (state->bar_width * state->value) / (state->nb_values - 1);
+    position = (state->bar_width * state->value) / normalizer;
     if(state->bar_width <= 0 || position != state->last_position) {
       if(!ioctl (STDERR_FILENO, TIOCGWINSZ, (char *) &win)) {
         /* Something weird is going on if the previous test is wrong */
@@ -354,7 +395,7 @@ void print_progress(struct progress_state *state) {
         } else {
           state->bar_width = win.ws_col - 7;
         }
-        position = (state->bar_width * state->value) / (state->nb_values - 1);
+        position = (state->bar_width * state->value) / normalizer;
         state->last_position = position;
         s = buffer;
         for(k = 0; k < position; k++) {
@@ -366,7 +407,7 @@ void print_progress(struct progress_state *state) {
 
         /* We need four % because of the fprintf that follows */
         sprintf(s, " [%3d%%%%]\r",
-                (100 * state->value) / (state->nb_values - 1));
+                (100 * state->value) / normalizer);
 
         fprintf(stderr, buffer);
       }
@@ -380,26 +421,16 @@ void start(const char *dirname1, const char *dirname2) {
   struct progress_state progress_state;
   int not_in, found;
   int nb_groups, nb_nodes;
-  int list1_length, list2_length, previous_progress;
+  int list1_length, previous_progress;
 
   char *buffer1 = safe_malloc(sizeof(char) * READ_BUFFER_SIZE);
   char *buffer2 = safe_malloc(sizeof(char) * READ_BUFFER_SIZE);
 
   not_in = 0;
 
-  if(show_progress) {
-    fprintf(stderr, "Scanning '%s' ... ", dirname1);
-  }
-
   list1 = scan_directory(0, dirname1);
-
   list1_length = file_list_length(list1);
 
-  if(show_progress) {
-    fprintf(stderr, "done (%d file%s).\n",
-            list1_length, (list1_length > 1 ? "s" : ""));
-  }
-
   if(dirname2) {
     if(strncmp(dirname2, "not:", 4) == 0) {
       not_in = 1;
@@ -409,21 +440,14 @@ void start(const char *dirname1, const char *dirname2) {
     } else if(strncmp(dirname2, "and:", 4) == 0) {
       dirname2 += 4;
     }
-    if(show_progress) {
-      fprintf(stderr, "Scanning '%s' ... ", dirname2);
-    }
     list2 = scan_directory(0, dirname2);
-    if(show_progress) {
-      list2_length = file_list_length(list2);
-      fprintf(stderr, "done (%d file%s).\n",
-              list2_length, (list2_length > 1 ? "s" : ""));
-    }
   } else {
     list2 = list1;
   }
 
   if(show_progress) {
-    fprintf(stderr, "Now looking for identical files (this may take a while).\n");
+    fprintf(stderr,
+            "Now looking for identical files (this may take a while).\n");
   }
 
   nb_groups = 0;
@@ -503,17 +527,19 @@ void start(const char *dirname1, const char *dirname2) {
 }
 
 void usage(FILE *out) {
-  fprintf(out, "Usage: finddup [OPTION]... DIR1 [[and:|not:]DIR2]\n");
+  fprintf(out, "Usage: finddup [OPTION]... [DIR1 [[and:|not:]DIR2]]\n");
   fprintf(out, "Version %s (%s)\n", VERSION_NUMBER, UNAME);
-  fprintf(out, "Without DIR2, lists duplicated files found in DIR1. With DIR2, lists files common to both directories. With the not: prefix, lists files found in DIR1 which do not exist in DIR2. The and: prefix is the default and should be used only if you have a directory starting with 'not:'\n");
+  fprintf(out, "Without DIR2, lists duplicated files found in DIR1, or the current directory if DIR1 is not provided. With DIR2, lists files common to both directories. With the not: prefix, lists files found in DIR1 which do not exist in DIR2. The and: prefix is the default and should be used only if you have a directory starting with 'not:'\n");
   fprintf(out, "\n");
   /*            01234567890123456789012345678901234567890123456789012345678901234567890123456789*/
+  fprintf(out, "   -v, --version              prints the version number and exit\n");
   fprintf(out, "   -h, --help                 show this help\n");
   fprintf(out, "   -d, --ignore-dots          ignore dot files and directories\n");
   fprintf(out, "   -0, --ignore-empty         ignore empty files\n");
   fprintf(out, "   -c, --hide-matchings       do not show which files in DIR2 corresponds to\n");
   fprintf(out, "                              those in DIR1\n");
   fprintf(out, "   -g, --no-group-ids         do not show the file groups\n");
+  fprintf(out, "   -t, --time-sort            sort according to modification time in each group\n");
   fprintf(out, "   -p, --show-progress        show progress\n");
   fprintf(out, "   -r, --real-paths           show the real file paths\n");
   fprintf(out, "   -i, --same-inodes-are-different\n");
@@ -525,11 +551,13 @@ void usage(FILE *out) {
 /**********************************************************************/
 
 static struct option long_options[] = {
+  { "version", no_argument, 0, 'v' },
   { "help", no_argument, 0, 'h' },
   { "same-inodes-are-different", no_argument, 0, 'i' },
   { "real-paths", no_argument, 0, 'r' },
   { "hide-matchings", no_argument, 0, 'c' },
   { "no-group-ids", no_argument, 0, 'g' },
+  { "time-sort", no_argument, 0, 't' },
   { "ignore-dots", no_argument, 0, 'd' },
   { "ignore-empty", no_argument, 0, '0' },
   { "show-progress", no_argument, 0, 'p' },
@@ -541,10 +569,15 @@ int main(int argc, char **argv) {
 
   setlocale (LC_ALL, "");
 
-  while ((c = getopt_long(argc, argv, "hircgd0pm",
+  while ((c = getopt_long(argc, argv, "vhircgtd0pm",
                           long_options, NULL)) != -1) {
     switch (c) {
 
+    case 'v':
+      printf("finddup version %s (%s)\n", VERSION_NUMBER, UNAME);
+      exit(EXIT_SUCCESS);
+      break;
+
     case 'h':
       usage(stdout);
       exit(EXIT_SUCCESS);
@@ -571,6 +604,10 @@ int main(int argc, char **argv) {
       show_groups = 0;
       break;
 
+    case 't':
+      sort_by_time = 1;
+      break;
+
     case 'p':
       show_progress = 1;
       break;
@@ -594,6 +631,9 @@ int main(int argc, char **argv) {
   } else if(optind + 1 == argc) {
     same_inodes_are_different = 1;
     start(argv[optind], 0);
+  } else if(optind == argc) {
+    same_inodes_are_different = 1;
+    start(".", 0);
   } else {
     usage(stderr);
     exit(EXIT_FAILURE);