pana_config_manager.cxx

/* BEGIN_COPYRIGHT                                                        */
/*                                                                        */
/* Open Diameter: Open-source software for the Diameter and               */
/*                Diameter related protocols                              */
/*                                                                        */
/* Copyright (C) 2002-2004 Open Diameter Project                          */
/*                                                                        */
/* This library is free software; you can redistribute it and/or modify   */
/* it under the terms of the GNU Lesser General Public License as         */
/* published by the Free Software Foundation; either version 2.1 of the   */
/* License, or (at your option) any later version.                        */
/*                                                                        */
/* This library 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      */
/* Lesser General Public License for more details.                        */
/*                                                                        */
/* You should have received a copy of the GNU Lesser General Public       */
/* License along with this library; if not, write to the Free Software    */
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307    */
/* USA.                                                                   */
/*                                                                        */
/* In addition, when you copy and redistribute some or the entire part of */
/* the source code of this software with or without modification, you     */
/* MUST include this copyright notice in each copy.                       */
/*                                                                        */
/* If you make any changes that are appeared to be useful, please send    */
/* sources that include the changed part to                               */
/* diameter-developers@lists.sourceforge.net so that we can reflect your  */
/* changes to one unified version of this software.                       */
/*                                                                        */
/* END_COPYRIGHT                                                          */


#include "ace/Log_Msg.h"
#include "ace/INET_Addr.h"
#include "pana_config_manager.h"
#include "pana_defs.h"
#include "pana_exceptions.h"
#include "pana_xml_parser.h"

class PANA_XMLData : public PANA_XMLElementParser {
   public:
      PANA_XMLData(std::string &name, PANA_Cfg &data) :
                   PANA_XMLElementParser(name),
                       payload(data) { }

      int svc(DOMNode *n);

   protected:

      PANA_Cfg &payload; 
};

class PANA_XMLDataGeneral : public PANA_XMLElementParser {
   public:
      PANA_XMLDataGeneral(std::string &name, PANA_CfgGeneral &data) :
                          PANA_XMLElementParser(name),
                              payload(data) { }

      void print();

      int svc(DOMNode *n);

   protected:

      PANA_CfgGeneral &payload; 
};

class PANA_XMLRetransmissionParam : public PANA_XMLElementParser {
   public:
      PANA_XMLRetransmissionParam(std::string &name,
                                  PANA_CfgRetransmissionParam &data) :
                           PANA_XMLElementParser(name),
                           payload(data) { }

      void print();

      int svc(DOMNode *n);

   protected:

      PANA_CfgRetransmissionParam &payload; 
};

class PANA_XMLProviderInfo : public PANA_XMLElementParser {
   public:
      PANA_XMLProviderInfo(std::string &name, PANA_CfgProviderInfo &data) :
                           PANA_XMLElementParser(name),
                           payload(data) { }

      void print();

      int svc(DOMNode *n);

      std::string &banner() { return banner_; }

   protected:

      std::string banner_; 
      PANA_CfgProviderInfo &payload; 
};

class PANA_XMLDeviceId : public PANA_XMLElementParser {
   public:
      PANA_XMLDeviceId(std::string &name, PANA_DeviceId &data) :
                       PANA_XMLElementParser(name),
                       payload(data) { }

      void print();

      int svc(DOMNode *n);

      std::string &banner() { return banner_; }

   protected:

      std::string banner_; 
      PANA_DeviceId &payload; 
};

class PANA_XMLDataClient : public PANA_XMLElementParser {
   public:
      PANA_XMLDataClient(std::string &name, PANA_CfgClient &data) :
                           PANA_XMLElementParser(name),
                           payload(data) { }

      int svc(DOMNode *n);

      void print();

   protected:

      PANA_CfgClient &payload; 
};

class PANA_XMLDataAuthAgent : public PANA_XMLElementParser {
   public:
      PANA_XMLDataAuthAgent(std::string &name, PANA_CfgAuthAgent &data) :
                           PANA_XMLElementParser(name),
                           payload(data) { }

      int svc(DOMNode *n);

      void print();

   protected:

      PANA_CfgAuthAgent &payload; 
};

