hsms_config.cpp

/*   
 *   (c) Copyright 2008 Philipp Skadorov (philipp_s@users.sourceforge.net)
 *
 *   This file is part of FREESECS.
 *
 *   FREESECS is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   FREESECS is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with FREESECS, see COPYING.
 *   If not, see <http://www.gnu.org/licenses/>.
 */
#include <string.h>
#include "log.h"
#include "hsms_config.h"

#define HSMS_CONFIG_LOG_LEVEL 5

using namespace freesecs;

char *hsms_config_t::str_err[] = {"No errors", "Invalid value", "Invalid token"};

hsms_config_t::hsms_config_t(const char *_name)
:name(_name)
,type(UNDEFINED)
,port(0)
,t6(0)
,t8(0)
,linktest(0)
,session_id(0)
,parse_flags(0)
{
}

hsms_config_t::hsms_config_t(const hsms_config_t& other)
{
    this->operator=(other);
}

hsms_config_t& 
hsms_config_t::operator = (const hsms_config_t& other)
{
    name = other.name;
    type = other.type;
    port = other.port;
    t6 = other.t6;
    t8 = other.t8;
    linktest = other.linktest;
    session_id = other.session_id;
    parse_flags = other.parse_flags;
    
    return *this;
}

hsms_config_t::~hsms_config_t()
{
}

int 
hsms_config_t::set_attr(const char *name, const char *value)
{
    int res = 0, i;
    if(0 == strcmp(name, "port"))
    {
        port = atoi(value);
        if(port)
        {
            parse_flags |= PORT;
        }
        else
        {
            res = INVALID_VALUE;
        }
    }
    else if(0 == strcmp(name, "t6"))
    {
        t6 = atoi(value);
        if(t6)
        {
            parse_flags |= T6;
        }
        else
        {
            res = INVALID_VALUE;
        }
    }
    else if(0 == strcmp(name, "t8"))
    {
        t8 = atoi(value);
        if(t8)
        {
            parse_flags |= T8;
        }
        else
        {
            res = INVALID_VALUE;
        }
    }
    else if(0 == strcmp(name, "linktest"))
    {
        i = atoi(value);
        if(0 <= i)
        {
            linktest = i;
            parse_flags |= LINKTEST;
        }
        else
        {
            res = INVALID_VALUE;
        }
    }
    else if(0 == strcmp(name, "session_id"))
    {
        session_id = atoi(value);
        if(0 < session_id)
        {
            parse_flags |= SESSION_ID;
        }
        else
        {
            res = INVALID_VALUE;
        }
    }
    /* expat issues: elements of no interest 
     * shall be bypassed*/
    else if(0 == strcmp(name, "cnx")){}
    else if(0 == strcmp(name, "atimeouts")){}
    else if(0 == strcmp(name, "ptimeouts")){}
    else
    {
        res = INVALID_TOKEN;
    }
    return res;
}

void
hsms_config_t::complete()
{
    parse_flags |= COMPLETED;
}
bool
hsms_config_t::is_valid()const
{
    return  (parse_flags    & PORT)         > 0
            && (parse_flags & T6)           > 0
            && (parse_flags & T8)           > 0
            && (parse_flags & SESSION_ID)   > 0
            && (parse_flags & UNEXPECTED)  == 0
            && (parse_flags & COMPLETED)    > 0;
}

hsms_passive_config_t::hsms_passive_config_t(const char *name)
:hsms_config_t(name)
{
    type = PASSIVE;
}

hsms_passive_config_t::hsms_passive_config_t(const hsms_passive_config_t &other)
:hsms_config_t(other)
{
    this->operator=(other);
}

hsms_passive_config_t & 
hsms_passive_config_t::operator = (const hsms_passive_config_t & other)
{
    this->hsms_config_t::operator=(other);
    t7 = other.t7;

    return *this;

}

bool 
hsms_passive_config_t::is_valid()const
{
    return hsms_config_t::is_valid()
            && (parse_flags & hsms_config_t::T7) > 0;
}

int 
hsms_passive_config_t::set_attr(const char *name, const char *value)
{
    int res = 0;
    if(0 == (res = hsms_config_t::set_attr(name, value)))
    {
    }
    else if(0 == strcmp(name, "t7"))
    {
        res = hsms_config_t::NO_ERROR;
        t7 = atoi(value);
        if(t7)
        {
            parse_flags |= hsms_config_t::T7;
        }
        else
        {
            res = INVALID_VALUE;
        }
    }
    else
    {
        res = INVALID_TOKEN;
        parse_flags |= hsms_config_t::UNEXPECTED;
    }
    return res;
}

hsms_active_config_t::hsms_active_config_t(const char *name)
:hsms_config_t(name)
{
    type = ACTIVE;
}

hsms_active_config_t::hsms_active_config_t(const hsms_active_config_t& other)
:hsms_config_t(other)
{
    this->operator=(other);
}

hsms_active_config_t & 
hsms_active_config_t::operator = (const hsms_active_config_t& other)
{
    this->hsms_config_t::operator=(other);
    t5 = other.t5;
    ip = other.ip;

    return *this;
}

bool 
hsms_active_config_t::is_valid()const
{
    return hsms_config_t::is_valid()
            && (parse_flags & hsms_config_t::T5) > 0
            && (parse_flags & hsms_config_t::IP) > 0;
}

