Added .clang-format file and applied style to source files

1 files changed, 205 insertions, 205 deletions

diff --git a/crypto.hpp b/crypto.hpp
index 64a1965..ef92219 100644
--- a/crypto.hpp
+++ b/crypto.hpp
@@ -1,220 +1,220 @@
 #ifndef SIMPLE_WEB_CRYPTO_HPP
-#define	SIMPLE_WEB_CRYPTO_HPP
+#define SIMPLE_WEB_CRYPTO_HPP
 
-#include <string>
 #include <cmath>
-#include <sstream>
 #include <iomanip>
 #include <istream>
+#include <sstream>
+#include <string>
 #include <vector>
 
 //Moving these to a seperate namespace for minimal global namespace cluttering does not work with clang++
-#include <openssl/evp.h>
 #include <openssl/buffer.h>
-#include <openssl/sha.h>
+#include <openssl/evp.h>
 #include <openssl/md5.h>
+#include <openssl/sha.h>
 
 namespace SimpleWeb {
-    //TODO 2017: remove workaround for MSVS 2012
-    #if _MSC_VER == 1700 //MSVS 2012 has no definition for round()
-        inline double round(double x) { //custom definition of round() for positive numbers
-            return floor(x + 0.5);
-        }
-    #endif
-
-    class Crypto {
-        const static size_t buffer_size=131072;
+//TODO 2017: remove workaround for MSVS 2012
+#if _MSC_VER == 1700              //MSVS 2012 has no definition for round()
+  inline double round(double x) { //custom definition of round() for positive numbers
+    return floor(x + 0.5);
+  }
+#endif
+
+  class Crypto {
+    const static size_t buffer_size = 131072;
+
+  public:
+    class Base64 {
     public:
-        class Base64 {
-        public:
-            static std::string encode(const std::string &ascii) {
-                std::string base64;
-                
-                BIO *bio, *b64;
-                BUF_MEM *bptr=BUF_MEM_new();
-
-                b64 = BIO_new(BIO_f_base64());
-                BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
-                bio = BIO_new(BIO_s_mem());
-                BIO_push(b64, bio);
-                BIO_set_mem_buf(b64, bptr, BIO_CLOSE);
-                
-                //Write directly to base64-buffer to avoid copy
-                int base64_length=static_cast<int>(round(4*ceil((double)ascii.size()/3.0)));
-                base64.resize(base64_length);
-                bptr->length=0;
-                bptr->max=base64_length+1;
-                bptr->data=(char*)&base64[0];
-
-                BIO_write(b64, &ascii[0], static_cast<int>(ascii.size()));
-                BIO_flush(b64);
-
-                //To keep &base64[0] through BIO_free_all(b64)
-                bptr->length=0;
-                bptr->max=0;
-                bptr->data=nullptr;
-
-                BIO_free_all(b64);
-                
-                return base64;
-            }
-            
-            static std::string decode(const std::string &base64) {
-                std::string ascii;
-                
-                //Resize ascii, however, the size is a up to two bytes too large.
-                ascii.resize((6*base64.size())/8);
-                BIO *b64, *bio;
-
-                b64 = BIO_new(BIO_f_base64());
-                BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
-                bio = BIO_new_mem_buf((char*)&base64[0], static_cast<int>(base64.size()));
-                bio = BIO_push(b64, bio);
-
-                int decoded_length = BIO_read(bio, &ascii[0], static_cast<int>(ascii.size()));
-                ascii.resize(decoded_length);
-
-                BIO_free_all(b64);
-                
-                return ascii;
-            }
-        };
-        
-        /// Return hex string from bytes in input string.
-        static std::string to_hex_string(const std::string &input) {
-          std::stringstream hex_stream;
-          hex_stream << std::hex << std::internal << std::setfill('0');
-          for (auto &byte : input)
-            hex_stream << std::setw(2) << static_cast<int>(static_cast<unsigned char>(byte));
-          return hex_stream.str();
-        }
-        
-        static std::string md5(const std::string &input, size_t iterations=1) {
-            std::string hash;
-            
-            hash.resize(128 / 8);
-            MD5(reinterpret_cast<const unsigned char*>(&input[0]), input.size(), reinterpret_cast<unsigned char*>(&hash[0]));
-            
-            for (size_t c = 1; c < iterations; ++c)
-              MD5(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
-            
-            return hash;
-        }
-        
-        static std::string md5(std::istream &stream, size_t iterations=1) {
-            MD5_CTX context;
-            MD5_Init(&context);
-            std::streamsize read_length;
-            std::vector<char> buffer(buffer_size);
-            while((read_length=stream.read(&buffer[0], buffer_size).gcount())>0)
-                MD5_Update(&context, buffer.data(), read_length);
-            std::string hash;
-            hash.resize(128 / 8);
-            MD5_Final(reinterpret_cast<unsigned char*>(&hash[0]), &context);
-            
-            for (size_t c = 1; c < iterations; ++c)
-              MD5(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
-            
-            return hash;
-        }
-
-        static std::string sha1(const std::string &input, size_t iterations=1) {
-            std::string hash;
-            
-            hash.resize(160 / 8);
-            SHA1(reinterpret_cast<const unsigned char*>(&input[0]), input.size(), reinterpret_cast<unsigned char*>(&hash[0]));
-            
-            for (size_t c = 1; c < iterations; ++c)
-              SHA1(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
-            
-            return hash;
-        }
-        
-        static std::string sha1(std::istream &stream, size_t iterations=1) {
-            SHA_CTX context;
-            SHA1_Init(&context);
-            std::streamsize read_length;
-            std::vector<char> buffer(buffer_size);
-            while((read_length=stream.read(&buffer[0], buffer_size).gcount())>0)
-                SHA1_Update(&context, buffer.data(), read_length);
-            std::string hash;
-            hash.resize(160 / 8);
-            SHA1_Final(reinterpret_cast<unsigned char*>(&hash[0]), &context);
-            
-            for (size_t c = 1; c < iterations; ++c)
-              SHA1(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
-            
-            return hash;
-        }
-
-        static std::string sha256(const std::string &input, size_t iterations=1) {
-            std::string hash;
-            
-            hash.resize(256 / 8);
-            SHA256(reinterpret_cast<const unsigned char*>(&input[0]), input.size(), reinterpret_cast<unsigned char*>(&hash[0]));
-            
-            for (size_t c = 1; c < iterations; ++c)
-              SHA256(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
-            
-            return hash;
-        }
-        
-        static std::string sha256(std::istream &stream, size_t iterations=1) {
-            SHA256_CTX context;
-            SHA256_Init(&context);
-            std::streamsize read_length;
-            std::vector<char> buffer(buffer_size);
-            while((read_length=stream.read(&buffer[0], buffer_size).gcount())>0)
-                SHA256_Update(&context, buffer.data(), read_length);
-            std::string hash;
-            hash.resize(256 / 8);
-            SHA256_Final(reinterpret_cast<unsigned char*>(&hash[0]), &context);
-            
-            for (size_t c = 1; c < iterations; ++c)
-              SHA256(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
-            
-            return hash;
-        }
-
-        static std::string sha512(const std::string &input, size_t iterations=1) {
-            std::string hash;
-            
-            hash.resize(512 / 8);
-            SHA512(reinterpret_cast<const unsigned char*>(&input[0]), input.size(), reinterpret_cast<unsigned char*>(&hash[0]));
-            
-            for (size_t c = 1; c < iterations; ++c)
-              SHA512(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
-            
-            return hash;
-        }
-        
-        static std::string sha512(std::istream &stream, size_t iterations=1) {
-            SHA512_CTX context;
-            SHA512_Init(&context);
-            std::streamsize read_length;
-            std::vector<char> buffer(buffer_size);
-            while((read_length=stream.read(&buffer[0], buffer_size).gcount())>0)
-                SHA512_Update(&context, buffer.data(), read_length);
-            std::string hash;
-            hash.resize(512 / 8);
-            SHA512_Final(reinterpret_cast<unsigned char*>(&hash[0]), &context);
-            
-            for (size_t c = 1; c < iterations; ++c)
-              SHA512(reinterpret_cast<const unsigned char*>(&hash[0]), hash.size(), reinterpret_cast<unsigned char*>(&hash[0]));
-            
-            return hash;
-        }
-        
-        /// key_size is number of bytes of the returned key.
-        static std::string pbkdf2(const std::string &password, const std::string &salt, int iterations, int key_size) {
-          std::string key;
-          key.resize(key_size);
-          PKCS5_PBKDF2_HMAC_SHA1(password.c_str(), password.size(),
-                                 reinterpret_cast<const unsigned char*>(salt.c_str()), salt.size(), iterations,
-                                 key_size, reinterpret_cast<unsigned char*>(&key[0]));
-          return key;
-        }
+      static std::string encode(const std::string &ascii) {
+        std::string base64;
+
+        BIO *bio, *b64;
+        BUF_MEM *bptr = BUF_MEM_new();
+
+        b64 = BIO_new(BIO_f_base64());
+        BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
+        bio = BIO_new(BIO_s_mem());
+        BIO_push(b64, bio);
+        BIO_set_mem_buf(b64, bptr, BIO_CLOSE);
+
+        //Write directly to base64-buffer to avoid copy
+        int base64_length = static_cast<int>(round(4 * ceil((double)ascii.size() / 3.0)));
+        base64.resize(base64_length);
+        bptr->length = 0;
+        bptr->max = base64_length + 1;
+        bptr->data = (char *)&base64[0];
+
+        BIO_write(b64, &ascii[0], static_cast<int>(ascii.size()));
+        BIO_flush(b64);
+
+        //To keep &base64[0] through BIO_free_all(b64)
+        bptr->length = 0;
+        bptr->max = 0;
+        bptr->data = nullptr;
+
+        BIO_free_all(b64);
+
+        return base64;
+      }
+
+      static std::string decode(const std::string &base64) {
+        std::string ascii;
+
+        //Resize ascii, however, the size is a up to two bytes too large.
+        ascii.resize((6 * base64.size()) / 8);
+        BIO *b64, *bio;
+
+        b64 = BIO_new(BIO_f_base64());
+        BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
+        bio = BIO_new_mem_buf((char *)&base64[0], static_cast<int>(base64.size()));
+        bio = BIO_push(b64, bio);
+
+        int decoded_length = BIO_read(bio, &ascii[0], static_cast<int>(ascii.size()));
+        ascii.resize(decoded_length);
+
+        BIO_free_all(b64);
+
+        return ascii;
+      }
     };
-}
-#endif	/* SIMPLE_WEB_CRYPTO_HPP */
 
+    /// Return hex string from bytes in input string.
+    static std::string to_hex_string(const std::string &input) {
+      std::stringstream hex_stream;
+      hex_stream << std::hex << std::internal << std::setfill('0');
+      for(auto &byte : input)
+        hex_stream << std::setw(2) << static_cast<int>(static_cast<unsigned char>(byte));
+      return hex_stream.str();
+    }
+
+    static std::string md5(const std::string &input, size_t iterations = 1) {
+      std::string hash;
+
+      hash.resize(128 / 8);
+      MD5(reinterpret_cast<const unsigned char *>(&input[0]), input.size(), reinterpret_cast<unsigned char *>(&hash[0]));
+
+      for(size_t c = 1; c < iterations; ++c)
+        MD5(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
+
+      return hash;
+    }
+
+    static std::string md5(std::istream &stream, size_t iterations = 1) {
+      MD5_CTX context;
+      MD5_Init(&context);
+      std::streamsize read_length;
+      std::vector<char> buffer(buffer_size);
+      while((read_length = stream.read(&buffer[0], buffer_size).gcount()) > 0)
+        MD5_Update(&context, buffer.data(), read_length);
+      std::string hash;
+      hash.resize(128 / 8);
+      MD5_Final(reinterpret_cast<unsigned char *>(&hash[0]), &context);
+
+      for(size_t c = 1; c < iterations; ++c)
+        MD5(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
+
+      return hash;
+    }
+
+    static std::string sha1(const std::string &input, size_t iterations = 1) {
+      std::string hash;
+
+      hash.resize(160 / 8);
+      SHA1(reinterpret_cast<const unsigned char *>(&input[0]), input.size(), reinterpret_cast<unsigned char *>(&hash[0]));
+
+      for(size_t c = 1; c < iterations; ++c)
+        SHA1(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
+
+      return hash;
+    }
+
+    static std::string sha1(std::istream &stream, size_t iterations = 1) {
+      SHA_CTX context;
+      SHA1_Init(&context);
+      std::streamsize read_length;
+      std::vector<char> buffer(buffer_size);
+      while((read_length = stream.read(&buffer[0], buffer_size).gcount()) > 0)
+        SHA1_Update(&context, buffer.data(), read_length);
+      std::string hash;
+      hash.resize(160 / 8);
+      SHA1_Final(reinterpret_cast<unsigned char *>(&hash[0]), &context);
+
+      for(size_t c = 1; c < iterations; ++c)
+        SHA1(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
+
+      return hash;
+    }
+
+    static std::string sha256(const std::string &input, size_t iterations = 1) {
+      std::string hash;
+
+      hash.resize(256 / 8);
+      SHA256(reinterpret_cast<const unsigned char *>(&input[0]), input.size(), reinterpret_cast<unsigned char *>(&hash[0]));
+
+      for(size_t c = 1; c < iterations; ++c)
+        SHA256(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
+
+      return hash;
+    }
+
+    static std::string sha256(std::istream &stream, size_t iterations = 1) {
+      SHA256_CTX context;
+      SHA256_Init(&context);
+      std::streamsize read_length;
+      std::vector<char> buffer(buffer_size);
+      while((read_length = stream.read(&buffer[0], buffer_size).gcount()) > 0)
+        SHA256_Update(&context, buffer.data(), read_length);
+      std::string hash;
+      hash.resize(256 / 8);
+      SHA256_Final(reinterpret_cast<unsigned char *>(&hash[0]), &context);
+
+      for(size_t c = 1; c < iterations; ++c)
+        SHA256(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
+
+      return hash;
+    }
+
+    static std::string sha512(const std::string &input, size_t iterations = 1) {
+      std::string hash;
+
+      hash.resize(512 / 8);
+      SHA512(reinterpret_cast<const unsigned char *>(&input[0]), input.size(), reinterpret_cast<unsigned char *>(&hash[0]));
+
+      for(size_t c = 1; c < iterations; ++c)
+        SHA512(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
+
+      return hash;
+    }
+
+    static std::string sha512(std::istream &stream, size_t iterations = 1) {
+      SHA512_CTX context;
+      SHA512_Init(&context);
+      std::streamsize read_length;
+      std::vector<char> buffer(buffer_size);
+      while((read_length = stream.read(&buffer[0], buffer_size).gcount()) > 0)
+        SHA512_Update(&context, buffer.data(), read_length);
+      std::string hash;
+      hash.resize(512 / 8);
+      SHA512_Final(reinterpret_cast<unsigned char *>(&hash[0]), &context);
+
+      for(size_t c = 1; c < iterations; ++c)
+        SHA512(reinterpret_cast<const unsigned char *>(&hash[0]), hash.size(), reinterpret_cast<unsigned char *>(&hash[0]));
+
+      return hash;
+    }
+
+    /// key_size is number of bytes of the returned key.
+    static std::string pbkdf2(const std::string &password, const std::string &salt, int iterations, int key_size) {
+      std::string key;
+      key.resize(key_size);
+      PKCS5_PBKDF2_HMAC_SHA1(password.c_str(), password.size(),
+                             reinterpret_cast<const unsigned char *>(salt.c_str()), salt.size(), iterations,
+                             key_size, reinterpret_cast<unsigned char *>(&key[0]));
+      return key;
+    }
+  };
+}
+#endif /* SIMPLE_WEB_CRYPTO_HPP */