void PANA_XMLDataGeneral::print()
{
    ACE_DEBUG((LM_INFO, "     General configuration\n"));
    ACE_DEBUG((LM_INFO, "          Listen Port     : %d\n", payload.listen_port_));
    ACE_DEBUG((LM_INFO, "          Interface name  : %s\n", payload.iface_name_.data()));
    ACE_DEBUG((LM_INFO, "          Protection Cap  : %d\n", payload.protection_capability_));
    ACE_DEBUG((LM_INFO, "          Dictionary      : %s\n", payload.dictionary_fname_.data()));
    ACE_DEBUG((LM_INFO, "          Mobility        : %d\n", payload.mobility_));
}

int PANA_XMLDataGeneral::svc(DOMNode *n)
{
   std::string tagName;

   tagName = "listen_port";
   PANA_XMLDataUInt32 listen_port(tagName, payload.listen_port_);
   listen_port.populate(n->getFirstChild());

   tagName = "interface_name";
   PANA_XMLDataString iface_name(tagName, payload.iface_name_);
   iface_name.populate(n->getFirstChild());

   tagName = "protection_capability";
   PANA_XMLDataUInt32 pcap(tagName, payload.protection_capability_);
   pcap.populate(n->getFirstChild());

   tagName = "dictionary_filename";
   PANA_XMLDataString dict(tagName, payload.dictionary_fname_);
   dict.populate(n->getFirstChild());

   tagName = "mobility";
   PANA_XMLDataUInt32 mob(tagName, payload.mobility_);
   mob.populate(n->getFirstChild());

   print();
   
   tagName = "retransmission_param";
   PANA_XMLRetransmissionParam rt(tagName, payload.rt_);
   rt.populate(n->getFirstChild());

   return (0);
}

void PANA_XMLRetransmissionParam::print()
{
    ACE_DEBUG((LM_INFO, "          Re-Transmission\n"));
    ACE_DEBUG((LM_INFO, "                     IRT  : %d\n", payload.irt_));
    ACE_DEBUG((LM_INFO, "                     MRC  : %d\n", payload.mrc_));
    ACE_DEBUG((LM_INFO, "                     MRT  : %d\n", payload.mrt_));
    ACE_DEBUG((LM_INFO, "                     MRD  : %d\n", payload.mrd_));
}

int PANA_XMLRetransmissionParam ::svc(DOMNode *n)
{
   std::string tagName;

   tagName = "initial_rt_timeout";
   PANA_XMLDataUInt32 irt(tagName, payload.irt_);
   irt.populate(n->getFirstChild());

   tagName = "max_rt_count";
   PANA_XMLDataUInt32 mrc(tagName, payload.mrc_);
   mrc.populate(n->getFirstChild());

   tagName = "max_rt_timeout";
   PANA_XMLDataUInt32 mrt(tagName, payload.mrt_);
   mrt.populate(n->getFirstChild());

   tagName = "max_rt_duration";
   PANA_XMLDataUInt32 mrd(tagName, payload.mrd_);
   mrd.populate(n->getFirstChild());

   print();

   return (0);
}

void PANA_XMLProviderInfo::print()
{
    ACE_DEBUG((LM_INFO, "          Provider Info [%s]:\n", banner_.data()));
    ACE_DEBUG((LM_INFO, "              Name : %s\n", payload.name_.data()));
    ACE_DEBUG((LM_INFO, "              ID   : %d\n", payload.id_));
}

int PANA_XMLProviderInfo ::svc(DOMNode *n)
{
   std::string tagName;

   tagName = "id";
   PANA_XMLDataUInt32 id(tagName, payload.id_);
   id.populate(n->getFirstChild());

   tagName = "name";
   PANA_XMLDataString name(tagName, payload.name_);
   name.populate(n->getFirstChild());

   print();

   return (0);
}

void PANA_XMLDeviceId::print()
{
    ACE_DEBUG((LM_INFO, "          EP Device Id      : %d, ",
               payload.type()));
}

