win/ddeedduupp/ddeedduupp.cpp

// ddeedduupp.cpp : This file contains the 'main' function. Program execution begins and ends there.
//

#include <iostream>

int main()
{
    std::cout << "Hello World!\n";
}

// Run program: Ctrl + F5 or Debug > Start Without Debugging menu
// Debug program: F5 or Debug > Start Debugging menu

// Tips for Getting Started: 
//   1. Use the Solution Explorer window to add/manage files
//   2. Use the Team Explorer window to connect to source control
//   3. Use the Output window to see build output and other messages
//   4. Use the Error List window to view errors
//   5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
//   6. In the future, to open this project again, go to File > Open > Project and select the .sln file

#if 0
//----------------------------------------------------------------------------------------------------
//$Header$
//----------------------------------------------------------------------------------------------------
//qdedup.c
//----------------------------------------------------------------------------------------------------
//Quick and dirty program to eliminate duplicates from a file tree.  A file containing the SHA512
//hashes of all the files to be considered must already exist, and must be regenerated each time the
//underlying files are deleted/added/modified, which means the file must regenerated after each run
//of qdedup.  (WARNING:  IF YOU DO NOT REGENERATE THE FILE AFTER EACH RUN OF qdedup, YOU WILL
//PROBABLY DESTROY DATA.  THE MECHANISM WOULD BE THAT THE SHA512 MANIFEST IMPLIES THAT DUPLICATES
//EXIST WHEN THEY NO LONGER DO, SO qdedup WILL ERRONEOUSLY DELETE THE LAST COPIES OF FILES.)  The
//program will eliminate duplicates within a single specified directory or outside a single specified
//directory.
//
//This program will compile and run only on *nix systems and under Cygwin on Windows systems.
//----------------------------------------------------------------------------------------------------
//Copyright David T. Ashley (dashley@gmail.com), 2016.
//----------------------------------------------------------------------------------------------------
//Provided under the MIT LICENSE, reproduced immediately below.
//----------------------------------------------------------------------------------------------------
//Permission is hereby granted, free of charge, to any person obtaining a copy of
//this software and associated documentation files (the "Software"), to deal in the
//Software without restriction, including without limitation the rights to use,
//copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
//Software, and to permit persons to whom the Software is furnished to do so,
//subject to the following conditions:
//
//The above copyright notice and this permission notice shall be included in all
//copies or substantial portions of the Software.
//
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//SOFTWARE.
//----------------------------------------------------------------------------------------------------
//All paths in the SHA512 file must be absolute or must be relative to the current working directory
//at the time this program is run.
//
//The recommended method to generate the SHA512 file is using the "-exec" option of the "find"
//command, i.e.
//
//   find target_directory -type f -exec sha512sum {} \; >sha512sums.txt
//
//If any files are deleted by the program, a new SHA512 file must be generated before the program is
//run again to delete files.  The reason for this restriction is that the program will never knowingly
//delete the last copy of a file.  If the SHA512 file contains the digests of files that no longer
//exist, the program may unknowingly delete the last copies of files (because it believes based on
//the SHA512 file that other copies exist when in fact they do not).
//
//The SHA512 file does not need to be sorted (this program sorts it internally by hash before using it).
//
//This program is designed to compile and run under Cygwin or *nix only.
//
//Usage:
//   qdedup
//      Prints help information and exits.
//   qdedup ndups <sha512file>
//      Prints statistics about the number of duplicates in <sha512file>.
//   qdedup filterdups <sha512file>
//      Analyzes duplicates and prints the filenames of groups of duplicates.  The output is designed
//      for hand analysis so that insight can be gained into what duplicates exist and where they
//      are located.
//   qdedup dedup_preserve_inside <sha512file> <path>
//      For each group of duplicates that exists, preserves the duplicates that exist within path
//      and removes all others.  If no copies of the duplicate exist within path, no copies of the
//      duplicate will be removed.
//   qdedup dryrun_preserve_inside <sha512file> <path>
//      Exactly like "dedup_preserve_inside", except that no files will be deleted.  Text will be
//      output to explain what would be deleted by "dedup_preserve_inside".
//   qdedup dedup_nopath <sha512file>
//      For each group of duplicates that exists, preserves only the first (the only with lowest
//      sort-order filename).
//   qdedup dryrun_nopath <sha512file> <path>
//      Exactly like "dedup_nopath", except that no files will be deleted.  Text will be
//      output to explain what would be deleted by "dedup_nopath".
//   qdedup dedup_preserve_outside <sha512file> <path>
//      For each group of duplicates that exists, deletes duplicates only from within the specified
//      path.  If any duplicates do not have at least one copy within <path> no instances of the
//      duplicate are deleted.
//   qdedup dryrun_preserve_outside <sha512file>
//      Exactly like "dedup_preserve_outside", except that no files will be deleted.  Text will be
//      output to explain what would be deleted by "dedup_preserve_outside".
//----------------------------------------------------------------------------------------------------
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
//----------------------------------------------------------------------------------------------------
#define LINELEN           (78)  //Number of printable characters in a line.
#define MAXLINELEN      (2000)  //The maximum number of characters that may be in a line of the
                                                                //SHA512 input file.  This count includes the \0 terminator, so only
                                                                //this value minus 1 characters may be in a line.
