xfarrow
/
dircomp
mirror of https://github.com/xfarrow/dircomp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

1.0

This commit is contained in:
Alessandro Ferro 2023-04-14 22:36:09 +02:00
parent a20a35deda
commit dd9c17e284
2 changed files with 157 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

266
dircomp.c
View File

@ -6,101 +6,124 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
*/ */
# include "dircomp.h" #include "dircomp.h"
int main(int argc, char* argv[]){ int main(int argc, char *argv[])
{
struct arguments arguments = get_arguments(argc, argv); struct arguments arguments = get_arguments(argc, argv);
if(arguments.h == true){ if (arguments.h == true)
{
print_help(); print_help();
return 0; return 0;
} }
if(analyze_directories(&arguments)){
char* directory_to_analyze1 = malloc(strlen(arguments.directory1) * sizeof(char));
char* directory_to_analyze2 = malloc(strlen(arguments.directory2) * sizeof(char));
strcpy(directory_to_analyze1, arguments.directory1);
strcpy(directory_to_analyze2, arguments.directory2);
if (analyze_directories(directory_to_analyze1, directory_to_analyze2, &arguments))
{
printf("Directories are equal\n"); printf("Directories are equal\n");
} }
else{ else
{
printf("Directories are not equal\n"); printf("Directories are not equal\n");
} }
return 0; return 0;
} }
struct arguments get_arguments(int argc, char** argv){ struct arguments get_arguments(int argc, char **argv)
{
struct arguments provided_arguments = {"", "", false, false, false}; struct arguments provided_arguments = {"", "", false, false, false};
char option; char option;
while((option = getopt(argc, argv, "rnsvh")) != -1){ while ((option = getopt(argc, argv, "rnsvh")) != -1)
switch(option){ {
case 'r': switch (option)
provided_arguments.r = true; {
break; case 'r':
case 'v': provided_arguments.r = true;
provided_arguments.v = true; break;
break; case 'v':
case 'h': provided_arguments.v = true;
provided_arguments.h = true; break;
break; case 'h':
provided_arguments.h = true;
break;
} }
} }
// Get directories // Get directories
if( (argc - optind) < 2 ){ if ((argc - optind) < 2)
fprintf (stderr, "Not enough directories.\n"); {
exit(-1); fprintf(stderr, "Not enough directories.\n");
exit(-1);
} }
else if( (argc - optind) > 2 ){ else if ((argc - optind) > 2)
fprintf (stderr, "Too many directories.\n"); {
exit(-1); fprintf(stderr, "Too many directories.\n");
exit(-1);
} }
provided_arguments.directory1 = malloc( (strlen(argv[optind]) * sizeof(char)) + 1); provided_arguments.directory1 = malloc((strlen(argv[optind]) * sizeof(char)) + 1);
strcpy(provided_arguments.directory1, argv[optind]); strcpy(provided_arguments.directory1, argv[optind]);
provided_arguments.directory2 = malloc( (strlen(argv[optind + 1]) * sizeof(char)) + 1); provided_arguments.directory2 = malloc((strlen(argv[optind + 1]) * sizeof(char)) + 1);
strcpy(provided_arguments.directory2, argv[optind + 1]); strcpy(provided_arguments.directory2, argv[optind + 1]);
return provided_arguments; return provided_arguments;
} }
bool analyze_directories(struct arguments* arguments){ bool analyze_directories(char* directory_to_analyze_1, char* directory_to_analyze_2, struct arguments *arguments)
if(arguments -> v == true) {
printf("\nAnalyzing directories %s %s\n", arguments -> directory1, arguments -> directory2); if (arguments->v == true)
printf("\nAnalyzing directories %s %s\n", directory_to_analyze_1, directory_to_analyze_2);
bool is_directory_equal = true; bool is_directory_equal = true;
char fullpath[512]; int stat_result;
struct dirent* element; char fullpath_file_helper[512];
char* subdirectory1;
char* subdirectory2;
struct dirent *element;
DIR *directory; DIR *directory;
// Open directory 1 // Open directory 1
directory = opendir(arguments -> directory1); directory = opendir(directory_to_analyze_1);
if (directory) { if (directory)
while ((element = readdir(directory)) != NULL) { {
while ((element = readdir(directory)) != NULL)
{
// Is file // Is file
if (element -> d_type == DT_REG) if (element->d_type == DT_REG)
{ {
// Check wether it exists in directory2 // Check wether it exists in directory2
strcpy(fullpath, arguments -> directory2); strcpy(fullpath_file_helper, directory_to_analyze_2);
strcat(fullpath, "/"); strcat(fullpath_file_helper, "/");
strcat(fullpath, element -> d_name); strcat(fullpath_file_helper, element->d_name);
if( access(fullpath, F_OK ) == -1 ) if (access(fullpath_file_helper, F_OK) == -1)
{ {
is_directory_equal = false; is_directory_equal = false;
if(arguments -> v == true) if (arguments->v == true)
printf("File %s exists in %s but does not in %s\n" , element -> d_name printf("File %s exists in %s but does not in %s\n" , element->d_name
, arguments -> directory1 , directory_to_analyze_1
, arguments -> directory2); , directory_to_analyze_2);
} }
// Check if files have the same signature // Check if files have the same signature
else{ else
strcpy(fullpath, arguments -> directory1); {
strcat(fullpath, "/"); strcpy(fullpath_file_helper, directory_to_analyze_1);
strcat(fullpath, element -> d_name); strcat(fullpath_file_helper, "/");
unsigned char* hash_file_1 = get_sha1_file(fullpath); strcat(fullpath_file_helper, element->d_name);
strcpy(fullpath, arguments -> directory2); unsigned char *hash_file_1 = get_sha1_file(fullpath_file_helper);
strcat(fullpath, "/"); strcpy(fullpath_file_helper, directory_to_analyze_2);
strcat(fullpath, element -> d_name); strcat(fullpath_file_helper, "/");
unsigned char* hash_file_2 = get_sha1_file(fullpath); strcat(fullpath_file_helper, element->d_name);
if(strcmp(hash_file_1, hash_file_2) != 0){ unsigned char *hash_file_2 = get_sha1_file(fullpath_file_helper);
if (strcmp(hash_file_1, hash_file_2) != 0)
{
is_directory_equal = false; is_directory_equal = false;
if(arguments -> v == true) if (arguments->v == true)
printf("File %s in %s has a different signature in %s\n" , element->d_name printf("File %s in %s has a different signature in %s\n", element->d_name
, arguments->directory1 , directory_to_analyze_1
, arguments->directory2); , directory_to_analyze_2);
} }
free(hash_file_1); free(hash_file_1);
free(hash_file_2); free(hash_file_2);
@ -108,29 +131,44 @@ bool analyze_directories(struct arguments* arguments){
} }
// Is directory // Is directory
else if (element -> d_type == DT_DIR) else if (element->d_type == DT_DIR)
{ {
// Check wether it exists in directory2 if (strcmp(element->d_name, ".") == 0 || strcmp(element->d_name, "..") == 0)
strcpy(fullpath, arguments -> directory2); {
strcat(fullpath, "/"); continue;
strcat(fullpath, element -> d_name);
// Allocate heap memory in order to free it before a potential recursive call starts
struct stat* dummy_structure = malloc(sizeof(struct stat));
if(stat(fullpath, dummy_structure) == -1){
is_directory_equal = false;
if(arguments -> v == true)
printf("Sub-directory %s exists in %s but does not in %s\n" , element -> d_name
, arguments->directory1
, arguments->directory2);
} }
// Check wether a folder with the same name exists in directory2
strcpy(fullpath_file_helper, directory_to_analyze_2);
strcat(fullpath_file_helper, "/");
strcat(fullpath_file_helper, element->d_name);
// Allocate heap memory in order to be able to free it before a potential recursive call starts
struct stat *dummy_structure = malloc(sizeof(struct stat));
stat_result = stat(fullpath_file_helper, dummy_structure);
free(dummy_structure); free(dummy_structure);
if (stat_result == -1)
{
is_directory_equal = false;
if (arguments->v == true)
printf("Sub-directory %s exists in %s but does not in %s\n" , element->d_name
, directory_to_analyze_1
, directory_to_analyze_2);
}
// Analyze recursively // Analyze recursively
if(arguments -> r == true){ else
if(strcmp(element -> d_name, ".") == 0 || strcmp(element -> d_name, "..") == 0){ {
continue; if (arguments->r == true)
{
subdirectory1 = malloc(sizeof(char) * (strlen(directory_to_analyze_1) + strlen(element->d_name) + 2));
strcpy(subdirectory1, directory_to_analyze_1);
strcat(subdirectory1, "/");
strcat(subdirectory1, element->d_name);
subdirectory2 = malloc(sizeof(char) * (strlen(directory_to_analyze_2) + strlen(element->d_name) + 2));
strcpy(subdirectory2, directory_to_analyze_2);
strcat(subdirectory2, "/");
strcat(subdirectory2, element->d_name);
is_directory_equal = analyze_directories(subdirectory1, subdirectory2, arguments) && is_directory_equal;
} }
analyze_directories(arguments);
} }
} }
} }
@ -138,70 +176,76 @@ bool analyze_directories(struct arguments* arguments){
} }
// Open directory 2 // Open directory 2
directory = opendir(arguments -> directory2); directory = opendir(directory_to_analyze_2);
if (directory) if (directory)
{ {
while ((element = readdir(directory)) != NULL) while ((element = readdir(directory)) != NULL)
{ {
// Is file // Is file
if (element -> d_type == DT_REG) if (element->d_type == DT_REG)
{ {
// Check wether it exists in directory1 // Check wether it exists in directory1
strcpy(fullpath, arguments -> directory1); strcpy(fullpath_file_helper, directory_to_analyze_1);
strcat(fullpath, "/"); strcat(fullpath_file_helper, "/");
strcat(fullpath, element -> d_name); strcat(fullpath_file_helper, element->d_name);
if( access(fullpath, F_OK ) == -1 ) if (access(fullpath_file_helper, F_OK) == -1)
{ {
is_directory_equal = false; is_directory_equal = false;
if(arguments -> v == true) if (arguments->v == true)
printf("File %s exists in %s but does not in %s\n", element -> d_name printf("File %s exists in %s but does not in %s\n" , element->d_name
, arguments -> directory2 , directory_to_analyze_2
, arguments -> directory1); , directory_to_analyze_1);
} }
} }
// Is directory // Is directory
else if (element -> d_type == DT_DIR) else if (element->d_type == DT_DIR)
{ {
// Check wether it exists in directory1 // Check wether a folder with the same name exists in directory1
strcpy(fullpath, arguments -> directory1); strcpy(fullpath_file_helper, directory_to_analyze_1);
strcat(fullpath, "/"); strcat(fullpath_file_helper, "/");
strcat(fullpath, element -> d_name); strcat(fullpath_file_helper, element->d_name);
struct stat dummy_structure; // no need to be malloc-ed, as it'll be automatically free-d as the call ends struct stat dummy_structure; // no need to be malloc-ed, as it'll be automatically free-d as the call ends
if(stat(fullpath, &dummy_structure) == -1){ if (stat(fullpath_file_helper, &dummy_structure) == -1)
{
is_directory_equal = false; is_directory_equal = false;
if(arguments -> v == true) if (arguments->v == true)
printf("Sub-directory %s exists in %s but does not in %s\n" , element->d_name printf("Sub-directory %s exists in %s but does not in %s\n" , element->d_name
, arguments->directory2 , directory_to_analyze_2
, arguments->directory1); , directory_to_analyze_1);
} }
} }
} }
closedir(directory); closedir(directory);
} }
free(directory_to_analyze_1);
free(directory_to_analyze_2);
return is_directory_equal; return is_directory_equal;
} }
unsigned char* get_sha1_file(char *filename){ unsigned char *get_sha1_file(char *filename)
FILE* f = fopen(filename,"rb"); {
if(f == NULL){ FILE *f = fopen(filename, "rb");
fprintf (stderr, "Couldn't open %s\n", filename); if (f == NULL)
{
fprintf(stderr, "Couldn't open %s\n", filename);
exit(-1); exit(-1);
} }
// For a matter of efficiency, we do not read // For a matter of efficiency, we do not read
// the whole file at once. It'd be heavy on RAM. // the whole file at once. It'd be heavy on RAM.
// Instead, we read BYTES_TO_READ_AT_ONCE at time // Instead, we read BYTES_TO_READ_AT_ONCE at time
#define BYTES_TO_READ_AT_ONCE 1048576 // 1MiB #define BYTES_TO_READ_AT_ONCE 512000 // 500KiB
unsigned int bytes; // how many bytes we have actually read from fread unsigned int bytes; // how many bytes we have actually read from fread
#if BYTES_TO_READ_AT_ONCE > UINT_MAX #if BYTES_TO_READ_AT_ONCE > UINT_MAX
#error Trying to read more bytes than what is possible to handle. Recompile using unsigned long or reduce BYTES_TO_READ_AT_ONCE #error Trying to read more bytes than what is possible to handle. Recompile using unsigned long or reduce BYTES_TO_READ_AT_ONCE
#endif #endif
SHA_CTX context; SHA_CTX context;
unsigned char* hash = malloc(SHA_DIGEST_LENGTH * sizeof(unsigned char)); // result will be here unsigned char *hash = malloc(SHA_DIGEST_LENGTH * sizeof(unsigned char)); // result will be here
unsigned char databuffer[BYTES_TO_READ_AT_ONCE]; unsigned char databuffer[BYTES_TO_READ_AT_ONCE];
SHA1_Init(&context); SHA1_Init(&context);
while((bytes = fread(databuffer, 1, BYTES_TO_READ_AT_ONCE, f)) != 0){ while ((bytes = fread(databuffer, 1, BYTES_TO_READ_AT_ONCE, f)) != 0)
{
SHA1_Update(&context, databuffer, bytes); SHA1_Update(&context, databuffer, bytes);
} }
SHA1_Final(hash, &context); SHA1_Final(hash, &context);
@ -209,9 +253,11 @@ unsigned char* get_sha1_file(char *filename){
return hash; return hash;
} }
void print_help(void){ void print_help(void)
{
printf("Usage: dircomp directory1 directory2 [-r] [-v] [-h]\n\n"); printf("Usage: dircomp directory1 directory2 [-r] [-v] [-h]\n\n");
printf(" -r \t\t Recursive\n");; printf(" -r \t\t Recursive\n");
;
printf(" -v \t\t Verbose\n"); printf(" -v \t\t Verbose\n");
printf(" -h \t\t Print this help and quit\n\n"); printf(" -h \t\t Print this help and quit\n\n");
} }

2
dircomp.h
View File

@ -31,7 +31,7 @@ struct arguments{
struct arguments get_arguments(int, char**); struct arguments get_arguments(int, char**);
// Reference: https://www.gnu.org/software/libc/manual/html_node/Directory-Entries.html // Reference: https://www.gnu.org/software/libc/manual/html_node/Directory-Entries.html
bool analyze_directories(struct arguments*); bool analyze_directories(char*, char*, struct arguments*);
// Reference: https://www.openssl.org/docs/man1.1.1/man3/SHA512_Init.html // Reference: https://www.openssl.org/docs/man1.1.1/man3/SHA512_Init.html
unsigned char* get_sha1_file(char *); unsigned char* get_sha1_file(char *);