X-Git-Url: https://www.fleuret.org/cgi-bin/gitweb/gitweb.cgi?a=blobdiff_plain;f=finddup.c;h=9c713218902404e68789020a5ef2b6c25ab3cfd8;hb=f7bb05fb425e5ff6f1e9105cd36309786963825d;hp=e36c22981a3839c3fe9cb2bd78c624667a79622d;hpb=b3d9bdba7605297c793d4aefdfa240a9da240ad5;p=finddup.git

diff --git a/finddup.c b/finddup.c
index e36c229..9c71321 100644
--- a/finddup.c
+++ b/finddup.c
@@ -1,8 +1,8 @@
 
 /*
- *  finddup is a simple utility find duplicated files, files common to
- *  several directories, or files present in one directory and not in
- *  another one.
+ *  finddup is a simple utility to find duplicated files, files common
+ *  to several directories, or files present in one directory and not
+ *  in another one.
  *
  *  Copyright (c) 2010 Francois Fleuret
  *  Written by Francois Fleuret <francois@fleuret.org>
@@ -23,7 +23,7 @@
  *
  */
 
-#define VERSION_NUMBER "0.6"
+#define VERSION_NUMBER "0.7"
 
 #define _BSD_SOURCE
 
@@ -41,7 +41,8 @@
 #include <getopt.h>
 #include <fcntl.h>
 
-#define BUFFER_SIZE 4096
+/* 1M really helps compared to 64k */
+#define READ_BUFFER_SIZE (1024 * 1024)
 
 typedef int64_t size_sum_t;
 
@@ -50,6 +51,8 @@ typedef int64_t size_sum_t;
 int ignore_dotfiles = 0; /* 1 means ignore files and directories
                             starting with a dot */
 
+int ignore_empty_files = 0; /* 1 means ignore empty files */
+
 int show_realpaths = 0; /* 1 means ignore files and directories
                             starting with a dot */
 
@@ -62,6 +65,12 @@ int show_hits = 1; /* 1 means to show the files from dir2
 int show_groups = 1; /* 1 means to show the group IDs when printing
                         file names */
 
+int ignore_same_inode = 0; /* 1 means that comparison between two file
+                              with same inode will always be false */
+
+int tty_width = -1; /* Positive value means what width to use to show
+                       the progress bar */
+
 /********************************************************************/
 
 /* malloc with error checking.  */
@@ -84,21 +93,6 @@ int ignore_entry(const char *name) {
     (ignore_dotfiles && name[0] == '.');
 }
 
