full API updates to reflect design change

Author: kaleb-himes

Makefile.am

@@ -32,11 +32,11 @@ EXTRA_DIST+= tests
 EXTRA_DIST+= manpages
 EXTRA_DIST+= README.md
 
-man_MANS+= manpages/wolfsslBenchmark.1
-man_MANS+= manpages/wolfsslDecrypt.1
-man_MANS+= manpages/wolfsslEncrypt.1
-man_MANS+= manpages/wolfsslHash.1
-man_MANS+= manpages/wolfsslMain.1
+man_MANS+= manpages/wolfCLU_benchmark.1
+man_MANS+= manpages/wolfCLU_decrypt.1
+man_MANS+= manpages/wolfCLU_encrypt.1
+man_MANS+= manpages/wolfCLU_hash.1
+man_MANS+= manpages/wolfssl.1
 
 include clu_src/include.am
 include clu_include/include.am

clu_include/clu_header_main.h

@@ -94,53 +94,53 @@
  *
  * @param argc holds all command line input
  * @param argv each holds one value from the command line input
- * @param action forwarded from wolfsslMain (-e, -d, -h, or -b)
+ * @param action forwarded from wolfCLU_main (-e, -d, -h, or -b)
  */
-int wolfsslSetup(int argc, char** argv, char action);
+int wolfCLU_setup(int argc, char** argv, char action);
 
 /* hash argument function
  *
  * @param argc holds all command line input
  * @param argv each holds one value from the command line input
  */
-int wolfsslHashSetup(int argc, char** argv);
+int wolfCLU_hashSetup(int argc, char** argv);
 
 /* benchmark argument function
  *
  * @param argc holds all command line input
  * @param argv each holds one value from the command line input
  */
-int wolfsslBenchSetup(int argc, char** argv);
+int wolfCLU_benchSetup(int argc, char** argv);
 
 /* 
  * generic help function 
  */
-void wolfsslHelp(void);
+void wolfCLU_help(void);
 
 /* 
  * verbose help function 
  */
-void wolfsslVerboseHelp(void);
+void wolfCLU_verboseHelp(void);
 
 /* 
  * encrypt help function 
  */
-void wolfsslEncryptHelp(void);
+void wolfCLU_encryptHelp(void);
 
 /* 
  * decrypt help function
  */
-void wolfsslDecryptHelp(void);
+void wolfCLU_decryptHelp(void);
 
 /* 
  * hash help function 
  */
-void wolfsslHashHelp(void);
+void wolfCLU_hashHelp(void);
 
 /* 
  * benchmark help function
  */
-void wolfsslBenchHelp(void);
+void wolfCLU_benchHelp(void);
 
 /* find algorithm for encryption/decryption 
  * 
@@ -149,40 +149,40 @@ void wolfsslBenchHelp(void);
  * @param mode the mode as set by the user (cbc or ctr)
  * @param size set based on the algorithm specified
  */
-int wolfsslGetAlgo(char* name, char** alg, char** mode, int* size);
+int wolfCLU_getAlgo(char* name, char** alg, char** mode, int* size);
 
 /* generates key based on password provided 
  * 
  * @param rng the random number generator
  * @param pwdKey the password based key as provided by the user
- * @param size size as determined by wolfsslGetAlgo
+ * @param size size as determined by wolfCLU_GetAlgo
  * @param salt the buffer to store the resulting salt after it's generated
  * @param pad a flag to let us know if there are padded bytes or not
  */
-int wolfsslGenKey(RNG* rng, byte* pwdKey, int size, byte* salt, int pad);
+int wolfCLU_genKey(RNG* rng, byte* pwdKey, int size, byte* salt, int pad);
 
 /* secure entry of password 
  *
  * @param pwdKey the password provide by the user
- * @param size the size as determnined by wolfsslGetAlgo
+ * @param size the size as determnined by wolfCLU_GetAlgo
  */
-int wolfsslNoEcho(char* pwdKey, int size);
+int wolfCLU_noEcho(char* pwdKey, int size);
 
 /* adds characters to end of string
  *
  * @param s the char array we'll be appending to
  * @param c the char that will be appended to s
  */
