-/* FDUPES Copyright (c) 1999 Adrian Lopez
+/* FDUPES Copyright (c) 1999-2002 Adrian Lopez
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation files
#include <dirent.h>
#include <unistd.h>
#include <stdlib.h>
+#ifndef OMIT_GETOPT_LONG
#include <getopt.h>
+#endif
#include <string.h>
#include <errno.h>
+#include <libgen.h>
-#ifndef EXTERNAL_MD5
#include "md5/md5.h"
-#endif
#define ISFLAG(a,b) ((a & b) == b)
#define SETFLAG(a,b) (a |= b)
-#define F_RECURSE 0x001
-#define F_HIDEPROGRESS 0x002
-#define F_DSAMELINE 0x004
-#define F_FOLLOWLINKS 0x008
-#define F_DELETEFILES 0x010
-#define F_EXCLUDEEMPTY 0x020
-#define F_CONSIDERHARDLINKS 0x040
-#define F_SHOWSIZE 0x080
-#define F_OMITFIRST 0x100
+#define F_RECURSE 0x0001
+#define F_HIDEPROGRESS 0x0002
+#define F_DSAMELINE 0x0004
+#define F_FOLLOWLINKS 0x0008
+#define F_DELETEFILES 0x0010
+#define F_EXCLUDEEMPTY 0x0020
+#define F_CONSIDERHARDLINKS 0x0040
+#define F_SHOWSIZE 0x0080
+#define F_OMITFIRST 0x0100
+#define F_RECURSEAFTER 0x0200
+#define F_NOPROMPT 0x0400
+#define F_SUMMARIZEMATCHES 0x0800
+#define F_EXCLUDEHIDDEN 0x1000
+#define F_PERMISSIONS 0x2000
+#define F_REVERSE 0x4000
+#define F_IMMEDIATE 0x8000
+
+typedef enum {
+ ORDER_TIME = 0,
+ ORDER_NAME
+} ordertype_t;
char *program_name;
#define INPUT_SIZE 256
+#define PARTIAL_MD5_SIZE 4096
+
+#define MD5_DIGEST_LENGTH 16
+
+/*
+
+TODO: Partial sums (for working with very large files).
+
+typedef struct _signature
+{
+ md5_state_t state;
+ md5_byte_t digest[16];
+} signature_t;
+
+typedef struct _signatures
+{
+ int num_signatures;
+ signature_t *signatures;
+} signatures_t;
+
+*/
+
typedef struct _file {
char *d_name;
off_t size;
- char *crcsignature;
+ md5_byte_t *crcpartial;
+ md5_byte_t *crcsignature;
+ dev_t device;
ino_t inode;
+ time_t mtime;
int hasdupes; /* true only if file is first on duplicate chain */
struct _file *duplicates;
struct _file *next;
typedef struct _filetree {
file_t *file;
-#ifdef EXPERIMENTAL_RBTREE
- unsigned char color;
- struct _filetree *parent;
-#endif
struct _filetree *left;
struct _filetree *right;
} filetree_t;
-#ifdef EXPERIMENTAL_RBTREE
-#define COLOR_RED 0
-#define COLOR_BLACK 1
-#endif
-
void errormsg(char *message, ...)
{
va_list ap;
return s.st_size;
}
+dev_t getdevice(char *filename) {
+ struct stat s;
+
+ if (stat(filename, &s) != 0) return 0;
+
+ return s.st_dev;
+}
+
ino_t getinode(char *filename) {
struct stat s;
return s.st_ino;
}
+time_t getmtime(char *filename) {
+ struct stat s;
+
+ if (stat(filename, &s) != 0) return 0;
+
+ return s.st_mtime;
+}
+
+char **cloneargs(int argc, char **argv)
+{
+ int x;
+ char **args;
+
+ args = (char **) malloc(sizeof(char*) * argc);
+ if (args == NULL) {
+ errormsg("out of memory!\n");
+ exit(1);
+ }
+
+ for (x = 0; x < argc; x++) {
+ args[x] = (char*) malloc(strlen(argv[x]) + 1);
+ if (args[x] == NULL) {
+ free(args);
+ errormsg("out of memory!\n");
+ exit(1);
+ }
+
+ strcpy(args[x], argv[x]);
+ }
+
+ return args;
+}
+
+int findarg(char *arg, int start, int argc, char **argv)
+{
+ int x;
+
+ for (x = start; x < argc; x++)
+ if (strcmp(argv[x], arg) == 0)
+ return x;
+
+ return x;
+}
+
+/* Find the first non-option argument after specified option. */
+int nonoptafter(char *option, int argc, char **oldargv,
+ char **newargv, int optind)
+{
+ int x;
+ int targetind;
+ int testind;
+ int startat = 1;
+
+ targetind = findarg(option, 1, argc, oldargv);
+
+ for (x = optind; x < argc; x++) {
+ testind = findarg(newargv[x], startat, argc, oldargv);
+ if (testind > targetind) return x;
+ else startat = testind;
+ }
+
+ return x;
+}
+
int grokdir(char *dir, file_t **filelistp)
{
DIR *cd;
struct stat linfo;
static int progress = 0;
static char indicator[] = "-\\|/";
+ char *fullname, *name;
cd = opendir(dir);
exit(1);
} else newfile->next = *filelistp;
+ newfile->device = 0;
newfile->inode = 0;
newfile->crcsignature = NULL;
+ newfile->crcpartial = NULL;
newfile->duplicates = NULL;
newfile->hasdupes = 0;
strcat(newfile->d_name, "/");
strcat(newfile->d_name, dirinfo->d_name);
+ if (ISFLAG(flags, F_EXCLUDEHIDDEN)) {
+ fullname = strdup(newfile->d_name);
+ name = basename(fullname);
+ if (name[0] == '.' && strcmp(name, ".") && strcmp(name, "..") ) {
+ free(newfile->d_name);
+ free(newfile);
+ continue;
+ }
+ free(fullname);
+ }
+
if (filesize(newfile->d_name) == 0 && ISFLAG(flags, F_EXCLUDEEMPTY)) {
free(newfile->d_name);
free(newfile);
return filecount;
}
-#ifndef EXTERNAL_MD5
-
-/* If EXTERNAL_MD5 is not defined, use L. Peter Deutsch's MD5 library.
- */
-char *getcrcsignature(char *filename)
+md5_byte_t *getcrcsignatureuntil(char *filename, off_t max_read)
{
- int x;
off_t fsize;
off_t toread;
md5_state_t state;
- md5_byte_t digest[16];
+ static md5_byte_t digest[MD5_DIGEST_LENGTH];
static md5_byte_t chunk[CHUNK_SIZE];
- static char signature[16*2 + 1];
- char *sigp;
FILE *file;
md5_init(&state);
+
fsize = filesize(filename);
+
+ if (max_read != 0 && fsize > max_read)
+ fsize = max_read;
file = fopen(filename, "rb");
if (file == NULL) {
}
while (fsize > 0) {
- toread = (fsize % CHUNK_SIZE) ? (fsize % CHUNK_SIZE) : CHUNK_SIZE;
+ toread = (fsize >= CHUNK_SIZE) ? CHUNK_SIZE : fsize;
if (fread(chunk, toread, 1, file) != 1) {
errormsg("error reading from file %s\n", filename);
+ fclose(file);
return NULL;
}
md5_append(&state, chunk, toread);
md5_finish(&state, digest);
- sigp = signature;
-
- for (x = 0; x < 16; x++) {
- sprintf(sigp, "%02x", digest[x]);
- sigp = strchr(sigp, '\0');
- }
-
fclose(file);
- return signature;
+ return digest;
}
-#endif /* [#ifndef EXTERNAL_MD5] */
-
-#ifdef EXTERNAL_MD5
-
-/* If EXTERNAL_MD5 is defined, use md5sum program to calculate signatures.
- */
-char *getcrcsignature(char *filename)
+md5_byte_t *getcrcsignature(char *filename)
{
- static char signature[256];
- char *command;
- char *separator;
- FILE *result;
+ return getcrcsignatureuntil(filename, 0);
+}
- command = (char*) malloc(strlen(filename)+strlen(EXTERNAL_MD5)+2);
- if (command == NULL) {
- errormsg("out of memory\n");
- exit(1);
- }
+md5_byte_t *getcrcpartialsignature(char *filename)
+{
+ return getcrcsignatureuntil(filename, PARTIAL_MD5_SIZE);
+}
- sprintf(command, "%s %s", EXTERNAL_MD5, filename);
+int md5cmp(const md5_byte_t *a, const md5_byte_t *b)
+{
+ int x;
- result = popen(command, "r");
- if (result == NULL) {
- errormsg("error invoking %s\n", EXTERNAL_MD5);
- exit(1);
+ for (x = 0; x < MD5_DIGEST_LENGTH; ++x)
+ {
+ if (a[x] < b[x])
+ return -1;
+ else if (a[x] > b[x])
+ return 1;
}
-
- free(command);
- if (fgets(signature, 256, result) == NULL) {
- errormsg("error generating signature for %s\n", filename);
- return NULL;
- }
- separator = strchr(signature, ' ');
- if (separator) *separator = '\0';
+ return 0;
+}
- pclose(result);
+void md5copy(md5_byte_t *to, const md5_byte_t *from)
+{
+ int x;
- return signature;
+ for (x = 0; x < MD5_DIGEST_LENGTH; ++x)
+ to[x] = from[x];
}
-#endif /* [#ifdef EXTERNAL_MD5] */
-
void purgetree(filetree_t *checktree)
{
if (checktree->left != NULL) purgetree(checktree->left);
free(checktree);
}
-#ifdef EXPERIMENTAL_RBTREE
-/* Use a red-black tree structure to store file information.
- */
-
-void rotate_left(filetree_t **root, filetree_t *node)
-{
- filetree_t *subject;
-
- subject = node->right;
- node->right = subject->left;
-
- if (subject->left != NULL) subject->left->parent = node;
- subject->parent = node->parent;
-
- if (node->parent == NULL) {
- *root = subject;
- } else {
- if (node == node->parent->left)
- node->parent->left = subject;
- else
- node->parent->right = subject;
- }
-
- subject->left = node;
- node->parent = subject;
-}
-
-void rotate_right(filetree_t **root, filetree_t *node)
-{
- filetree_t *subject;
-
- subject = node->left;
- node->left = subject->right;
-
- if (subject->right != NULL) subject->right->parent = node;
- subject->parent = node->parent;
-
- if (node->parent == NULL) {
- *root = subject;
- } else {
- if (node == node->parent->left)
- node->parent->left = subject;
- else
- node->parent->right = subject;
- }
-
- subject->right = node;
- node->parent = subject;
-}
-
-#define TREE_LEFT -1
-#define TREE_RIGHT 1
-#define TREE_ROOT 0
-
-void registerfile(filetree_t **root, filetree_t *parent, int loc, file_t *file)
+void getfilestats(file_t *file)
{
- filetree_t *node;
- filetree_t *uncle;
-
file->size = filesize(file->d_name);
file->inode = getinode(file->d_name);
-
- node = (filetree_t*) malloc(sizeof(filetree_t));
- if (node == NULL) {
- errormsg("out of memory!\n");
- exit(1);
- }
-
- node->file = file;
- node->left = NULL;
- node->right = NULL;
- node->parent = parent;
- node->color = COLOR_RED;
-
- if (loc == TREE_ROOT)
- *root = node;
- else if (loc == TREE_LEFT)
- parent->left = node;
- else
- parent->right = node;
-
- while (node != *root && node->parent->color == COLOR_RED) {
- if (node->parent->parent == NULL) return;
-
- if (node->parent == node->parent->parent->left) {
- uncle = node->parent->parent->right;
- if (uncle == NULL) return;
-
- if (uncle->color == COLOR_RED) {
- node->parent->color = COLOR_BLACK;
- uncle->color = COLOR_BLACK;
- node->parent->parent->color = COLOR_RED;
- node = node->parent->parent;
- } else {
- if (node == node->parent->right) {
- node = node->parent;
- rotate_left(root, node);
- }
- node->parent->color = COLOR_BLACK;
- node->parent->parent->color = COLOR_RED;
- rotate_right(root, node->parent->parent);
- }
- } else {
- uncle = node->parent->parent->left;
- if (uncle == NULL) return;
-
- if (uncle->color == COLOR_RED) {
- node->parent->color = COLOR_BLACK;
- uncle->color = COLOR_BLACK;
- node->parent->parent->color = COLOR_RED;
- node = node->parent->parent;
- } else {
- if (node == node->parent->right) {
- node = node->parent;
- rotate_left(root, node);
- }
- node->parent->color = COLOR_BLACK;
- node->parent->parent->color = COLOR_RED;
- rotate_right(root, node->parent->parent);
- }
- }
- }
-
- (*root)->color = COLOR_BLACK;
+ file->device = getdevice(file->d_name);
+ file->mtime = getmtime(file->d_name);
}
-#endif /* [#ifdef EXPERIMENTAL_RBTREE] */
-
-#ifndef EXPERIMENTAL_RBTREE
-
int registerfile(filetree_t **branch, file_t *file)
{
- file->size = filesize(file->d_name);
- file->inode = getinode(file->d_name);
+ getfilestats(file);
*branch = (filetree_t*) malloc(sizeof(filetree_t));
if (*branch == NULL) {
return 1;
}
-#endif /* [#ifndef EXPERIMENTAL_RBTREE] */
+int same_permissions(char* name1, char* name2)
+{
+ struct stat s1, s2;
+
+ if (stat(name1, &s1) != 0) return -1;
+ if (stat(name2, &s2) != 0) return -1;
+
+ return (s1.st_mode == s2.st_mode &&
+ s1.st_uid == s2.st_uid &&
+ s1.st_gid == s2.st_gid);
+}
+
+int is_hardlink(filetree_t *checktree, file_t *file)
+{
+ file_t *dupe;
+ ino_t inode;
+ dev_t device;
+
+ inode = getinode(file->d_name);
+ device = getdevice(file->d_name);
+
+ if ((inode == checktree->file->inode) &&
+ (device == checktree->file->device))
+ return 1;
+
+ if (checktree->file->hasdupes)
+ {
+ dupe = checktree->file->duplicates;
+
+ do {
+ if ((inode == dupe->inode) &&
+ (device == dupe->device))
+ return 1;
+
+ dupe = dupe->duplicates;
+ } while (dupe != NULL);
+ }
+
+ return 0;
+}
-file_t *checkmatch(filetree_t **root, filetree_t *checktree, file_t *file)
+file_t **checkmatch(filetree_t **root, filetree_t *checktree, file_t *file)
{
int cmpresult;
- char *crcsignature;
+ md5_byte_t *crcsignature;
off_t fsize;
- /* If inodes are equal one of the files is a hard link, which
- is usually not accidental. We don't want to flag them as
- duplicates, unless the user specifies otherwise. */
+ /* If device and inode fields are equal one of the files is a
+ hard link to the other or the files have been listed twice
+ unintentionally. We don't want to flag these files as
+ duplicates unless the user specifies otherwise.
+ */
- if (!ISFLAG(flags, F_CONSIDERHARDLINKS) && getinode(file->d_name) ==
- checktree->file->inode) return NULL;
+ if (!ISFLAG(flags, F_CONSIDERHARDLINKS) && is_hardlink(checktree, file))
+ return NULL;
fsize = filesize(file->d_name);
cmpresult = -1;
else
if (fsize > checktree->file->size) cmpresult = 1;
+ else
+ if (ISFLAG(flags, F_PERMISSIONS) &&
+ !same_permissions(file->d_name, checktree->file->d_name))
+ cmpresult = -1;
else {
- if (checktree->file->crcsignature == NULL) {
- crcsignature = getcrcsignature(checktree->file->d_name);
- if (crcsignature == NULL) return NULL;
+ if (checktree->file->crcpartial == NULL) {
+ crcsignature = getcrcpartialsignature(checktree->file->d_name);
+ if (crcsignature == NULL) {
+ errormsg ("cannot read file %s\n", checktree->file->d_name);
+ return NULL;
+ }
- checktree->file->crcsignature = (char*) malloc(strlen(crcsignature)+1);
- if (checktree->file->crcsignature == NULL) {
+ checktree->file->crcpartial = (md5_byte_t*) malloc(MD5_DIGEST_LENGTH * sizeof(md5_byte_t));
+ if (checktree->file->crcpartial == NULL) {
errormsg("out of memory\n");
exit(1);
}
- strcpy(checktree->file->crcsignature, crcsignature);
+ md5copy(checktree->file->crcpartial, crcsignature);
}
- if (file->crcsignature == NULL) {
- crcsignature = getcrcsignature(file->d_name);
- if (crcsignature == NULL) return NULL;
+ if (file->crcpartial == NULL) {
+ crcsignature = getcrcpartialsignature(file->d_name);
+ if (crcsignature == NULL) {
+ errormsg ("cannot read file %s\n", file->d_name);
+ return NULL;
+ }
- file->crcsignature = (char*) malloc(strlen(crcsignature)+1);
- if (file->crcsignature == NULL) {
+ file->crcpartial = (md5_byte_t*) malloc(MD5_DIGEST_LENGTH * sizeof(md5_byte_t));
+ if (file->crcpartial == NULL) {
errormsg("out of memory\n");
exit(1);
}
- strcpy(file->crcsignature, crcsignature);
+ md5copy(file->crcpartial, crcsignature);
}
- cmpresult = strcmp(file->crcsignature, checktree->file->crcsignature);
+ cmpresult = md5cmp(file->crcpartial, checktree->file->crcpartial);
+ /*if (cmpresult != 0) errormsg(" on %s vs %s\n", file->d_name, checktree->file->d_name);*/
+
+ if (cmpresult == 0) {
+ if (checktree->file->crcsignature == NULL) {
+ crcsignature = getcrcsignature(checktree->file->d_name);
+ if (crcsignature == NULL) return NULL;
+
+ checktree->file->crcsignature = (md5_byte_t*) malloc(MD5_DIGEST_LENGTH * sizeof(md5_byte_t));
+ if (checktree->file->crcsignature == NULL) {
+ errormsg("out of memory\n");
+ exit(1);
+ }
+ md5copy(checktree->file->crcsignature, crcsignature);
+ }
+
+ if (file->crcsignature == NULL) {
+ crcsignature = getcrcsignature(file->d_name);
+ if (crcsignature == NULL) return NULL;
+
+ file->crcsignature = (md5_byte_t*) malloc(MD5_DIGEST_LENGTH * sizeof(md5_byte_t));
+ if (file->crcsignature == NULL) {
+ errormsg("out of memory\n");
+ exit(1);
+ }
+ md5copy(file->crcsignature, crcsignature);
+ }
+
+ cmpresult = md5cmp(file->crcsignature, checktree->file->crcsignature);
+ /*if (cmpresult != 0) errormsg("P on %s vs %s\n",
+ file->d_name, checktree->file->d_name);
+ else errormsg("P F on %s vs %s\n", file->d_name,
+ checktree->file->d_name);
+ printf("%s matches %s\n", file->d_name, checktree->file->d_name);*/
+ }
}
if (cmpresult < 0) {
if (checktree->left != NULL) {
return checkmatch(root, checktree->left, file);
} else {
-#ifndef EXPERIMENTAL_RBTREE
registerfile(&(checktree->left), file);
-#else
- registerfile(root, checktree, TREE_LEFT, file);
-#endif
return NULL;
}
} else if (cmpresult > 0) {
if (checktree->right != NULL) {
return checkmatch(root, checktree->right, file);
} else {
-#ifndef EXPERIMENTAL_RBTREE
registerfile(&(checktree->right), file);
-#else
- registerfile(root, checktree, TREE_RIGHT, file);
-#endif
return NULL;
}
- } else return checktree->file;
+ } else
+ {
+ getfilestats(file);
+ return &checktree->file;
+ }
}
/* Do a bit-for-bit comparison in case two different files produce the
int confirmmatch(FILE *file1, FILE *file2)
{
- unsigned char c1;
- unsigned char c2;
+ unsigned char c1[CHUNK_SIZE];
+ unsigned char c2[CHUNK_SIZE];
size_t r1;
size_t r2;
fseek(file2, 0, SEEK_SET);
do {
- r1 = fread(&c1, sizeof(c1), 1, file1);
- r2 = fread(&c2, sizeof(c2), 1, file2);
+ r1 = fread(c1, sizeof(unsigned char), sizeof(c1), file1);
+ r2 = fread(c2, sizeof(unsigned char), sizeof(c2), file2);
- if (c1 != c2) return 0; /* file contents are different */
- } while (r1 && r2);
+ if (r1 != r2) return 0; /* file lengths are different */
+ if (memcmp (c1, c2, r1)) return 0; /* file contents are different */
+ } while (r2);
- if (r1 != r2) return 0; /* file lengths are different */
-
return 1;
}
+void summarizematches(file_t *files)
+{
+ int numsets = 0;
+ double numbytes = 0.0;
+ int numfiles = 0;
+ file_t *tmpfile;
+
+ while (files != NULL)
+ {
+ if (files->hasdupes)
+ {
+ numsets++;
+
+ tmpfile = files->duplicates;
+ while (tmpfile != NULL)
+ {
+ numfiles++;
+ numbytes += files->size;
+ tmpfile = tmpfile->duplicates;
+ }
+ }
+
+ files = files->next;
+ }
+
+ if (numsets == 0)
+ printf("No duplicates found.\n\n");
+ else
+ {
+ if (numbytes < 1024.0)
+ printf("%d duplicate files (in %d sets), occupying %.0f bytes.\n\n", numfiles, numsets, numbytes);
+ else if (numbytes <= (1000.0 * 1000.0))
+ printf("%d duplicate files (in %d sets), occupying %.1f kilobytes\n\n", numfiles, numsets, numbytes / 1000.0);
+ else
+ printf("%d duplicate files (in %d sets), occupying %.1f megabytes\n\n", numfiles, numsets, numbytes / (1000.0 * 1000.0));
+
+ }
+}
+
void printmatches(file_t *files)
{
file_t *tmpfile;
while (files != NULL) {
if (files->hasdupes) {
if (!ISFLAG(flags, F_OMITFIRST)) {
- if (ISFLAG(flags, F_SHOWSIZE)) printf("%ld byte%seach:\n", files->size,
+ if (ISFLAG(flags, F_SHOWSIZE)) printf("%lld byte%seach:\n", (long long int)files->size,
(files->size != 1) ? "s " : " ");
if (ISFLAG(flags, F_DSAMELINE)) escapefilename("\\ ", &files->d_name);
printf("%s%c", files->d_name, ISFLAG(flags, F_DSAMELINE)?' ':'\n');
}
}
-void autodelete(file_t *files)
+/*
+#define REVISE_APPEND "_tmp"
+char *revisefilename(char *path, int seq)
+{
+ int digits;
+ char *newpath;
+ char *scratch;
+ char *dot;
+
+ digits = numdigits(seq);
+ newpath = malloc(strlen(path) + strlen(REVISE_APPEND) + digits + 1);
+ if (!newpath) return newpath;
+
+ scratch = malloc(strlen(path) + 1);
+ if (!scratch) return newpath;
+
+ strcpy(scratch, path);
+ dot = strrchr(scratch, '.');
+ if (dot)
+ {
+ *dot = 0;
+ sprintf(newpath, "%s%s%d.%s", scratch, REVISE_APPEND, seq, dot + 1);
+ }
+
+ else
+ {
+ sprintf(newpath, "%s%s%d", path, REVISE_APPEND, seq);
+ }
+
+ free(scratch);
+
+ return newpath;
+} */
+
+int relink(char *oldfile, char *newfile)
+{
+ dev_t od;
+ dev_t nd;
+ ino_t oi;
+ ino_t ni;
+
+ od = getdevice(oldfile);
+ oi = getinode(oldfile);
+
+ if (link(oldfile, newfile) != 0)
+ return 0;
+
+ /* make sure we're working with the right file (the one we created) */
+ nd = getdevice(newfile);
+ ni = getinode(newfile);
+
+ if (nd != od || oi != ni)
+ return 0; /* file is not what we expected */
+
+ return 1;
+}
+
+void deletefiles(file_t *files, int prompt, FILE *tty)
{
int counter;
int groups = 0;
counter = 1;
dupelist[counter] = files;
- printf("[%d] %s\n", counter, files->d_name);
+ if (prompt) printf("[%d] %s\n", counter, files->d_name);
tmpfile = files->duplicates;
while (tmpfile) {
dupelist[++counter] = tmpfile;
- printf("[%d] %s\n", counter, tmpfile->d_name);
+ if (prompt) printf("[%d] %s\n", counter, tmpfile->d_name);
tmpfile = tmpfile->duplicates;
}
- printf("\n");
+ if (prompt) printf("\n");
+
+ if (!prompt) /* preserve only the first file */
+ {
+ preserve[1] = 1;
+ for (x = 2; x <= counter; x++) preserve[x] = 0;
+ }
+
+ else /* prompt for files to preserve */
do {
printf("Set %d of %d, preserve files [1 - %d, all]",
curgroup, groups, counter);
- if (ISFLAG(flags, F_SHOWSIZE)) printf(" (%ld byte%seach)", files->size,
+ if (ISFLAG(flags, F_SHOWSIZE)) printf(" (%lld byte%seach)", (long long int)files->size,
(files->size != 1) ? "s " : " ");
printf(": ");
fflush(stdout);
- fgets(preservestr, INPUT_SIZE, stdin);
+ if (!fgets(preservestr, INPUT_SIZE, tty))
+ preservestr[0] = '\n'; /* treat fgets() failure as if nothing was entered */
i = strlen(preservestr) - 1;
}
preservestr = tstr;
- if (!fgets(preservestr + i + 1, INPUT_SIZE, stdin))
- break; /* stop if fgets fails -- possible EOF? */
+ if (!fgets(preservestr + i + 1, INPUT_SIZE, tty))
+ {
+ preservestr[0] = '\n'; /* treat fgets() failure as if nothing was entered */
+ break;
+ }
i = strlen(preservestr)-1;
}
if (preserve[x])
printf(" [+] %s\n", dupelist[x]->d_name);
else {
- printf(" [-] %s\n", dupelist[x]->d_name);
- remove(dupelist[x]->d_name);
+ if (remove(dupelist[x]->d_name) == 0) {
+ printf(" [-] %s\n", dupelist[x]->d_name);
+ } else {
+ printf(" [!] %s ", dupelist[x]->d_name);
+ printf("-- unable to delete file!\n");
+ }
}
}
printf("\n");
free(preservestr);
}
+int sort_pairs_by_arrival(file_t *f1, file_t *f2)
+{
+ if (f2->duplicates != 0)
+ return !ISFLAG(flags, F_REVERSE) ? 1 : -1;
+
+ return !ISFLAG(flags, F_REVERSE) ? -1 : 1;
+}
+
+int sort_pairs_by_mtime(file_t *f1, file_t *f2)
+{
+ if (f1->mtime < f2->mtime)
+ return !ISFLAG(flags, F_REVERSE) ? -1 : 1;
+ else if (f1->mtime > f2->mtime)
+ return !ISFLAG(flags, F_REVERSE) ? 1 : -1;
+
+ return 0;
+}
+
+int sort_pairs_by_filename(file_t *f1, file_t *f2)
+{
+ return strcmp(f1->d_name, f2->d_name);
+}
+
+void registerpair(file_t **matchlist, file_t *newmatch,
+ int (*comparef)(file_t *f1, file_t *f2))
+{
+ file_t *traverse;
+ file_t *back;
+
+ (*matchlist)->hasdupes = 1;
+
+ back = 0;
+ traverse = *matchlist;
+ while (traverse)
+ {
+ if (comparef(newmatch, traverse) <= 0)
+ {
+ newmatch->duplicates = traverse;
+
+ if (back == 0)
+ {
+ *matchlist = newmatch; /* update pointer to head of list */
+
+ newmatch->hasdupes = 1;
+ traverse->hasdupes = 0; /* flag is only for first file in dupe chain */
+ }
+ else
+ back->duplicates = newmatch;
+
+ break;
+ }
+ else
+ {
+ if (traverse->duplicates == 0)
+ {
+ traverse->duplicates = newmatch;
+
+ if (back == 0)
+ traverse->hasdupes = 1;
+
+ break;
+ }
+ }
+
+ back = traverse;
+ traverse = traverse->duplicates;
+ }
+}
+
+void deletesuccessor(file_t **existing, file_t *duplicate,
+ int (*comparef)(file_t *f1, file_t *f2))
+{
+ file_t *to_keep;
+ file_t *to_delete;
+
+ if (comparef(duplicate, *existing) >= 0)
+ {
+ to_keep = *existing;
+ to_delete = duplicate;
+ }
+ else
+ {
+ to_keep = duplicate;
+ to_delete = *existing;
+
+ *existing = duplicate;
+ }
+
+ if (!ISFLAG(flags, F_HIDEPROGRESS)) fprintf(stderr, "\r%40s\r", " ");
+
+ printf(" [+] %s\n", to_keep->d_name);
+ if (remove(to_delete->d_name) == 0) {
+ printf(" [-] %s\n", to_delete->d_name);
+ } else {
+ printf(" [!] %s ", to_delete->d_name);
+ printf("-- unable to delete file!\n");
+ }
+
+ printf("\n");
+}
+
void help_text()
{
printf("Usage: fdupes [options] DIRECTORY...\n\n");
- printf(" -r --recurse \tinclude files residing in subdirectories\n");
+ printf(" -r --recurse \tfor every directory given follow subdirectories\n");
+ printf(" \tencountered within\n");
+ printf(" -R --recurse: \tfor each directory given after this option follow\n");
+ printf(" \tsubdirectories encountered within (note the ':' at\n");
+ printf(" \tthe end of the option, manpage for more details)\n");
printf(" -s --symlinks \tfollow symlinks\n");
printf(" -H --hardlinks \tnormally, when two or more files point to the same\n");
printf(" \tdisk area they are treated as non-duplicates; this\n");
printf(" \toption will change this behavior\n");
printf(" -n --noempty \texclude zero-length files from consideration\n");
+ printf(" -A --nohidden \texclude hidden files from consideration\n");
printf(" -f --omitfirst \tomit the first file in each set of matches\n");
printf(" -1 --sameline \tlist each set of matches on a single line\n");
printf(" -S --size \tshow size of duplicate files\n");
+ printf(" -m --summarize \tsummarize dupe information\n");
printf(" -q --quiet \thide progress indicator\n");
printf(" -d --delete \tprompt user for files to preserve and delete all\n");
printf(" \tothers; important: under particular circumstances,\n");
printf(" \twith -s or --symlinks, or when specifying a\n");
printf(" \tparticular directory more than once; refer to the\n");
printf(" \tfdupes documentation for additional information\n");
+ /*printf(" -l --relink \t(description)\n");*/
+ printf(" -N --noprompt \ttogether with --delete, preserve the first file in\n");
+ printf(" \teach set of duplicates and delete the rest without\n");
+ printf(" \tprompting the user\n");
+ printf(" -I --immediate \tdelete duplicates as they are encountered, without\n");
+ printf(" \tgrouping into sets; implies --noprompt\n");
+ printf(" -p --permissions \tdon't consider files with different owner/group or\n");
+ printf(" \tpermission bits as duplicates\n");
+ printf(" -o --order=BY \tselect sort order for output, linking and deleting; by\n");
+ printf(" \tmtime (BY='time'; default) or filename (BY='name')\n");
+ printf(" -i --reverse \treverse order while sorting\n");
printf(" -v --version \tdisplay fdupes version\n");
printf(" -h --help \tdisplay this help message\n\n");
+#ifdef OMIT_GETOPT_LONG
+ printf("Note: Long options are not supported in this fdupes build.\n\n");
+#endif
}
int main(int argc, char **argv) {
FILE *file2;
file_t *files = NULL;
file_t *curfile;
- file_t *match = NULL;
+ file_t **match = NULL;
filetree_t *checktree = NULL;
int filecount = 0;
int progress = 0;
-
+ char **oldargv;
+ int firstrecurse;
+ ordertype_t ordertype = ORDER_TIME;
+
+#ifndef OMIT_GETOPT_LONG
static struct option long_options[] =
{
{ "omitfirst", 0, 0, 'f' },
{ "recurse", 0, 0, 'r' },
+ { "recursive", 0, 0, 'r' },
+ { "recurse:", 0, 0, 'R' },
+ { "recursive:", 0, 0, 'R' },
{ "quiet", 0, 0, 'q' },
{ "sameline", 0, 0, '1' },
{ "size", 0, 0, 'S' },
{ "symlinks", 0, 0, 's' },
{ "hardlinks", 0, 0, 'H' },
+ { "relink", 0, 0, 'l' },
{ "noempty", 0, 0, 'n' },
+ { "nohidden", 0, 0, 'A' },
{ "delete", 0, 0, 'd' },
{ "version", 0, 0, 'v' },
{ "help", 0, 0, 'h' },
+ { "noprompt", 0, 0, 'N' },
+ { "immediate", 0, 0, 'I'},
+ { "summarize", 0, 0, 'm'},
+ { "summary", 0, 0, 'm' },
+ { "permissions", 0, 0, 'p' },
+ { "order", 1, 0, 'o' },
+ { "reverse", 0, 0, 'i' },
{ 0, 0, 0, 0 }
};
+#define GETOPT getopt_long
+#else
+#define GETOPT getopt
+#endif
program_name = argv[0];
- while ((opt = getopt_long(argc, argv, "frq1SsHndvh", long_options, NULL)) != EOF) {
+ oldargv = cloneargs(argc, argv);
+
+ while ((opt = GETOPT(argc, argv, "frRq1SsHlnAdvhNmpo:i"
+#ifndef OMIT_GETOPT_LONG
+ , long_options, NULL
+#endif
+ )) != EOF) {
switch (opt) {
case 'f':
SETFLAG(flags, F_OMITFIRST);
case 'r':
SETFLAG(flags, F_RECURSE);
break;
+ case 'R':
+ SETFLAG(flags, F_RECURSEAFTER);
+ break;
case 'q':
SETFLAG(flags, F_HIDEPROGRESS);
break;
case 'n':
SETFLAG(flags, F_EXCLUDEEMPTY);
break;
+ case 'A':
+ SETFLAG(flags, F_EXCLUDEHIDDEN);
+ break;
case 'd':
SETFLAG(flags, F_DELETEFILES);
break;
case 'h':
help_text();
exit(1);
+ case 'N':
+ SETFLAG(flags, F_NOPROMPT);
+ break;
+ case 'I':
+ SETFLAG(flags, F_IMMEDIATE);
+ break;
+ case 'm':
+ SETFLAG(flags, F_SUMMARIZEMATCHES);
+ break;
+ case 'p':
+ SETFLAG(flags, F_PERMISSIONS);
+ break;
+ case 'o':
+ if (!strcasecmp("name", optarg)) {
+ ordertype = ORDER_NAME;
+ } else if (!strcasecmp("time", optarg)) {
+ ordertype = ORDER_TIME;
+ } else {
+ errormsg("invalid value for --order: '%s'\n", optarg);
+ exit(1);
+ }
+ break;
+ case 'i':
+ SETFLAG(flags, F_REVERSE);
+ break;
+
default:
- fprintf(stderr, "Try `fdupes --help' for more information\n");
+ fprintf(stderr, "Try `fdupes --help' for more information.\n");
exit(1);
}
}
exit(1);
}
- for (x = optind; x < argc; x++) filecount += grokdir(argv[x], &files);
+ if (ISFLAG(flags, F_RECURSE) && ISFLAG(flags, F_RECURSEAFTER)) {
+ errormsg("options --recurse and --recurse: are not compatible\n");
+ exit(1);
+ }
+
+ if (ISFLAG(flags, F_SUMMARIZEMATCHES) && ISFLAG(flags, F_DELETEFILES)) {
+ errormsg("options --summarize and --delete are not compatible\n");
+ exit(1);
+ }
+
+ if (ISFLAG(flags, F_RECURSEAFTER)) {
+ firstrecurse = nonoptafter("--recurse:", argc, oldargv, argv, optind);
+
+ if (firstrecurse == argc)
+ firstrecurse = nonoptafter("-R", argc, oldargv, argv, optind);
+
+ if (firstrecurse == argc) {
+ errormsg("-R option must be isolated from other options\n");
+ exit(1);
+ }
+
+ /* F_RECURSE is not set for directories before --recurse: */
+ for (x = optind; x < firstrecurse; x++)
+ filecount += grokdir(argv[x], &files);
+
+ /* Set F_RECURSE for directories after --recurse: */
+ SETFLAG(flags, F_RECURSE);
- if (!files) exit(0);
+ for (x = firstrecurse; x < argc; x++)
+ filecount += grokdir(argv[x], &files);
+ } else {
+ for (x = optind; x < argc; x++)
+ filecount += grokdir(argv[x], &files);
+ }
+
+ if (!files) {
+ if (!ISFLAG(flags, F_HIDEPROGRESS)) fprintf(stderr, "\r%40s\r", " ");
+ exit(0);
+ }
curfile = files;
while (curfile) {
if (!checktree)
-#ifndef EXPERIMENTAL_RBTREE
registerfile(&checktree, curfile);
-#else
- registerfile(&checktree, NULL, TREE_ROOT, curfile);
-#endif
else
match = checkmatch(&checktree, checktree, curfile);
curfile = curfile->next;
continue;
}
-
- file2 = fopen(match->d_name, "rb");
+
+ file2 = fopen((*match)->d_name, "rb");
if (!file2) {
fclose(file1);
curfile = curfile->next;
continue;
}
-
+
if (confirmmatch(file1, file2)) {
- match->hasdupes = 1;
- curfile->duplicates = match->duplicates;
- match->duplicates = curfile;
+ if (ISFLAG(flags, F_DELETEFILES) && ISFLAG(flags, F_IMMEDIATE))
+ deletesuccessor(match, curfile,
+ (ordertype == ORDER_TIME) ? sort_pairs_by_mtime : sort_pairs_by_filename );
+ else
+ registerpair(match, curfile,
+ (ordertype == ORDER_TIME) ? sort_pairs_by_mtime : sort_pairs_by_filename );
}
fclose(file1);
if (!ISFLAG(flags, F_HIDEPROGRESS)) fprintf(stderr, "\r%40s\r", " ");
- if (ISFLAG(flags, F_DELETEFILES)) autodelete(files);
- else printmatches(files);
+ if (ISFLAG(flags, F_DELETEFILES))
+ {
+ if (ISFLAG(flags, F_NOPROMPT))
+ {
+ deletefiles(files, 0, 0);
+ }
+ else
+ {
+ if (freopen("/dev/tty", "r", stdin) == 0)
+ {
+ errormsg("could not open terminal for input\n");
+ exit(1);
+ }
+
+ deletefiles(files, 1, stdin);
+ }
+ }
+
+ else
+
+ if (ISFLAG(flags, F_SUMMARIZEMATCHES))
+ summarizematches(files);
+
+ else
+
+ printmatches(files);
while (files) {
curfile = files->next;
free(files->d_name);
+ free(files->crcsignature);
+ free(files->crcpartial);
free(files);
files = curfile;
}
-
+
+ for (x = 0; x < argc; x++)
+ free(oldargv[x]);
+
+ free(oldargv);
+
purgetree(checktree);
return 0;
projects / platform / upstream / fdupes.git / commitdiff