-void print_size_sum(size_sum_t s) {
-  char tmp[100];
-  char *a = tmp + sizeof(tmp)/sizeof(char);
-  *(--a) = '\0';
-  if(s) {
-    while(s) {
-      *(--a) = s%10 + '0';
-      s /= 10;
-    }
-  } else {
-    *(--a) = '0';
-  }
-  printf(a);
-}
-
 /**********************************************************************/
 
 struct file_with_size {
@@ -106,7 +100,7 @@ struct file_with_size {
   size_t size;
   ino_t inode;
   struct file_with_size *next;
-  int group_id;
+  int group_id, dir_id;
 };
 
 void file_list_delete(struct file_with_size *head) {
@@ -130,17 +124,17 @@ int file_list_length(struct file_with_size *head) {
 
 /**********************************************************************/
 
-int same_content(struct file_with_size *f1, struct file_with_size *f2) {
+int same_content(struct file_with_size *f1, struct file_with_size *f2,
+                 char *buffer1, char *buffer2) {
   int fd1, fd2, s1, s2;
-  char buffer1[BUFFER_SIZE], buffer2[BUFFER_SIZE];
 
   fd1 = open(f1->filename, O_RDONLY);
   fd2 = open(f2->filename, O_RDONLY);
 
   if(fd1 >= 0 && fd2 >= 0) {
     while(1) {
-      s1 = read(fd1, buffer1, BUFFER_SIZE);
-      s2 = read(fd2, buffer2, BUFFER_SIZE);
+      s1 = read(fd1, buffer1, READ_BUFFER_SIZE);
+      s2 = read(fd2, buffer2, READ_BUFFER_SIZE);
 
       if(s1 < 0 || s2 < 0) {
         close(fd1);
@@ -154,7 +148,7 @@ int same_content(struct file_with_size *f1, struct file_with_size *f2) {
           close(fd2);
           return 1;
         } else {
-          if(strncmp(buffer1, buffer2, s1)) {
+          if(memcmp(buffer1, buffer2, s1)) {
             close(fd1);
             close(fd2);
             return 0;
@@ -185,8 +179,12 @@ int same_content(struct file_with_size *f1, struct file_with_size *f2) {
   }
 }
 
-int same_files(struct file_with_size *f1, struct file_with_size *f2) {
-  return f1->size == f2->size && same_content(f1, f2);
+int same_files(struct file_with_size *f1, struct file_with_size *f2,
+               char *buffer1, char *buffer2) {
+  if(ignore_same_inode && f1->inode == f2->inode) {
+    return 0;
+  }
+  return f1->size == f2->size && same_content(f1, f2, buffer1, buffer2);
 }
 
 /**********************************************************************/
@@ -220,13 +218,18 @@ struct file_with_size *scan_directory(struct file_with_size *tail,
     closedir(dir);
   } else {
     if(S_ISREG(sb.st_mode)) {
-      tmp = safe_malloc(sizeof(struct file_with_size));
-      tmp->next = tail;
-      tmp->filename = strdup(name);
-      tmp->size = sb.st_size;
-      tmp->inode = sb.st_ino;
-      tmp->group_id = -1;
-      tail = tmp;
+      if(!ignore_entry(name)) {
+        if(!ignore_empty_files || sb.st_size > 0) {
+          tmp = safe_malloc(sizeof(struct file_with_size));
+          tmp->next = tail;
+          tmp->filename = strdup(name);
+          tmp->size = sb.st_size;
+          tmp->inode = sb.st_ino;
+          tmp->group_id = -1;
+          tmp->dir_id = -1;
+          tail = tmp;
+        }
+      }
     }
   }
 
@@ -236,12 +239,17 @@ struct file_with_size *scan_directory(struct file_with_size *tail,
 void print_file(struct file_with_size *node) {
   char tmp[PATH_MAX + 1];
   if(show_realpaths) {
-    if(show_groups) {
-      realpath(node->filename, tmp);
-      printf("%d %s\n", node->group_id, tmp);
+    if(realpath(node->filename, tmp)) {
+      if(show_groups) {
+        printf("%d %s\n", node->group_id, tmp);
+      } else {
+        printf("%s\n", tmp);
+      }
     } else {
-      realpath(node->filename, tmp);
-      printf("%s\n", tmp);
+      printf("Can not get the realpath of \"%s\": %s\n",
+             node->filename,
+             strerror(errno));
+      exit(EXIT_FAILURE);
     }
   } else {
     if(show_groups) {
@@ -263,7 +271,13 @@ int compare_nodes(const void *x1, const void *x2) {
   } else if((*f1)->group_id > (*f2)->group_id) {
     return 1;
   } 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;
+    }
   }
 }
 
@@ -278,7 +292,7 @@ void print_result(struct file_with_size *list1, struct file_with_size *list2) {
     if(node1->group_id >= 0) { nb++; }
   }
 
-  if(show_hits) {
+  if(list2) {
     for(node2 = list2; node2; node2 = node2->next) {
       if(node2->group_id >= 0) { nb++; }
     }
@@ -293,7 +307,7 @@ void print_result(struct file_with_size *list1, struct file_with_size *list2) {
     }
   }
 
-  if(show_hits) {
+  if(list2) {
     for(node2 = list2; node2; node2 = node2->next) {
       if(node2->group_id >= 0) {
         nodes[n++] = node2;
@@ -304,37 +318,46 @@ void print_result(struct file_with_size *list1, struct file_with_size *list2) {
   qsort(nodes, nb, sizeof(struct file_with_size *), compare_nodes);
 
   for(n = 0; n < nb; n++) {
+    if(!show_groups && n > 0 && nodes[n]->group_id != nodes[n-1]->group_id) {
+      printf("\n");
+    }
     print_file(nodes[n]);
   }
 
   free(nodes);
 }
 
+void print_progress(int max, int n, int *pp) {
+  int p, k;
+  int width;
+  if(show_progress && tty_width > 0) {
+    width = tty_width - 7;
+    p = (width * n) / (max - 1);
+    if(p > *pp) {
+      for(k = 0; k < p; k++) {
+        fprintf(stderr, "+");
+      }
+      for(; k < width; k++) {
+        fprintf(stderr, "-");
+      }
+      *pp = p;
+      p = (100 * n) / (max - 1);
+      fprintf(stderr, " [%3d%%]\r", p);
+    }
+  }
+}
+
 void start(const char *dirname1, const char *dirname2) {
   struct file_with_size *list1, *list2;
   struct file_with_size *node1, *node2;
-  struct stat sb1, sb2;
-  int not_in, found, same_dir;
-  int k, p, pp, l1, n;
+  int not_in, found;
+  int nb_groups, nb_nodes;
+  int list1_length, previous_progress;
 
-  if(strncmp(dirname2, "not:", 4) == 0) {
-    not_in = 1;
-    dirname2 += 4;
-  } else {
-    not_in = 0;
-  }
+  char *buffer1 = safe_malloc(sizeof(char) * READ_BUFFER_SIZE);
+  char *buffer2 = safe_malloc(sizeof(char) * READ_BUFFER_SIZE);
 
-  if(lstat(dirname1, &sb1) != 0) {
-    fprintf(stderr, "Can not stat \"%s\": %s\n", dirname1, strerror(errno));
-    exit(EXIT_FAILURE);
-  }
-
-  if(lstat(dirname2, &sb2) != 0) {
-    fprintf(stderr, "Can not stat \"%s\": %s\n", dirname2, strerror(errno));
-    exit(EXIT_FAILURE);
-  }
-
-  same_dir = (sb1.st_ino == sb2.st_ino);
+  not_in = 0;
 
   if(show_progress) {
     fprintf(stderr, "Scanning %s ... ", dirname1);
@@ -342,39 +365,41 @@ void start(const char *dirname1, const char *dirname2) {
 
   list1 = scan_directory(0, dirname1);
 
-  if(same_dir) {
-    list2 = list1;
-  } else {
+  if(dirname2) {
+    if(strncmp(dirname2, "not:", 4) == 0) {
+      not_in = 1;
+      /* groups are not computed in the not: mode */
+      show_groups = 0;
+      dirname2 += 4;
+    } else if(strncmp(dirname2, "and:", 4) == 0) {
+      dirname2 += 4;
+    }
     if(show_progress) {
       fprintf(stderr, "%s ... ", dirname2);
     }
     list2 = scan_directory(0, dirname2);
+  } else {
+    list2 = list1;
   }
 
   if(show_progress) {
     fprintf(stderr, "done.\n");
   }
 
-  k = 0;
-  pp = -1;
-  n = 0;
-  l1 = file_list_length(list1);
+  nb_groups = 0;
+  previous_progress = -1;
+  nb_nodes = 0;
+  list1_length = file_list_length(list1);
 
   if(not_in) {
     for(node1 = list1; node1; node1 = node1->next) {
-      if(show_progress) {
-        p = (100 * n)/l1;
-        if(p > pp) {
-          fprintf(stderr, "%d%%\n", p);
-          pp = p;
-        }
-        n++;
-      }
+      print_progress(list1_length, nb_nodes, &previous_progress);
+      nb_nodes++;
 
       found = 0;
 
       for(node2 = list2; !found && node2; node2 = node2->next) {
-        if(node1->inode != node2->inode && same_files(node1, node2)) {
+        if(same_files(node1, node2, buffer1, buffer2)) {
           found = 1;
         }
       }
@@ -390,52 +415,69 @@ void start(const char *dirname1, const char *dirname2) {
 
   } else {
     for(node1 = list1; node1; node1 = node1->next) {
-      if(show_progress) {
-        p = (100 * n)/l1;
-        if(p > pp) {
-          fprintf(stderr, "%d%%\n", p);
-          pp = p;
-        }
-        n++;
-      }
+      print_progress(list1_length, nb_nodes, &previous_progress);
+      nb_nodes++;
 
       for(node2 = list2; node2; node2 = node2->next) {
-        if(node1->inode != node2->inode && same_files(node1, node2)) {
-          if(node1->group_id < 0) {
-            if(node2->group_id >= 0) {
-              node1->group_id = node2->group_id;
-            } else {
-              node1->group_id = k;
-              k++;
+        if(node1->group_id < 0 || node2->group_id < 0) {
+          if(same_files(node1, node2, buffer1, buffer2)) {
+            if(node1->group_id < 0) {
+              if(node2->group_id >= 0) {
+                node1->group_id = node2->group_id;
+              } else {
+                node1->group_id = nb_groups;
+                node1->dir_id = 1;
+                nb_groups++;
+              }
+            }
+            if(node2->group_id < 0) {
+              node2->group_id = node1->group_id;
+              node2->dir_id = 2;
             }
-          }
-          if(node2->group_id < 0) {
-            node2->group_id = node1->group_id;
           }
         }
       }
     }
   }
 
-  print_result(list1, list2);
+  if(show_progress) {
+    fprintf(stderr, "\n");
+  }
 
-  file_list_delete(list1);
-  if(!same_dir) {
+  if(dirname2) {
+    print_result(list1, list2);
+    file_list_delete(list1);
     file_list_delete(list2);
+  } else {
+    print_result(list1, 0);
+    file_list_delete(list1);
   }
+
+  free(buffer1);
+  free(buffer2);
 }
 
 void print_help(FILE *out) {
-  fprintf(out, "Usage: finddup [OPTION]... DIR1 [[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.\n");
+  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, "\n");
-  fprintf(out, "   -h   show this help\n");
-  fprintf(out, "   -d   ignore dot files and directories\n");
-  fprintf(out, "   -c   do not show which files in DIR2 corresponds to those in DIR1\n");
-  fprintf(out, "   -g   do not show the file groups\n");
-  fprintf(out, "   -p   show progress\n");
-  fprintf(out, "   -r   show the real file paths\n");
+  fprintf(out, "   -h, --help\n");
+  fprintf(out, "        show this help\n");
+  fprintf(out, "   -d, --ignore-dots\n");
+  fprintf(out, "        ignore dot files and directories\n");
+  fprintf(out, "   -0, --ignore-empty\n");
+  fprintf(out, "        ignore empty files\n");
+  fprintf(out, "   -c, --hide-matchings\n");
+  fprintf(out, "        do not show which files in DIR2 corresponds to those in DIR1\n");
+  fprintf(out, "   -g, --no-group-ids\n");
+  fprintf(out, "        do not show the file groups\n");
+  fprintf(out, "   -p, --show-progress\n");
+  fprintf(out, "        show progress\n");
+  fprintf(out, "   -r, --real-paths\n");
+  fprintf(out, "        show the real file paths\n");
+  fprintf(out, "   -i, --same-inodes-are-different\n");
+  fprintf(out, "        consider files with same inode as different\n");
   fprintf(out, "\n");
   fprintf(out, "Report bugs and comments to <francois@fleuret.org>\n");
 }
@@ -445,13 +487,28 @@ void print_help(FILE *out) {
 int main(int argc, char **argv) {
   int c;
   struct file_with_size *root;
+  struct winsize win;
 
   root = 0;
 
   setlocale (LC_ALL, "");
 
   while (1) {
-    c = getopt(argc, argv, "hrcgdp");
+    int option_index = 0;
+    static struct option long_options[] = {
+      { "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' },
+      { "ignore-dots", no_argument, 0, 'd' },
+      { "ignore-empty", no_argument, 0, '0' },
+      { "show-progress", no_argument, 0, 'p' },
+      { 0, 0, 0, 0 }
+    };
+
+    c = getopt_long(argc, argv, "hircgd0p",
+                    long_options, &option_index);
     if (c == -1)
       break;
 
@@ -467,10 +524,18 @@ int main(int argc, char **argv) {
       ignore_dotfiles = 1;
       break;
 
+    case '0':
+      ignore_empty_files = 1;
+      break;
+
     case 'r':
       show_realpaths = 1;
       break;
 
+    case 'i':
+      ignore_same_inode = 1;
+      break;
+
     case 'g':
       show_groups = 0;
       break;
@@ -488,10 +553,17 @@ int main(int argc, char **argv) {
     }
   }
 
-  if(optind + 1 < argc) {
+  if(show_progress &&
+     isatty(STDOUT_FILENO) &&
+     !ioctl (STDOUT_FILENO, TIOCGWINSZ, (char *) &win)) {
+    tty_width = win.ws_col;
+  }
+
+  if(optind + 2 == argc) {
     start(argv[optind], argv[optind + 1]);
-  } else if(optind < argc) {
-    start(argv[optind], argv[optind]);
+  } else if(optind + 1 == argc) {
+    ignore_same_inode = 1;
+    start(argv[optind], 0);
   } else {
     print_help(stderr);
     exit(EXIT_FAILURE);