int 
hsms_active_config_t::set_attr(const char *name, const char *value)
{
    int res = 0;
    if(0 == (res = hsms_config_t::set_attr(name, value)))
    {
    }
    else if(0 == strcmp(name, "t5"))
    {
        res = hsms_config_t::NO_ERROR;
        t5 = atoi(value);
        if(t5)
        {
            parse_flags |= hsms_config_t::T5;
        }
        else
        {
            res = INVALID_VALUE;
        }
    }
    else if(0 == strcmp(name, "ip"))
    {
        res = hsms_config_t::NO_ERROR;
        ip = value;
        if(0 < ip.length())
        {
            parse_flags |= hsms_config_t::IP;
        }
        else
        {
            res = INVALID_VALUE;
        }
    }
    else
    {
        res = INVALID_TOKEN;
        parse_flags |= hsms_config_t::UNEXPECTED;
    }
    return res;
}

hsms_config_parser_t::hsms_config_parser_t()
:curr_cnx(NULL), process(false)
{
    if(!(p = XML_ParserCreate(NULL))) 
    {
        TRACE_ERROR("Couldn't allocate memory for parser");
        throw;
    }

    XML_SetUserData(p, (void*)this);
    //XML_UseParserAsHandlerArg(p);
    XML_SetElementHandler(p, start_handler, end_handler);
    XML_SetCharacterDataHandler(p, char_handler);
}

hsms_config_parser_t::~hsms_config_parser_t()
{
    XML_ParserFree(p);
}

int 
hsms_config_parser_t::parse(const char *s, int len, int is_final)
{
    return XML_Parse(p, s, len, is_final);
}

static char item_name[128];

void
hsms_config_parser_t::start_handler(void *data, const char *el, const char **attr)
{
    hsms_config_parser_t *hsms_p = (hsms_config_parser_t*)data;
    if(0 == strcmp(el, "hsms"))
    {
        hsms_p->process = true;
    }
    if(!hsms_p->process)
    {
        return;
    }
    if(0 == strcmp(el, "cnx"))
    {
        if(NULL == attr 
            || NULL == attr[0]
            || NULL == attr[1]
            || NULL == attr[2]
            || NULL == attr[3])
        {
            TRACE_ERROR("!!!!CNX ATTRIBUTE ERROR!!!!!\n");
        }
        else
        {
            if(0 == strcmp(attr[3], "passive"))
            {
                /*
                hsms_p->passive_configs.push_back(hsms_passive_config_t(attr[1]));
                hsms_p->curr_cnx = &hsms_p->passive_configs.back();
                */
                hsms_p->curr_cnx = new hsms_passive_config_t(attr[1]);
            }
            else if(0 == strcmp(attr[3], "active"))
            {
                /*
                hsms_p->active_configs.push_back(hsms_active_config_t(attr[1]));
                hsms_p->curr_cnx = &hsms_p->active_configs.back();
                */
                hsms_p->curr_cnx = new hsms_active_config_t(attr[1]);
            }
            else
            {
                TRACE_ERROR("!!!!UNKNOWN CNX TYPE: %s!!!!!\n", attr[3]);
                hsms_p->curr_cnx = NULL;
            }
        }
    }
    memset(item_name, 0, sizeof(item_name));
    strncpy(item_name, el, sizeof(item_name)-1);
}

void
hsms_config_parser_t::end_handler(void *data, const char *el)
{
    hsms_config_parser_t *hsms_p = (hsms_config_parser_t*)data;    
    
    if(0 == strcmp(el, "hsms"))
    {
        hsms_p->process = false;
    }

    else if(    0 == strcmp(el, "cnx") 
                && NULL != hsms_p->curr_cnx
                && true == hsms_p->process  )
    {
        hsms_p->curr_cnx->complete();
        TRACE_DEBUG(HSMS_CONFIG_LOG_LEVEL, "%s: cnx %s valid: %d\n", 
                    __func__, 
                    hsms_p->curr_cnx->name.c_str(), 
                    hsms_p->curr_cnx->is_valid());

        if(hsms_config_t::PASSIVE == hsms_p->curr_cnx->type)
        {
            hsms_p->passive_configs.push_back(*((hsms_passive_config_t*)hsms_p->curr_cnx));
        }
        else if(hsms_config_t::ACTIVE == hsms_p->curr_cnx->type)
        {
            hsms_p->active_configs.push_back(*((hsms_active_config_t*)hsms_p->curr_cnx));
        }
        delete hsms_p->curr_cnx;
        hsms_p->curr_cnx = NULL;
    }
    memset(item_name, 0, sizeof(item_name));
}

void
hsms_config_parser_t::char_handler(void *data, const char *txt, int txtlen)
{
    static const int buflen = 128;
    static char buf[buflen];
    int copy_len, line_number, error;
    std::string err_str;

    hsms_config_parser_t *hsms_p = (hsms_config_parser_t*)data;
    if(NULL == hsms_p->curr_cnx
        || false == hsms_p->process)
    {
        return;
    }

    if(0 == strlen(item_name) || 0 == txtlen)
    {
        return;
    }

    copy_len = buflen-1 < txtlen ? buflen-1 : txtlen;
    memset(buf, 0, sizeof(buf));
    strncpy(buf, txt, copy_len);

    if(hsms_config_t::NO_ERROR != (error = hsms_p->curr_cnx->set_attr(item_name, buf)))
    {
        line_number = XML_GetCurrentLineNumber(hsms_p->p);

        sprintf(buf, "Config error at line %d: %s", line_number, hsms_config_t::str_err[error]);
        err_str = buf;
    }
}    

---