int main(int argc, char** argv)
{
    int     ret = 0;
    int     option = 0;
    int     ignoreIn = 0;
    int     ignoreOut = 0;
    int     long_index = 0;
    int     i;

    if (argc == 1) {
        printf("Main Help.\n");
        wolfCLU_help();
    }
    /* Set ignore variables for -in and -out files */
    ret = wolfCLU_checkForArg("-in", 3, argc, argv);
    if (ret > 0) {
        ignoreIn = ret + 1;
    }
    ret = wolfCLU_checkForArg("-out", 4, argc, argv);
    if (ret > 0) {
        ignoreOut = ret + 1;
    }


    /* flexibility: allow users to input any CAPS or lower case,
     * we will do all processing on lower case only. */
    for (i = 0; i < argc; i++) {
        if (i != ignoreIn && i != ignoreOut) {
            convert_to_lower(argv[i], (int) XSTRLEN(argv[i]));
        }
    }

    while ((option = getopt_long_only(argc, argv,"",
                   long_options, &long_index )) != -1) {

        switch (option) {
            /* Encrypt */
            case ENCRYPT:  ret = wolfCLU_setup(argc, argv, 'e');
                            break;
            /* Decrypt */
            case DECRYPT:  ret = wolfCLU_setup(argc, argv, 'd');;
                            break;
            /* Benchmark */
            case BENCHMARK:ret = wolfCLU_benchSetup(argc, argv);
                            break;
            /* Hash */
            case HASH:     ret = wolfCLU_hashSetup(argc, argv);
                            break;
            /* x509 Certificate processing */
            case X509:     ret = wolfCLU_certSetup(argc, argv);
                            break;
            /* x509 Certificate request */
            case REQUEST:  ret = wolfCLU_requestSetup(argc, argv);
                            break;
            case GEN_KEY:  ret = wolfCLU_genKeySetup(argc, argv);
                            break;
/* Ignore the following arguments for now. Will be handled by their respective
 * setups IE Crypto setup, Benchmark setup, or Hash Setup */

            /* File passed in by user */
            case INFILE:    break;
            /* Output file */
            case OUTFILE:   break;
            /* Password */
            case PASSWORD:  break;
            /* Key if used must be in hex */
            case KEY:       break;
            /* IV if used must be in hex */
            case IV:        break;
            /* Opt to benchmark all available algorithms */
            case ALL:       break;
            /* size for hash to output */
            case SIZE:      break;
            /* Time to benchmark for 1-10 seconds optional default: 3s */
            case TIME:      break;
            /* Verify results, used with -iv and -key */
            case VERIFY:    break;
            /* Certificate Stuff*/
            case INFORM:    break;
            case OUTFORM:   break;
            case OUTPUT:    break;
            case NOOUT:     break;
            case TEXT_OUT:  break;
            case SILENT:    break;
            case HELP1:
                    if (argc == 2) {
                        printf("Main help menu:\n");
                        wolfCLU_help();
                        return 0;
                    }
                    break;
            case HELP2:
                    if (argc == 2) {
                        printf("Main help menu:\n");
                        wolfCLU_help();
                        return 0;
                    }
                    break;
            /* which version of clu am I using */
            case VERBOSE:
                            wolfCLU_verboseHelp();
                            return 0;
/*End of ignored arguments */

            case 'v':       wolfCLU_version();
                            return 0;

             default:
                            printf("Main help default.\n");
                            wolfCLU_help();
                            return 0;
        }
    }

    if (ret != 0)
        printf("Error returned: %d.\n", ret);

    return ret;
}
int wolfCLU_benchSetup(int argc, char** argv)
{
    int     ret     =   0;          /* return variable */
    int     time    =   3;          /* timer variable */
    int     i, j    =   0;          /* second loop variable */
    char*   algs[]  =   {           /* list of acceptable algorithms */
#ifndef NO_AES
        "aes-cbc",
#endif
#ifdef WOLFSSL_AES_COUNTER
        "aes-ctr",
#endif
#ifndef NO_DES3
        "3des",
#endif
#ifdef HAVE_CAMELLIA
        "camellia",
#endif
#ifndef NO_MD5
        "md5",
#endif
#ifndef NO_SHA
        "sha",
#endif
#ifndef NO_SHA256
        "sha256",
#endif
#ifdef WOLFSSL_SHA384
        "sha384",
#endif
#ifdef WOLFSSL_SHA512
        "sha512",
#endif
#ifdef HAVE_BLAKE2
        "blake2b",
#endif
        NULL /* terminal argument (also stops us from having an empty list) */
    };
    size_t algsSz = sizeof(algs) / sizeof(algs[0]) - 1; /* -1 to ignore NULL */

    /* acceptable options */
    int option[sizeof(algs) / sizeof(algs[0])] = {0};

    /* acceptable option check */
    int optionCheck = 0;

    ret = wolfCLU_checkForArg("-help", 5, argc, argv);
    if (ret > 0) {
            wolfCLU_benchHelp();
            return 0;
    }

    ret = wolfCLU_checkForArg("-time", 5, argc, argv);
    if (ret > 0) {
        /* time for each test in seconds */
        time = atoi(argv[ret+1]);
        if (time < 1 || time > 10) {
            printf("Invalid time, must be between 1-10. Using default"
                                            " of three seconds.\n");
            time = 3;
        }
    }

    ret = wolfCLU_checkForArg("-all", 4, argc, argv);
    if (ret > 0) {
        /* perform all available tests */
        for (j = 0; j < (int)algsSz; j++) {
            option[j] = 1;
            optionCheck = 1;
        }
    }

    /* pull as many of the algorithms out of the argv as posible */
    for (i = 0; i < (int)algsSz; ++i) {
        ret = wolfCLU_checkForArg(algs[i], XSTRLEN(algs[i]), argc, argv);
        if (ret > 0) {
            option[i] = 1;
            optionCheck = 1;
        }
    }

    if (optionCheck != 1) {
        wolfCLU_help();
        ret = 0;
    }
    else {
        /* benchmarking function */
        printf("\nTesting for %d second(s)\n", time);
        ret = wolfCLU_benchmark(time, option);
    }
    return ret;
}