Configuration.cc

Go to the documentation of this file.

#include "include/Configuration.h"
#ifndef CONFIGURATION_H_
#include "include/Debug.h"
#endif
#include "include/generic.h"
#include <iostream>
#include <sstream>
#include <fstream>
#include <vector>
#include <string.h>
#include <stdlib.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>



using namespace std;



Configuration::Configuration(string cfile, Debug *dbg, vector<string> sections, vector<string> vars)
{
        // Assign variables
        this->sections = sections;
        this->vars = vars;
        this->dbg = dbg;
        // Parse main configuration file
        ReadFile(cfile);
        Parseconf();
}
void Configuration::LoadSysVars()
{
        dbg->Prntdbg(CODEAT, 20, "Load system variables");
        // Load all necessary variables from the system

        if( gethostname(hostname, 128) == 0 )
        {
                // Get host adresses
                struct hostent * pHost;
                struct in_addr **addr_list;
                
                
                pHost = gethostbyname(hostname);
                
                if (!pHost)
                {
                        string err = "Unknown host ";
                        err += hostname;
                        dbg->Prnterr(CODEAT, err);
                }
                else
                {
                        ipaddr = inet_ntoa(*(struct in_addr*)pHost->h_addr);
                        if (ipaddr.substr(0,3).compare("127") == 0)
                        {
                                addr_list = (struct in_addr **)pHost->h_addr_list;
                                for(int i = 0; addr_list[i] != NULL; i++) {
                                        ipaddr = inet_ntoa(*addr_list[i]);
                                        if (ipaddr.substr(0,3).compare("127") != 0 && ipaddr.compare("") != 0)
                                                break;
                                }
                        }
                        dbg->Prntdbg(CODEAT, 20, "IP address set to " + ipaddr);
                }
        }
}

string Configuration::GetHostname()
{
        // Return Hostname
        string hn = hostname;
        return hn;
}
void Configuration::ReadFile(string cfile)
{
        
        // Load file contents in the buffer
        ifstream is;
        is.exceptions (ifstream::eofbit | ifstream::failbit | ifstream::badbit);

        try
        {
                is.open (cfile.c_str(), ios::binary);
        }
        catch (ifstream::failure& e) {
            dbg->Prnterr(CODEAT, "Error opening file " + cfile);
                exit(-1);
        }       

        try
        {
                // get length of file
                is.seekg (0, ios::end);
                content_len = is.tellg();
                is.seekg (0, ios::beg);
        }
        catch (ios_base::failure& e)
        {
                dbg->Prnterr(CODEAT, "Error getting content length");
                exit(-1);
        }
        
        
        // allocate memory
        try {
                content = new char [content_len];
        }
        catch (std::bad_alloc&)
        {
                dbg->Prnterr(CODEAT, "Error allocating memory");
                exit(-1);
        }
        
        try
        {
                // read data as a block
                is.read (content, content_len);
        }
        catch (ios_base::failure& e)
        {
                dbg->Prnterr(CODEAT, "Error reading file content");
                exit(-1);
        }
        is.close();
}

void Configuration::Parseconf()
{
        char * line;
        string parse, key, value;
        int pos;
        
        // Parse Configuration
        line = strtok (content,"\n");
        while (line != NULL)
        {
                parse = line;
                // remove comments
                parse = parse.substr(0,parse.find_first_of("#"));
                // Avoid blank lines
                pos = parse.find_first_not_of(" ");

                if (pos >= 0)
                {
                        // trim left
                        parse = parse.substr(parse.find_first_not_of(" "), parse.length());
                        parse = parse.substr(parse.find_first_not_of("\t"), parse.length());
                        // trim right
                        parse = parse.substr(0,parse.find_last_not_of(" ") + 1);
                        parse = parse.substr(0,parse.find_last_not_of("\t") + 1);
                        
                        // now split the string
                        key = parse.substr(0,parse.find_first_of("="));
                        
                        // Add keys and values to configuration map
                        
                        if (key.find_first_of("[") == 0)
                        {
                                // This is a section
                                key = key.substr(1,key.length()-2);
                                value = "section";
                        }
                        else 
                        {
                                // This is a key - value pair
                                value = parse.substr(parse.find_first_of("=") + 1, parse.length() - 1);
                                // trim left value
                                value = value.substr(value.find_first_not_of(" "), value.length());
                                value = value.substr(value.find_first_not_of("\t"), value.length());
                                // trim right key
                                key = key.substr(0,key.find_last_not_of(" ") + 1);
                                key = key.substr(0,key.find_last_not_of("\t") + 1);
                        }
                        AddConf(key, value);
                        
                }
                line = strtok (NULL, "\n");
        }
        
        // Free Memory
        delete[] content;
}

void Configuration::AddConf(string key, string value)
{
        if (CheckSyntax(key, value))
                config.insert(pair<string, string>(key, value));
        else
                dbg->Prnterr(CODEAT,"Unknown keyword: " + key);
}

bool Configuration::CheckSyntax(string key, string value)
{

        bool correct = false;

        if (value.compare("section") == 0)
        {
                // This is a section
                for (unsigned int i = 0; i < sections.size(); i++)
                        if (key.compare(sections[i]) == 0) 
                                correct = true;
        } 
        else
        {
                // This is a variable
                for (unsigned int i = 0; i < vars.size(); i++)
                        if (key.compare(vars[i]) == 0) 
                                correct = true;
        }

        return correct;
}
string Configuration::GetValue(string key)
{
        // Get configuration Value
        string val = "Unknown value: " + key;
        if (config[key].compare("") != 0)
                val = config[key];
        
        return val;
}

Configuration::~Configuration()
{

}

---