#define UNLINKPAUSETIME  (0.1)  //Number of seconds to pause between file unlinks (deletions).  This
                                                                //is designed to give the user time to abort the program if desired
                                                                //before catastrophic quantities of files are deleted.
//----------------------------------------------------------------------------------------------------
//Data structure that holds the character representation of and SHA512 hash, plus the specified
//filename.
typedef struct
{
        char hash[129];
        //512/4 = 128 characters for the hash, plus 1 character for zero terminator.
        char* fname;
        //Filename as specified in the file, allocated via malloc() family.
} tFileHashRecord;
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//-----  CHARACTER CLASSIFICATION FUNCTIONS  ---------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//TRUE if character is part of valid hash.
int is_valid_hash_char(char c)
{
        switch (c)
        {
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
        case 'a':
        case 'b':
        case 'c':
        case 'd':
        case 'e':
        case 'f':
                return(1);
                break;
        default:
                return(0);
                break;
        }
}
//----------------------------------------------------------------------------------------------------
//TRUE if character is part of newline sequence
int is_newline_sequence_char(char c)
{
        switch (c)
        {
        case 13:
        case 10:
                return(1);
                break;
        default:
                return(0);
                break;
        }
}

//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//-----  FORMATTED OUTPUT FUNCTIONS  -----------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//Repeats a character to a stream a specified number of times.
//
void stream_rep_char(FILE* s, char c, unsigned n)
{
        while (n--)
        {
                fprintf(s, "%c", c);
        }
}
//----------------------------------------------------------------------------------------------------
//Prints a horizontal line to a stream, including the newline.
//
void stream_hline(FILE* s)
{
        stream_rep_char(s, '-', LINELEN);
        fprintf(s, "\n");
}
//----------------------------------------------------------------------------------------------------
//Prints a horizontal line to a stdout, including the newline.
//
void stdout_hline(void)
{
        stream_rep_char(stdout, '-', LINELEN);
        fprintf(stdout, "\n");
}
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//-----  FATAL ERROR FUNCTIONS  ----------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//Errors out fatally.
//
void fatal(const char* desc, const char* file, unsigned line)
{
        stdout_hline();
        printf("Fatal error:  %s\n", desc);
        printf("Source file:  %s\n", file);
        printf("Line       :  %u\n", line);
        stdout_hline();
        exit(1);
}
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//-----  MEMORY ALLOCATION WRAPPERS  -----------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//malloc() wrapper.
void* w_malloc(size_t nbytes)
{
        void* rv;

        if (!nbytes)
        {
                fatal("Memory allocation request for 0 bytes.", __FILE__, __LINE__);
        }

        rv = malloc(nbytes);

        if (!rv)
        {
                fatal("Out of memory in malloc() request.", __FILE__, __LINE__);
        }

        //Zero out, just for consistency.
        memset(rv, 0, nbytes);
}
//----------------------------------------------------------------------------------------------------
//realloc() wrapper.
void* w_realloc(void* p, size_t n)
{
        void* rv;

        if (!n)
        {
                fatal("Memory reallocation request for 0 bytes.", __FILE__, __LINE__);
        }

        if (!p)
        {
                fatal("Memory reallocation request with NULL pointer.", __FILE__, __LINE__);
        }

        rv = realloc(p, n);

        if (!rv)
        {
                fatal("Out of memory in realloc() request.", __FILE__, __LINE__);
        }
}
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//-----  SLEEP FUNCTIONS  ----------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//Sleep for a time, in seconds.
void w_sleep(double seconds)
{
        struct timespec t;

        if (seconds < 0)
        {
                fatal("Sleep for negative time request.", __FILE__, __LINE__);
        }
        else if (seconds > 3600)
        {
                fatal("Sleep for too long request.", __FILE__, __LINE__);
        }

        t.tv_sec = floor(seconds);
        t.tv_nsec = (seconds - floor(seconds)) * 1E9;

        nanosleep(&t, NULL);
}
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//-----  SHA512 FIELD READ FUNCTIONS  ----------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//These functions read in an individual field of a standard SHA512 file generated using application
//of the standard sha512sum program.
//
//*rcode = 1, success.
//         0, legal end of file, record assigned.
void get_sha512file_line(FILE* s, int* rcode, tFileHashRecord* hash_rec)
{
        unsigned bidx;
        unsigned nchars;
        int ic;
        int exitflag;
        int eoffound;
        int eolfound;
        char c;
        char buf[MAXLINELEN];

        //Zero out the buffer.  This handles string termination automatically.
        memset(buf, 0, sizeof(buf));

        //Read characters into the buffer until either hit EOF, newline, or can't
        //fill the buffer any longer.
        eoffound = 0;
        eolfound = 0;
        exitflag = 0;
        bidx = 0;
        do
        {
                ic = fgetc(s);
                c = ic;

                if (ic == EOF)
                {
                        eoffound = 1;
                        eolfound = 0;
                        nchars = bidx;
                        exitflag = 1;
                }
                else if (is_newline_sequence_char(c))
                {
                        eoffound = 0;
                        eolfound = 1;
                        nchars = bidx;
                        exitflag = 1;
                }
                else if (bidx >= (MAXLINELEN - 1))
                {
                        fatal("SHA512 hash file line too long to parse.", __FILE__, __LINE__);
                }
                else
                {
                        buf[bidx] = c;
                        bidx++;
                        exitflag = 0;
                }
        } while (!exitflag);

        //If we encountered a newline, inch past it.  We may encounter an EOF.
        if (eolfound)
        {
                exitflag = 0;
                do
                {
                        ic = fgetc(s);
                        c = ic;

                        if (ic == EOF)
                        {
                                eoffound = 1;
                                eolfound = 0;
                                exitflag = 1;
                        }
                        else if (is_newline_sequence_char(c))
                        {
                                exitflag = 0;
                        }
                        else
                        {
                                //We hit the next line.  Put the character back.
                                eoffound = 0;
                                eolfound = 1;
                                ungetc(ic, s);
                                exitflag = 1;
                        }
                } while (!exitflag);
        }

        //For better or worse, we have a \0-terminated line in the buffer.
        //
        //Zero the caller's area.  This takes care of the hash terminator as well.
        memset(hash_rec, 0, sizeof(*hash_rec));

        //Ensure that we have at least 128 characters, and they are all hex characters.
        //Otherwise, we can't proceed.
        if (nchars < 128)
        {
                fatal("SHA512 hash file line too short.", __FILE__, __LINE__);
        }
        else
        {
                for (bidx = 0; bidx < 128; bidx++)
                {
                        if (!is_valid_hash_char(buf[bidx]))
                        {
                                fatal("Character in SHA512 hash portion of line inconsistent with hash.", __FILE__, __LINE__);
                        }
                }
        }

        //The 129th and 130'th character must be present and must be a space and asterisk, respectively.
        if (nchars < 130)
        {
                fatal("SHA512 hash file line too short.", __FILE__, __LINE__);
        }
        else if (buf[128] != ' ')
        {
                fatal("129th hash line character must be \" \".", __FILE__, __LINE__);
        }
        else if (buf[129] != '*')
        {
                fatal("130th hash line character must be \"*\".", __FILE__, __LINE__);
        }
        //   else if (buf[129] != ' ')
        //   {
        //      //130th character is ' '.  Need to figure out why sometimes space and sometimes '*'.
        //      fatal("130th hash line character must be \" \".", __FILE__, __LINE__);
        //   }

           //There must be a 131'st character.  Beyond that, we can't qualify, because filenames may
           //have odd characters and may be of any length.
        if (nchars < 131)
        {
                fatal("SHA512 hash file line too short.", __FILE__, __LINE__);
        }

        //Copy the hash to the caller's area.  The terminator has already been inserted.
        memcpy(&(hash_rec->hash[0]), buf, 128);

        //Allocate space for the filename.
        hash_rec->fname = w_malloc(strlen(buf + 130) + 1);

        //Make the copy.
        strcpy(hash_rec->fname, buf + 130);

        if (eoffound)
                * rcode = 0;
        else
                *rcode = 1;
}
//----------------------------------------------------------------------------------------------------
void parseinputfile(tFileHashRecord** parsed_recs, unsigned* count, char* fname)
{
        FILE* s;
        int rcode;

        //Try to open the file for reading.  Inability is a failure.
        s = fopen(fname, "r");
        if (!s)
        {
                fatal("Hash file open failure.", __FILE__, __LINE__);
        }

        //Start off with a count of 0 and a NULL pointer.
        *count = 0;
        *parsed_recs = NULL;

        do
        {
                //For the first time, allocate space for one record.  Beyond that,
                //expand it.
                if (!*parsed_recs)
                {
                        *parsed_recs = w_malloc(sizeof(tFileHashRecord));
                }
                else
                {
                        *parsed_recs = w_realloc(*parsed_recs, (size_t)((*count + 1)) * sizeof(tFileHashRecord));
                }

                //Parse and fill in the space.
                get_sha512file_line(s, &rcode, (*parsed_recs) + (*count));

                //We now have one more.
                (*count)++;
        } while (rcode == 1);

        //Try to close the file.  Inability is a failure.
        if (fclose(s))
        {
                fatal("Hash file close failure.", __FILE__, __LINE__);
        }
}
//----------------------------------------------------------------------------------------------------
int sortcmpascendinghash(const void* p0_in, const void* p1_in)
{
        const tFileHashRecord* p0, * p1;

        p0 = p0_in;
        p1 = p1_in;

        return(strcmp(p0->hash, p1->hash));
}