int PANA_XMLDeviceId::svc(DOMNode *n)
{
   std::string tagName;
   
   tagName = "type";
   ACE_UINT32 type;
   PANA_XMLDataUInt32 ptype(tagName, type);
   ptype.populate(n->getFirstChild());
   payload.type(PANA_DeviceId::TYPE(type));

   tagName = "id";
   std::string id;
   PANA_XMLDataString pid(tagName, id);
   pid.populate(n->getFirstChild());

   print();

   std::string &c_id = const_cast<std::string&>(payload.id());
   if (type == PANA_DeviceId::IPV4_ADDRESS) {
       char buf[128]; 
       ACE_OS::sprintf(buf, "%s:0", id.data());
       ACE_INET_Addr inet(buf);
       ACE_UINT32 ipAddr = ACE_HTONL(inet.get_ip_address());

       c_id.assign((char*)&ipAddr, sizeof(ACE_UINT32));
       
       ACE_DEBUG((LM_INFO, "[%s]\n", inet.get_host_addr()));
   }
   else {
       c_id.assign(id.data(), id.size());
   }

   return (0);
}

void PANA_XMLDataClient::print()
{
    ACE_DEBUG((LM_INFO, "     Client configuration\n"));
    ACE_DEBUG((LM_INFO, "          PAA IP Adress   : %s\n", payload.paa_ip_address_.data()));
    ACE_DEBUG((LM_INFO, "          PAA Port Number : %d\n", payload.paa_port_number_));
    ACE_DEBUG((LM_INFO, "          PAA Mcast Addr  : %s\n", payload.paa_mcast_address_.data()));
    ACE_DEBUG((LM_INFO, "          PAA Mcast Port  : %d\n", payload.paa_mcast_port_number_));
    ACE_DEBUG((LM_INFO, "          Separate NAP/ISP: %d\n", payload.s_flag_));
}

int PANA_XMLDataClient::svc(DOMNode *n)
{
   std::string tagName;

   tagName = "paa_ip_address";
   PANA_XMLDataString paa_ip(tagName, payload.paa_ip_address_);
   paa_ip.populate(n->getFirstChild());

   tagName = "paa_port_number";
   PANA_XMLDataUInt32 paa_port(tagName, payload.paa_port_number_);
   paa_port.populate(n->getFirstChild());

   tagName = "paa_mcast_address";
   PANA_XMLDataString paa_mcast(tagName, payload.paa_mcast_address_);
   paa_mcast.populate(n->getFirstChild());

   tagName = "paa_mcast_port_number";
   PANA_XMLDataUInt32 paa_mcast_port(tagName, payload.paa_mcast_port_number_);
   paa_mcast_port.populate(n->getFirstChild());

   tagName = "separate";
   PANA_XMLDataUInt32 separate(tagName, payload.s_flag_);
   separate.populate(n->getFirstChild());

   print();

   tagName = "isp_info";
   PANA_XMLProviderInfo isp(tagName, payload.isp_info_);
   isp.banner() = "ISP Info";
   isp.populate(n->getFirstChild());

   return (0);
}

void PANA_XMLDataAuthAgent::print()
{
    ACE_DEBUG((LM_INFO, "     Auth Agent configuration\n"));
    ACE_DEBUG((LM_INFO, "          Separate NAP/ISP: %d\n", payload.s_flag_));
    ACE_DEBUG((LM_INFO, "          Use Cookie      : %d\n", payload.use_cookie_));
    ACE_DEBUG((LM_INFO, "          EAP Piggyback   : %d\n", payload.eap_piggyback_));
    ACE_DEBUG((LM_INFO, "          Session-Lifetime: %d\n", payload.sessionLifetime_));
    ACE_DEBUG((LM_INFO, "          Grace Period    : %d\n", payload.gracePeriod_));
    ACE_DEBUG((LM_INFO, "          Multicast Addr  : %s\n", payload.mcast_address_.data()));
    ACE_DEBUG((LM_INFO, "          Multicast Port  : %d\n", payload.mcast_port_number_));
    ACE_DEBUG((LM_INFO, "          Requested Dev Id: %d\n", payload.request_dev_id_));
}

