fix: Ambiguity when compiling

[cassiopeia.git] / src / config.cpp

diff --git a/src/config.cpp b/src/config.cpp
index a9407f8c163d1689431e09fb19aea7750dca14f8..ad3c1375963a16602d07611b62bc7ff502e31606 100644 (file)
--- a/src/config.cpp
+++ b/src/config.cpp
@@ -1,20 +1,25 @@
 #include <iostream>
 #include <vector>
 #include <fstream>
+#include <dirent.h>
+#include <unordered_map>
 
-#include "sslUtil.h"
+#include "crypto/sslUtil.h"
 
 std::string keyDir;
-std::vector<Profile> profiles;
+std::unordered_map<std::string, Profile> profiles;
+std::unordered_map<std::string, std::shared_ptr<CAConfig>> CAs;
 std::string sqlHost, sqlUser, sqlPass, sqlDB;
+std::string serialPath;
 
-int parseConfig( std::string path ) {
+std::shared_ptr<std::unordered_map<std::string, std::string>> parseConf( std::string path ) {
+    std::shared_ptr<std::unordered_map<std::string, std::string>> map( new std::unordered_map<std::string, std::string>() );
     std::ifstream config;
     config.open( path );
 
     if( !config.is_open() ) {
-        std::cerr << "config missing" << std::endl;
-        return 1;
+        std::cout << "Where is " << path << "?" << std::endl;
+        throw "Config missing";
     }
 
     std::string line1;
@@ -33,65 +38,112 @@ int parseConfig( std::string path ) {
 
         std::string key = line1.substr( 0, splitter );
         std::string value = line1.substr( splitter + 1 );
+        map->emplace( key, value );
+    }
+
+    config.close();
+
+    return map;
+}
+
+int parseProfiles() {
+    CAs = std::unordered_map<std::string, std::shared_ptr<CAConfig>>();
+
+    DIR* dp;
+    struct dirent* ep;
+    dp = opendir( "profiles" );
+
+    if( dp == NULL ) {
+        std::cerr << "Profiles not found " << std::endl;
+        return -1;
+    }
 
-        if( key == "key.directory" ) {
-            keyDir = value;
+    while( ( ep = readdir( dp ) ) ) {
+        if( ep->d_name[0] == '.' ) {
             continue;
-        } else if( key == "sql.host" ) {
-            sqlHost = value;
-        } else if( key == "sql.user" ) {
-            sqlUser = value;
-        } else if( key == "sql.password" ) {
-            sqlPass = value;
-        } else if( key == "sql.database" ) {
-            sqlDB = value;
         }
 
-        if( key.compare( 0, 8, "profile." ) == 0 ) {
-            int numE = key.find( ".", 9 );
+        std::string profileName( ep->d_name );
 
-            if( numE == 0 ) {
-                std::cout << "invalid line: " << line1 << std::endl;
-                continue;
-            }
+        int splitter = profileName.find( "-" );
 
-            unsigned int i = atoi( key.substr( 8, numE - 8 ).c_str() );
-            std::string rest = key.substr( numE + 1 );
+        if( splitter == -1 ) {
+            std::cerr << "Ignoring malformed profile: " << profileName << std::endl;
+            continue;
+        }
 
-            if( i + 1 > profiles.size() ) {
-                profiles.resize( i + 1 );
-            }
+        std::string id = profileName.substr( 0, splitter );
 
-            if( rest == "key" ) {
-                profiles[i].key = value;
-            } else if( rest == "cert" ) {
-                profiles[i].cert = value;
-            } else if( rest == "ku" ) {
-                profiles[i].ku = value;
-            } else if( rest == "eku" ) {
-                profiles[i].eku = value;
-            } else {
-                std::cout << "invalid line: " << line1 << std::endl;
-                continue;
-            }
+        if( profileName.substr( profileName.size() - 4 ) != ".cfg" ) {
+            std::cerr << "Ignoring malformed profile: " << profileName << std::endl;
+            continue;
         }
-    }
 
-    for( auto& prof : profiles ) {
-        if( prof.cert != "" && prof.key != "" ) {
-            std::cout << "Loading profile... " << std::endl;
-            prof.ca = loadX509FromFile( prof.cert );
-            prof.caKey = loadPkeyFromFile( prof.key );
+        auto map = parseConf( std::string( "profiles/" ) + profileName );
+
+        profileName = profileName.substr( 0, profileName.size() - 4 );
+
+        Profile prof;
+        prof.id = std::stoi( id );
+        prof.eku = map->at( "eku" );
+        prof.ku = map->at( "ku" );
+        prof.maxValidity = std::stoi( map->at( "days" ) ) * /* DAYS */24 * 60 * 60;
+
+        std::string cas = map->at( "ca" );
+
+        DIR *dir;
+        struct dirent *ent;
+        if ((dir = opendir ("ca")) != NULL) {
+            while ((ent = readdir (dir)) != NULL) {
+                std::string caName = std::string(ent->d_name);
+                if( caName.find( cas ) != 0 ){
+                    continue;
+                }
+
+                if( CAs.find( caName ) == CAs.end() ) {
+                    std::shared_ptr<CAConfig> ca( new CAConfig( caName ) );
+                    CAs.emplace( caName, ca );
+                }
+
+                prof.ca.push_back( CAs.at( caName ) );
+                std::cout << "Adding CA: " << caName << std::endl;
+            }
+            closedir (dir);
+        } else {
+            throw "Directory with CAConfigs not found";
         }
+
+        profiles.emplace( profileName, prof );
+        std::cout << "Profile: " << profileName << " up and running." << std::endl;
     }
 
+    ( void ) closedir( dp );
+
+
     std::cout << profiles.size() << " profiles loaded." << std::endl;
 
+    return 0;
+}
+
+int parseConfig( std::string path ) {
+
+    auto masterConf = parseConf( path );
+
+    keyDir = masterConf->at( "key.directory" );
+    sqlHost = masterConf->at( "sql.host" );
+    sqlUser = masterConf->at( "sql.user" );
+    sqlPass = masterConf->at( "sql.password" );
+    sqlDB = masterConf->at( "sql.database" );
+    serialPath = masterConf->at( "serialPath" );
+
     if( keyDir == "" ) {
         std::cerr << "Missing config property key.directory" << std::endl;
         return -1;
     }
 
-    config.close();
+    if( parseProfiles() != 0 ) {
+        return -1;
+    }
+
     return 0;
 }