-void wolfsslAppend(char* s, char c);
+void wolfCLU_append(char* s, char c);
 
 /* interrupt function
  *
  * @param signo gets type cast to void, interrupts the loop.
  */
-void wolfsslStop(int signo);
+void wolfCLU_stop(int signo);
 
 /* finds current time during runtime */
-double wolfsslGetTime(void);
+double wolfCLU_getTime(void);
 
 /* A function to convert from Hex to Binary
  *
@@ -199,7 +199,7 @@ double wolfsslGetTime(void);
  * @param b3Sz a word32 that will be set after conversion of b3, can be NULL
  * @param b4Sz a word32 that will be set after conversion of b4, can be NULL
  */
-int wolfsslHexToBin(const char* h1, byte** b1, word32* b1Sz,
+int wolfCLU_hexToBin(const char* h1, byte** b1, word32* b1Sz,
                     const char* h2, byte** b2, word32* b2Sz,
                     const char* h3, byte** b3, word32* b3Sz,
                     const char* h4, byte** b4, word32* b4Sz);
@@ -212,14 +212,14 @@ int wolfsslHexToBin(const char* h1, byte** b1, word32* b1Sz,
  * @param b4 a buffer to be freed, can be set to NULL
  * @param b5 a buffer to be freed, can be set to NULL
  */
-void wolfsslFreeBins(byte* b1, byte* b2, byte* b3, byte* b4, byte* b5);
+void wolfCLU_freeBins(byte* b1, byte* b2, byte* b3, byte* b4, byte* b5);
 
 /* function to display stats results from benchmark
  *
  * @param start the time when the benchmark was started
  * @param blockSize the block size of the algorithm being benchmarked
  */
-void wolfsslStats(double start, int blockSize, int64_t blocks);
+void wolfCLU_stats(double start, int blockSize, int64_t blocks);
 
 /* encryption function
  *
@@ -230,15 +230,15 @@ void wolfsslStats(double start, int blockSize, int64_t blocks);
  * @param pwdKey this is the user provided password to be used as the key
  * @param key if entered must be in hex, can be used to verify encryption with
  *            nist test vectors.
- * @param size this is set by wolfsslGetAlgo and is used to stretch the password
+ * @param size this is set by wolfCLU_GetAlgo and is used to stretch the password
  * @param in the filename or user input from command line
  * @param out the filename to output following en/de cryption
  * @param iv if entered must be in hex otherwise generated at run time
  * @param block size of block as determined by the algorithm being used
  * @param ivCheck a flag if user inputs a specific IV
  * @param inputHex a flag to specify encrypting hex data, instead of byte data
  */
-int wolfsslEncrypt(char* alg, char* mode, byte* pwdKey, byte* key, int size, 
+int wolfCLU_encrypt(char* alg, char* mode, byte* pwdKey, byte* key, int size, 
 								char* in, char* out, byte* iv, int block, 
                                 int ivCheck, int inputHex);
 
@@ -251,23 +251,23 @@ int wolfsslEncrypt(char* alg, char* mode, byte* pwdKey, byte* key, int size,
  * @param pwdKey this is the user provided password to be used as the key
  * @param key if entered must be in hex, can be used to verify encryption with
  *            nist test vectors.
- * @param size this is set by wolfsslGetAlgo and is used to stretch the password
+ * @param size this is set by wolfCLU_GetAlgo and is used to stretch the password
  * @param in the filename or user input from command line
  * @param out the filename to output following en/de cryption
  * @param iv if entered must be in hex otherwise generated at run time
  * @param block size of block as determined by the algorithm being used
  * @param keyType let's decrypt know if it's using a password based key or a 
  *        hexidecimal, user specified key.
  */
-int wolfsslDecrypt(char* alg, char* mode, byte* pwdKey, byte* key, int size, 
+int wolfCLU_decrypt(char* alg, char* mode, byte* pwdKey, byte* key, int size, 
 						char* in, char* out, byte* iv, int block, int keyType);
 
 /* benchmarking function 
  *
  * @param timer a timer to be started and stopped for benchmarking purposes
  * @param option a flag to allow benchmark execution
  */
-int wolfsslBenchmark(int timer, int* option);
+int wolfCLU_benchmark(int timer, int* option);
 
 /* hashing function 
  *
@@ -277,11 +277,11 @@ int wolfsslBenchmark(int timer, int* option);
  * @param alg
  * @param size
  */
-int wolfsslHash(char* in, char* out, char* alg, int size);
+int wolfCLU_hash(char* in, char* out, char* alg, int size);
 /*
  * get the current Version
  */
-void wolfsslVersion(void);
+void wolfCLU_version(void);
 #endif
 
 #endif /* _WOLFSSL_CLU_HEADER_ */

clu_include/x509/clu_cert.h

@@ -23,10 +23,10 @@
 #include <wolfssl/wolfcrypt/error-crypt.h>
 
 /* handles incoming arguments for certificate generation */
-int wolfsslCertSetup(int argc, char** argv);
+int wolfCLU_certSetup(int argc, char** argv);
 
 /* print help info */
-void wolfsslCertHelp();
+void wolfCLU_certHelp();
 
 /* check for user input errors */
 int error_check(int inpem_flag, int inder_flag, int outpem_flag,

clu_include/x509/clu_parse.h

@@ -20,13 +20,13 @@
  */
 
 /* a helper function for wolfCLU_parse_file */
-int wolfCLU_inpem_outpem(char* infile, char* outfile, int silent_flag);
+int wolfCLU_inpemOutpem(char* infile, char* outfile, int silent_flag);
 /* a helper function for wolfCLU_parse_file */
-int wolfCLU_inpem_outder(char* infile, char* outfile, int silent_flag);
+int wolfCLU_inpemOutder(char* infile, char* outfile, int silent_flag);
 /* a helper function for wolfCLU_parse_file */
-int wolfCLU_inder_outpem(char* infile, char* outfile, int silent_flag);
+int wolfCLU_inderOutpem(char* infile, char* outfile, int silent_flag);
 /* a helper function for wolfCLU_parse_file */
-int wolfCLU_inder_outder(char* infile, char* outfile, int silent_flag);
+int wolfCLU_inderOutder(char* infile, char* outfile, int silent_flag);
 /* function for processing input/output based on format requests from user */
-int wolfCLU_parse_file(char* infile, int inform, char* outfile, int outform,
+int wolfCLU_parseFile(char* infile, int inform, char* outfile, int outform,
                                                                int silent_flag);

clu_include/x509/clu_request.h

@@ -20,6 +20,6 @@
  */
 
 /* handles incoming arguments for certificate requests */
-int wolfsslRequestSetup(int argc, char** argv);
+int wolfCLU_requestSetup(int argc, char** argv);
 
 

clu_src/benchmark/clu_bench_setup.c

@@ -21,7 +21,7 @@
 
 #include "clu_include/clu_header_main.h"
 
-int wolfsslBenchSetup(int argc, char** argv)
+int wolfCLU_benchSetup(int argc, char** argv)
 {
     int     ret     =   0;          /* return variable */
     int     time    =   3;          /* timer variable */
@@ -65,7 +65,7 @@ int wolfsslBenchSetup(int argc, char** argv)
     for (i = 2; i < argc; i++) {
         if (XSTRNCMP(argv[i], "-help", 5) == 0) {
             /* help checking */
-            wolfsslBenchHelp();
+            wolfCLU_benchHelp();
             return 0;
         }
         for (j = 0; j < (int) sizeof(algs)/(int) sizeof(algs[0]); j++) {
@@ -95,12 +95,12 @@ int wolfsslBenchSetup(int argc, char** argv)
     }
     if (optionCheck != 1) {
         /* help checking */
-        wolfsslHelp();
+        wolfCLU_help();
     }
     else {
         /* benchmarking function */
         printf("\nTesting for %d second(s)\n", time);
-        ret = wolfsslBenchmark(time, option);
+        ret = wolfCLU_benchmark(time, option);
     }
     return ret;
 }