//----------------------------------------------------------------------------------------------------
void sortinternaldsbyhash(tFileHashRecord* parsed_recs, unsigned count)
{
        qsort(parsed_recs, count, sizeof(tFileHashRecord), sortcmpascendinghash);
}
//----------------------------------------------------------------------------------------------------
int sortcmpascendingfname(const void* p0_in, const void* p1_in)
{
        const tFileHashRecord* p0, * p1;

        p0 = p0_in;
        p1 = p1_in;

        return(strcmp(p0->fname, p1->fname));
}
//----------------------------------------------------------------------------------------------------
//This sort has to be run after the hash sort.  Within groups of identical hashes, it sorts by 
//ascending filename.
void sortinternalgroupfname(tFileHashRecord* parsed_recs, unsigned count)
{
        unsigned ui;
        unsigned i_group_min, i_group_max;

        if (!count)
                return;

        i_group_min = 0;
        i_group_max = 0;

        do
        {
                //Advance i_group_max to the end of the group of duplicates.
                while ((i_group_max < (count - 1)) && (!strcmp(parsed_recs[i_group_min].hash, parsed_recs[i_group_max + 1].hash)))
                {
                        i_group_max++;
                }

                if (i_group_min != i_group_max)
                {
                        //Sort the internal group.
                        qsort(parsed_recs + i_group_min,
                                i_group_max - i_group_min + 1,
                                sizeof(tFileHashRecord),
                                sortcmpascendingfname);
                }

                //On to the next group.
                i_group_max++;
                i_group_min = i_group_max;

        } while (i_group_max < (count - 1));
}
//----------------------------------------------------------------------------------------------------
void printsinglerecord(tFileHashRecord* rec, unsigned elno)
{
        printf("[%9u]\n", elno);
        printf("Hash       : %s\n", rec->hash);
        printf("Filename   : %s\n", rec->fname);
        stdout_hline();
}
//----------------------------------------------------------------------------------------------------
void printinternalds(tFileHashRecord* parsed_recs, unsigned count)
{
        unsigned i;

        for (i = 0; i < count; i++)
        {
                printsinglerecord(parsed_recs + i, i);
        }
}
//----------------------------------------------------------------------------------------------------
void gather_dup_stats(tFileHashRecord* parsed_recs, unsigned count, unsigned* out_num_dups, unsigned* out_cumulative_dups)
{
        unsigned i_group_min, i_group_max;

        *out_num_dups = 0;
        *out_cumulative_dups = 0;

        if (!count)
                return;

        i_group_min = 0;
        i_group_max = 0;

        do
        {
                //Advance i_group_max to the end of the group of duplicates.
                while ((i_group_max < (count - 1)) && (!strcmp(parsed_recs[i_group_min].hash, parsed_recs[i_group_max + 1].hash)))
                {
                        i_group_max++;
                }

                //Log the findings.
                if (i_group_min != i_group_max)
                {
                        (*out_num_dups)++;
                        (*out_cumulative_dups) += (i_group_max - i_group_min + 1);
                }

                //On to the next group.
                i_group_max++;
                i_group_min = i_group_max;

        } while (i_group_max < (count - 1));
}
//----------------------------------------------------------------------------------------------------
void option_dups(char* fname)
{
        tFileHashRecord* parsed_recs;
        unsigned count, num_dups, cumulative_dups;

        parseinputfile(&parsed_recs, &count, fname);
        //printf("%u records parsed.\n", count);
        sortinternaldsbyhash(parsed_recs, count);
        sortinternalgroupfname(parsed_recs, count);
        printinternalds(parsed_recs, count);
        stdout_hline();
        gather_dup_stats(parsed_recs, count, &num_dups, &cumulative_dups);
        printf("Number of duplicated files  : %u\n", num_dups);
        if (num_dups)
        {
                printf("Average number of duplicates: %.2f\n", (double)cumulative_dups / (double)num_dups);
        }
}
//----------------------------------------------------------------------------------------------------
void option_filterdups(char* fname)
{
        tFileHashRecord* parsed_recs;
        unsigned dupgroup;
        unsigned count;
        unsigned ui;
        unsigned i_group_min, i_group_max;

        parseinputfile(&parsed_recs, &count, fname);
        //printf("%u records parsed.\n", count);
        sortinternaldsbyhash(parsed_recs, count);
        sortinternalgroupfname(parsed_recs, count);

        if (!count)
                return;

        dupgroup = 0;
        i_group_min = 0;
        i_group_max = 0;

        do
        {
                //Advance i_group_max to the end of the group of duplicates.
                while ((i_group_max < (count - 1)) && (!strcmp(parsed_recs[i_group_min].hash, parsed_recs[i_group_max + 1].hash)))
                {
                        i_group_max++;
                }

                //Print the findings.
                if (i_group_min != i_group_max)
                {
                        printf("Duplicate group %u:\n", dupgroup);
                        for (ui = i_group_min; ui <= i_group_max; ui++)
                        {
                                printf("%s\n", parsed_recs[ui].fname);
                        }

                        dupgroup++;

                        stdout_hline();
                }

                //On to the next group.
                i_group_max++;
                i_group_min = i_group_max;

        } while (i_group_max < (count - 1));
}
//----------------------------------------------------------------------------------------------------
//Returns true if the filename is within the specified path, or false otherwise.
int is_path_member(const char* fname, const char* path)
{
        if (strlen(fname) == 0)
        {
                fatal("Zero-length filename.", __FILE__, __LINE__);
        }
        else if (strlen(path) == 0)
        {
                fatal("Zero-length path.", __FILE__, __LINE__);
        }
        else if (path[strlen(path) - 1] != '/')
        {
                fatal("Paths must canonically end with forward slash character.", __FILE__, __LINE__);
        }
        else if (strlen(fname) <= strlen(path))
        {
                //Can't be in the path because filename is not longer than path name.
                return 0;
        }
        else if (memcmp(fname, path, strlen(path)) == 0)
        {
                return 1;
        }
        else
        {
                return 0;
        }
}
//----------------------------------------------------------------------------------------------------
void option_dedup(char* fname, char* path, int may_delete, double pause_time)
{
        tFileHashRecord* parsed_recs;
        unsigned dupgroup;
        unsigned count;
        unsigned ui;
        unsigned within_path;
        unsigned i_group_min, i_group_max;

        parseinputfile(&parsed_recs, &count, fname);
        //printf("%u records parsed.\n", count);
        sortinternaldsbyhash(parsed_recs, count);
        sortinternalgroupfname(parsed_recs, count);

        if (!count)
                return;

        dupgroup = 0;
        i_group_min = 0;
        i_group_max = 0;

        do
        {
                //Advance i_group_max to the end of the group of duplicates.
                while ((i_group_max < (count - 1)) && (!strcmp(parsed_recs[i_group_min].hash, parsed_recs[i_group_max + 1].hash)))
                {
                        i_group_max++;
                }

                //If this is a group of duplicates.
                if (i_group_min != i_group_max)
                {
                        //Print the findings.
                        printf("Duplicate group %u:\n", dupgroup);
                        for (ui = i_group_min; ui <= i_group_max; ui++)
                        {
                                printf("%s\n", parsed_recs[ui].fname);
                        }

                        dupgroup++;

                        stdout_hline();

                        //Count how many of the group of duplicates are within the supplied path.
                        within_path = 0;
                        for (ui = i_group_min; ui <= i_group_max; ui++)
                        {
                                if (is_path_member(parsed_recs[ui].fname, path))
                                {
                                        within_path++;
                                }
                        }

                        //We have to take different actions based on whether we do or don't have any within path.
                        //If we don't have any, we may delete nothing.
                        if (!within_path)
                        {
                                printf("None of these duplicates in path--taking no action.\n");
                                //stdout_hline();
                        }
                        else
                        {
                                for (ui = i_group_min; ui <= i_group_max; ui++)
                                {
                                        if (is_path_member(parsed_recs[ui].fname, path))
                                        {
                                                printf("Not deleting: %s\n", parsed_recs[ui].fname);
                                        }
                                        else
                                        {
                                                printf("Deleting    : %s\n", parsed_recs[ui].fname);
                                                if (may_delete)
                                                {
                                                        if (!unlink(parsed_recs[ui].fname))
                                                        {
                                                                printf("   File deleted (unlinked) successfully.\n");
                                                        }
                                                        else
                                                        {
                                                                printf("   Failure attempting to delete (unlink) file.\n");
                                                        }
                                                }
                                                else
                                                {
                                                        printf("   Dry run only.\n");
                                                }
                                        }

                                        //w_sleep(pause_time);
                                }
                        }

                        stdout_hline();
                }

                //On to the next group.
                i_group_max++;
                i_group_min = i_group_max;

        } while (i_group_max < (count - 1));
}
//----------------------------------------------------------------------------------------------------
int main(int argc, char* argv[])
{
        stdout_hline();
        printf("Execution begins.\n");
        stdout_hline();

        if (argc == 1)
        {
        }
        else if ((argc == 3) && (strcmp(argv[1], "ndups") == 0))
        {
                option_dups(argv[2]);
        }
        else if ((argc == 3) && (strcmp(argv[1], "filterdups") == 0))
        {
                option_filterdups(argv[2]);
        }
        else if ((argc == 3) && (strcmp(argv[1], "dedup_nopath") == 0))
        {
                //option_filterdups(argv[2]);
        }
        else if ((argc == 3) && (strcmp(argv[1], "dryrun_nopath") == 0))
        {
                //option_filterdups(argv[2]);
        }
        else if ((argc == 4) && (strcmp(argv[1], "dedup_preserve_inside") == 0))
        {
                option_dedup(argv[2], argv[3], 1, UNLINKPAUSETIME);
        }
        else if ((argc == 4) && (strcmp(argv[1], "dryrun_preserve_inside") == 0))
        {
                option_dedup(argv[2], argv[3], 0, UNLINKPAUSETIME / 10.0);
        }
        else
        {
                printf("Unrecognized parameter form.  Try \"dedup\".\n");
        }

        //w_sleep(-3 /* UNLINKPAUSETIME*/ );

        //stdout_hline();
        printf("Execution ends.\n");
        stdout_hline();

        return 0;
}
//----------------------------------------------------------------------------------------------------
#endif
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision URL Header