blah

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#include <sys/stat.h>
#include <dirent.h>



using namespace std;



int main(int argc, char *argv[]) {

    cout << endl << "--- ========= BCKUP%199 ========= ---" << endl << "\t-- running" << endl << endl;


    int x=0;
    int y=0;

    const int MAX = 2048;

    int is_regular_file(const char *path);


    char ch='z';
    char DESTINATION[MAX]; memset(DESTINATION,'\0',MAX);
    char SOURCE[MAX]; memset(SOURCE,'\0',MAX);

    char directories[3][MAX] = { "/home/vt1/Documents", "/opt/BACKUP", 0 };

    char COMMAND[MAX]; memset(COMMAND,'\0', MAX);

    char tar_command[MAX]; memset(tar_command,'\0', MAX);
    char zip7_command[MAX]; memset(zip7_command,'\0', MAX);

    strncpy(zip7_command, "7z a -bso0 -bsp0 '", (MAX-18));
    strncpy(tar_command, "tar -zcf '", (MAX-10));

    char tar_extension[8] = ".tar.gz";
    char zip7_extension[8] = ".7z";

    bool backup_dir_is_set=0;
    bool source_dir_is_set=0;

    bool swV=0;
    bool swT=0;
    bool swX=0;
    bool swQ=0;

    bool warn=0;




    // displays the command line arguments

    if (swV) {
        cout << "ARGV:" << "\tARGC: " << argc << endl << endl;

        for (int i=0; i<argc; i++) {
            cout << "- " << *(argv+i) << endl;
        }
    }

    // regulates the command line switches
    for (int i=0; i<argc; i++) {

        if (strlen(argv[i]) == 2 && *(argv+i)[0] == '-') {

            if (swV) {
                cout << "\t\tSUCCESS (" << argv[i] << ")" << endl;
            }

            switch (argv[i][1]) {
                case 'q': // quiet
                    swQ=1;

                    break;

                case 'v': // verbos
                    swV=1;

                    if (swV) {
                        cout << "- verbose" << endl;
                    }
                    break;

                case 't': // dry run
                    swT=1;

                    if (swV) {
                        cout << "- dry run ;; not actually backing up (-t)" << endl;
                    }
                    break;

                case 'x': // override backup directoru
                    swX=1;

                    if (((i+1) < argc) && swV) {
                        cout << "- FOUND DIR OVERRIDE SWITCH: " << argv[i] << endl;
                        cout << "\t-- changing backup dir" << endl;
                    }
                    break;


                default:

                    if (swV) {
                        cout << "-- unknown option" << "\t" << argv[i] << endl;
                    }
                    break;
            }
        }
        else {
            if ((i > 0) && strlen(argv[i]) >= 1 && *(argv+i)[0] != '-') {

                if (swV) {
                    cout << endl << "- looks like a directory" << endl;
                    cout << "\t-- dir: " << argv[i];
                }

                if (!source_dir_is_set && !swX) {

                    strncpy(SOURCE, argv[i], MAX);

                    if (swV) {
                        cout << "\t-- set" << endl << endl;
                    }

                    source_dir_is_set = 1;
                }
                else {

                    if ((i > 0) && swX && strlen(argv[i])>=1 && argv[i][0] != '-') {

                        if (!backup_dir_is_set) {
                            strncpy(DESTINATION, *(argv+i), (MAX));
                            cout << "\t-- set" << endl << endl;
                            backup_dir_is_set = 1;
                            swX=0;
                        }

                    }
                }
            }
        }
    } // end of FOR loop



    // check SOURCEDIR and BACKUPDIR
    if (!source_dir_is_set) { warn=1; strncpy(SOURCE,directories[0],MAX); source_dir_is_set=1; }
    if (!backup_dir_is_set) { strncpy(DESTINATION,directories[1],MAX); backup_dir_is_set=1; }


    if (warn && !swQ) {
        if (swV) {
            cout << "WARNING: SOURCE DIRECTORY WAS NOT SPECIFIED" << endl << "SOURCE DIR SET TO DEFAULT LOCATION: (( " << SOURCE << " ))" << endl << endl;
        }
    }

    if (!swQ) {
        cout << "SOURCE:\t\t" << SOURCE << endl;
        cout << "DESTINATION:\t" << DESTINATION << endl << endl;
    }

    if (swV) {
        cout << endl << "- Starting Backup Routine" << endl << "\t-- Check SOURCE and DESTINATION" << endl << endl;
    }

    if (swV) {
        cout << "- changing into SOURCE directory" << endl;
    }

    chdir(SOURCE);

    if (swV) {
        cout << "- reading context of SOURCE directory" << endl << endl;
    }

    // over here we go read the SOURCE directory
        // #include <dirent.h>

    string path = SOURCE; //Put a valid path here for folder

    DIR *directory = opendir(path.c_str());
    struct dirent *direntStruct;

    if (directory != NULL) {

        // generate system command in COMMAND[MAX]

        while (direntStruct = readdir(directory)) {

            if (strcmp(direntStruct->d_name,".") != 0 && strcmp(direntStruct->d_name,"..") != 0) {

                if (!swQ) {
                    cout << "- generate compression on files..." << endl;
                    cout << "\t-- " << direntStruct->d_name << endl;
                }

                strncpy(COMMAND, tar_command, (MAX - strlen(tar_command)));
                strncat(COMMAND, DESTINATION, (MAX - strlen(DESTINATION)));
                strncat(COMMAND, "/", 1);
                strncat(COMMAND, direntStruct->d_name, (MAX - strlen(direntStruct->d_name)));
                strncat(COMMAND, tar_extension, strlen(tar_extension));
                strncat(COMMAND, "' '", 3);
                //strncat(COMMAND, SOURCE, (MAX - strlen(SOURCE)));
                //strncat(COMMAND, "/", 1);
                strncat(COMMAND, direntStruct->d_name, strlen(direntStruct->d_name));
                strncat(COMMAND, "'", 1);

                if (swV) {
                    cout << "COMMAND:" << endl << "- " << COMMAND << endl << endl;
                }

                // use COMMAND and discard it
                if (!swT) {
                    system(COMMAND);
                }
                else { cout << "-- performing dry run" << endl; }

                // cleanup
                memset(COMMAND,'\0', MAX);
            }
        }

        closedir(directory);
    }

    if (!swQ) {
        cout << endl << "---------------------" << endl << "- BACKUP IS COMPLETED" << endl;
    }

    cout << endl;

    ch=0;

return 0;
}


// eof