int PANA_XMLDataAuthAgent::svc(DOMNode *n)
{
   std::string tagName;

   tagName = "separate";
   PANA_XMLDataUInt32 separate(tagName, payload.s_flag_);
   separate.populate(n->getFirstChild());

   tagName = "use_cookie";
   PANA_XMLDataUInt32 ck(tagName, payload.use_cookie_);
   ck.populate(n->getFirstChild());

   tagName = "eap_piggyback";
   PANA_XMLDataUInt32 ep(tagName, payload.eap_piggyback_);
   ep.populate(n->getFirstChild());

   tagName = "session_lifetime";
   PANA_XMLDataUInt32 sessLifetime(tagName, payload.sessionLifetime_);
   sessLifetime.populate(n->getFirstChild());

   tagName = "grace_period";
   PANA_XMLDataUInt32 gracePeriod(tagName, payload.gracePeriod_);
   gracePeriod.populate(n->getFirstChild());

   tagName = "mcast_address";
   PANA_XMLDataString mcast(tagName, payload.mcast_address_);
   mcast.populate(n->getFirstChild());

   tagName = "mcast_port_number";
   PANA_XMLDataUInt32 mcast_port(tagName, payload.mcast_port_number_);
   mcast_port.populate(n->getFirstChild());

   tagName = "request_device_id_type";
   PANA_XMLDataUInt32 reqDevId(tagName, payload.request_dev_id_);
   reqDevId.populate(n->getFirstChild());

   print();

   tagName = "nap_info";
   PANA_XMLProviderInfo nap(tagName, payload.nap_info_);
   nap.banner() = "NAP Info";
   nap.populate(n->getFirstChild());

   ACE_UINT32 ndx = 0;
   char buf[32];

   tagName = "isp_info";
   DOMNode *sibling = n->getFirstChild();
   while (sibling != NULL) {

     if (sibling->getNodeType() == DOMNode::ELEMENT_NODE) {

         char *c_str = XMLString::transcode(sibling->getNodeName());

         if (XMLString::compareString(c_str, tagName.c_str()) == 0) {

             PANA_CfgProviderInfo *pInfo;
             ACE_NEW_NORETURN(pInfo, PANA_CfgProviderInfo);

             PANA_XMLProviderInfo isp(tagName, *pInfo);
             ACE_OS::sprintf(buf, "%s #%d", "ISP Info", ++ ndx);
             isp.banner() = buf;
             if (isp.populate(sibling) == 0) {
                 payload.isp_info_.push_back(pInfo);
             }
             else {
                 delete pInfo;
             }
         }

         XMLString::release(&c_str);
      }
      sibling = sibling->getNextSibling();
   }

   tagName = "ep_id";
   sibling = n->getFirstChild();
   while (sibling != NULL) {

     if (sibling->getNodeType() == DOMNode::ELEMENT_NODE) {

         char *c_str = XMLString::transcode(sibling->getNodeName());

         if (XMLString::compareString(c_str, tagName.c_str()) == 0) {

             PANA_DeviceId *devId;
             ACE_NEW_NORETURN(devId, PANA_DeviceId);
             
             PANA_XMLDeviceId pId(tagName, *devId);
             if (pId.populate(sibling) == 0) {
                 payload.ep_id_.push_back(devId);                 
             }
             else {
                 delete devId;
             }
         }

         XMLString::release(&c_str);
      }
      sibling = sibling->getNextSibling();
   }

   return (0);
}

int PANA_XMLData::svc(DOMNode *n)
{
   std::string tagName;

   tagName = "general";
   PANA_XMLDataGeneral general(tagName, payload.general_);
   general.populate(n->getFirstChild());

   tagName = "client";
   PANA_XMLDataClient client(tagName, payload.client_);
   client.populate(n->getFirstChild());

   tagName = "auth_agent";
   PANA_XMLDataAuthAgent aa(tagName, payload.auth_agent_);
   aa.populate(n->getFirstChild());

   return (0);
}

PANA_CfgManager::PANA_CfgManager()
{
}

PANA_CfgManager::~PANA_CfgManager()
{
    // do nothing
}

void PANA_CfgManager::open(std::string &cfg_file)
{
    std::string cfgRoot = "pana_configuration";

    PANA_XMLTreeParser parser;
    PANA_XMLData configData(cfgRoot, data_);

    if (parser.open(cfg_file, configData) != 0) {
        throw (PANA_Exception(PANA_Exception::CONFIG_ERROR, 
                              "Fatal: Unable to parse XML config file"));
    }
}

void PANA_CfgManager::close()
{
   // free up allocated provider list
   PANA_CfgProviderInfo *i;
   PANA_CfgProviderList &ispList = data_.auth_agent_.isp_info_;

   while (! ispList.empty()) {
      i = ispList.front();
      if (i) {
         delete i;
      }
      ispList.pop_front();
   }
}

---