xmlconfig.cpp

Go to the documentation of this file.

#include <cstring>

#include "xmlconfig.hpp"



const char * XmlConfig::retrieveText(std::string node, TiXmlHandle hdl)
{
        TiXmlElement *elem;
        elem = hdl.FirstChildElement("protocol").FirstChildElement(node.c_str()).Element();
        if (!elem)
        {
                std::cout<<"error: no '"<<node<<"' node in the config file. Aborting."<<std::endl;
                exit(1);
        }
        else
        {
                const char * cont = elem->GetText();
                return cont;
        }
}
        

int XmlConfig::toInteger(std::string node, TiXmlHandle hdl)
{
        int number = atoi(retrieveText(node,hdl));
        return number;
}


cryptoTools::SHAx * XmlConfig::string2hash(const char * hashRepresentation)
{
        if (strcmp(hashRepresentation,"SHA-256") == 0)
                return new cryptoTools::SHA256();
        else if (strcmp(hashRepresentation,"SHA-384") == 0)
                return new cryptoTools::SHA384();
        else if (strcmp(hashRepresentation,"SHA-512") == 0)
                return new  cryptoTools::SHA512();
        else
        {
                std::cout<<"ERROR: in XmlCOnfig.string2hash,"
                         <<"Incorrect hash type: "
                         <<hashRepresentation<<std::endl;
                exit(1);
        }        
}


arithm::Group * XmlConfig::unmarshalPGroup(const char * fieldRepresentation)
{
        std::string fieldRepr(fieldRepresentation);
        unsigned int index=0;
        std::string fieldByteTree = "";
        // getting rid of the comment
        while (fieldRepr[index] != ':')
                index++;
        index += 2; // taking care of the second ':'

        // reading the ByteTree corresponding to the group
        while (index < fieldRepr.size())
        {
                // to suppress spaces
                if (fieldRepr[index]!=' ')
                        fieldByteTree.push_back(fieldRepr[index]);
                index++;
        }
        verifierUtils::ByteTree * bt =
                verifierUtils::ByteTree::parseString(fieldByteTree);
        
        // returning a field of the correct type
        if (bt->getChild(0)->compare("verificatum.arithm.ModPGroup") == 0)
                return new arithm::ModPGrp(bt->getChild(1));
        else
        {
                std::cout<<"ERROR: in xmlConfig.unmarshalPGroup"
                         <<"pgroup type unkown: "
                         <<bt->getChild(0)->toString()<<"."
                         <<"Aborting."<<std::endl;
                exit(1);
        }
}


XmlConfig::XmlConfig(std::string path2file)
{
        TiXmlDocument doc(path2file.c_str());
        // Checking if we can open it; otherwise we stop everything.
        if(!doc.LoadFile())
        {
                std::cout<<"Error when loading file"<<std::endl;
                std::cout<<"error #"<<doc.ErrorId()<<" : "<<doc.ErrorDesc()<<std::endl;
                exit(1);
        }
        // Reading every first level nodes of the file and assigning
        // the instance's sttribute accordingly.
        TiXmlHandle hdl(&doc); // it is apparently better to use
                               // handles than pointers and I am a man
                               // of peace, so I do.

        // reading simple constants
        nopart    = toInteger("nopart"  ,hdl);
        thres     = toInteger("thres"   ,hdl);
        maxciph   = toInteger("maxciph" ,hdl); 
        vbitlenro = toInteger("vbitlenro",hdl);
        statdist = toInteger("statdist",hdl);
        cbitlenro = toInteger("cbitlenro",hdl);

        // reading rohash
        const char * ro = retrieveText("rohash",hdl);
        rohash = string2hash(ro);

        // reading prghash
        const char * prgType = retrieveText("prg",hdl);
        prghash = string2hash(prgType);
        
        // reading pgroup
        const char * fieldRepr = retrieveText("pgroup",hdl);
        pgroup = unmarshalPGroup(fieldRepr);
}


unsigned int XmlConfig::getNopart()
{
        return nopart;
}


unsigned int XmlConfig::getThres()
{
        return thres;
}


unsigned int XmlConfig::getMaxciph()
{
        return maxciph;
}


unsigned int XmlConfig::getVbitlenro()
{
        return vbitlenro;
}


unsigned int XmlConfig::getStatdist()
{
        return statdist;
}


unsigned int XmlConfig::getCbitlenro()
{
        return cbitlenro;
}


cryptoTools::SHAx * XmlConfig::getRohash()
{
        return rohash;
}


cryptoTools::SHAx * XmlConfig::getPrghash()
{
        return prghash;
}


arithm::Group * XmlConfig::getPgroup()
{
        return pgroup;
}