aaa_xml_data.cxx

Diameter协议栈

   }
   return (0);
}

int AAA_XMLDataRouteTable::svc(DOMNode *n)
{
   AAA_LOG(LM_INFO, "(%P|%t)  Route Table:\n");

   unsigned int expireTime;
   std::string empty = "";
   std::string tagName;
   
   tagName = "expire_time";
   OD_Utl_XMLDataUInt32 etime(tagName, expireTime);
   etime.populate(n->getFirstChild());
   AAA_ROUTE_TABLE()->ExpireTime(expireTime);

   tagName = "route";
   AAA_RouteEntry *newRte = NULL;
   
   DOMNode *found = NULL, *sibling = n->getFirstChild();
   while (sibling) {
       
      ACE_NEW_RETURN(newRte, AAA_RouteEntry(empty), (-1));

      AAA_XMLDataRoute route(tagName, *newRte);
      if (route.populate(sibling, &found) == 0) {
         if (AAA_ROUTE_TABLE()->Lookup(newRte->Realm())) {
             AAA_LOG(LM_INFO, "(%P|%t)                        *Duplicate route (replacing previous)\n");
         }
         AAA_ROUTE_TABLE()->Add(*newRte);
         sibling = found->getNextSibling();
      }
      else {
          delete newRte;
          break;
      }
   }

   ACE_NEW_RETURN(newRte, AAA_RouteEntry(empty), (-1));

   AAA_LOG(LM_INFO, "(%P|%t)  Default Route: \n");

   tagName = "default_route";   
   AAA_XMLDataRoute def_route(tagName, *newRte);
   if (def_route.populate(n->getFirstChild()) == 0) {
       AAA_ROUTE_TABLE()->DefaultRoute(*newRte);
   }
   else {
       delete newRte;
   }
   
   return (0);
}

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

   tagName = "identity";
   OD_Utl_XMLDataString identity(tagName, payload.identity);
   identity.populate(n->getFirstChild());

   tagName = "realm";
   OD_Utl_XMLDataString realm(tagName, payload.realm);
   realm.populate(n->getFirstChild());

   tagName = "tcp_port";
   OD_Utl_XMLDataUInt32 tcp_port(tagName, payload.tcp_port);
   tcp_port.populate(n->getFirstChild());
  
   tagName = "tls_port";
   OD_Utl_XMLDataUInt32 tls_port(tagName, payload.tls_port);
   tls_port.populate(n->getFirstChild());
  
   tagName = "watchdog_timeout";
   OD_Utl_XMLDataUInt32 watchdog(tagName, payload.watchdog_timeout);
   watchdog.populate(n->getFirstChild());
  
   tagName = "retry_interval";
   OD_Utl_XMLDataUInt32 retry(tagName, payload.retry_interval);
   retry.populate(n->getFirstChild());

   tagName = "request_retransmission_interval";
   OD_Utl_XMLDataUInt32 retxint(tagName, payload.retx_interval);
   retxint.populate(n->getFirstChild());

   if (payload.retx_interval && 
       (payload.retx_interval < AAA_ROUTER_MIN_RETX_INTERVAL)) {
       payload.retx_interval = AAA_ROUTER_MIN_RETX_INTERVAL;
   }

   tagName = "max_request_retransmission_count";
   OD_Utl_XMLDataUInt32 retxcnt(tagName, payload.retx_max_count);
   retxcnt.populate(n->getFirstChild());

   if (payload.retx_max_count && 
       (payload.retx_max_count > AAA_ROUTER_MAX_RETX_COUNT)) {
       payload.retx_max_count = AAA_ROUTER_MAX_RETX_COUNT;
   }

   tagName = "advertised_host_ip";
   DOMNode *found, *sibling = n->getFirstChild();

   while (sibling) {
      std::string host_ip;
      OD_Utl_XMLDataString hip(tagName, host_ip);      
      if (hip.populate(sibling, &found) == 0) {
      
         std::string testAddr(host_ip + ":0");
         ACE_INET_Addr hostAddr;
         
         if (! hostAddr.set(testAddr.data())) {
             payload.advertised_host_ip.push_back(testAddr); 
         }
         else {
             AAA_LOG(LM_INFO, "(%P|%t) WARNING: Invalid Host IP Addr [%s], will be ignored\n", 
                     host_ip.data());
         }
         sibling = found->getNextSibling();
      }
      else {
         break;
      }
   }
  
   AAA_XMLDataTransportMngt::print(payload);

   tagName = "peer_table";
   AAA_XMLDataPeerTable peerTable(tagName, task);
   peerTable.populate(n->getFirstChild());

   tagName = "route_table";
   AAA_XMLDataRouteTable routeTable(tagName);
   routeTable.populate(n->getFirstChild());

   return (0);
}

void AAA_XMLDataTransportMngt::print(AAA_DataTransportMngt &data)
{
   AAA_LOG(LM_INFO, "(%P|%t)            Identity : %s\n", 
                 data.identity.data());
   AAA_LOG(LM_INFO, "(%P|%t)               Realm : %s\n", 
                 data.realm.data());
   AAA_LOG(LM_INFO, "(%P|%t)          TCP Listen : %d\n", 
                 data.tcp_port);
   AAA_LOG(LM_INFO, "(%P|%t)          TLS Listen : %d\n", 
                 data.tls_port);
   AAA_LOG(LM_INFO, "(%P|%t)   Watch-Dog timeout : %d\n", 
                 data.watchdog_timeout);
   AAA_LOG(LM_INFO, "(%P|%t)   Request Retry Int : %d\n", 
                 data.retx_interval);
   AAA_LOG(LM_INFO, "(%P|%t)   Max Request Retry : %d\n", 
                 data.retx_max_count);
   AAA_LOG(LM_INFO, "(%P|%t)      Retry interval : %d\n", 
                 data.retry_interval);
                 
   std::list<std::string>::iterator i = data.advertised_host_ip.begin();
   for (; i != data.advertised_host_ip.end(); i++) {
        AAA_LOG(LM_INFO, "(%P|%t)        Host IP Addr : %s\n", 
                       (*i).data());
   }
}

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

   tagName = "stateful";
   OD_Utl_XMLDataUInt32 stateful(tagName, payload.stateful);
   stateful.populate(n->getFirstChild());

   if (payload.stateful) {
       payload.stateful = AAA_SESSION_STATE_MAINTAINED;
   }
   else {
       payload.stateful = AAA_SESSION_NO_STATE_MAINTAINED;
   }

   tagName = "session_timeout";
   OD_Utl_XMLDataUInt32 session(tagName, payload.sessionTm);
   session.populate(n->getFirstChild());

   tagName = "lifetime_timeout";
   OD_Utl_XMLDataUInt32 lifetime(tagName, payload.lifetimeTm);
   lifetime.populate(n->getFirstChild());

   tagName = "grace_period_timeout";
   OD_Utl_XMLDataUInt32 grace(tagName, payload.graceTm);
   grace.populate(n->getFirstChild());

   tagName = "abort_retry_timeout";
   OD_Utl_XMLDataUInt32 abort(tagName, payload.abortRetryTm);
   abort.populate(n->getFirstChild());

   AAA_XMLDataAuthSession::print(payload);

   return (0);
}

void AAA_XMLDataAuthSession::print(AAA_DataAuthSession &data)
{
   AAA_LOG(LM_INFO, "(%P|%t)       Stateful Auth : %d\n", 
                 data.stateful);
   AAA_LOG(LM_INFO, "(%P|%t)          Session(T) : %d\n", 
                 data.sessionTm);
   AAA_LOG(LM_INFO, "(%P|%t)         Lifetime(T) : %d\n", 
                 data.lifetimeTm);
   AAA_LOG(LM_INFO, "(%P|%t)            Grace(T) : %d\n", 
                 data.graceTm);
   AAA_LOG(LM_INFO, "(%P|%t)            Abort(T) : %d\n", 
                 data.abortRetryTm);
}

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

   tagName = "session_timeout";
   OD_Utl_XMLDataUInt32 session(tagName, payload.sessionTm);
   session.populate(n->getFirstChild());

   tagName = "interim_interval";
   OD_Utl_XMLDataUInt32 interim(tagName, payload.recIntervalTm);
   interim.populate(n->getFirstChild());

   tagName = "realtime";
   OD_Utl_XMLDataUInt32 realtime(tagName, payload.realtime);
   realtime.populate(n->getFirstChild());

   AAA_XMLDataAcctSession::print(payload);

   return (0);
}

void AAA_XMLDataAcctSession::print(AAA_DataAcctSession &data)
{
   AAA_LOG(LM_INFO, "(%P|%t)          Session(T) : %d\n", 
                 data.sessionTm);
   AAA_LOG(LM_INFO, "(%P|%t)    Interim Interval : %d\n", 
                 data.recIntervalTm);
   AAA_LOG(LM_INFO, "(%P|%t)  Real-Time Required : %d\n", 
                 data.realtime);
}

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

   tagName = "max_sessions";
   OD_Utl_XMLDataUInt32 maxSessions(tagName, payload.maxSessions);
   maxSessions.populate(n->getFirstChild());

   tagName = "auth_sessions";
   AAA_XMLDataAuthSession auth(tagName, payload.authSessions);
   auth.populate(n->getFirstChild());

   AAA_XMLDataSessionMngt::print(payload);

   tagName = "acct_sessions";
   AAA_XMLDataAcctSession acct(tagName, payload.acctSessions);
   acct.populate(n->getFirstChild());

   return (0);
}

void AAA_XMLDataSessionMngt::print(AAA_DataSessionMngt &data)
{
   AAA_LOG(LM_INFO, "(%P|%t)            Max Sess : %d\n", 
                 data.maxSessions);
}

int AAA_XMLDataLogFlags::svc(DOMNode *n)
{
   std::string tagName;
   std::string debugFlg;
   std::string traceFlg;
   std::string infoFlg;

   tagName = "debug";
   OD_Utl_XMLDataString debug(tagName, debugFlg);
   debug.populate(n->getFirstChild());

   tagName = "trace";
   OD_Utl_XMLDataString trace(tagName, traceFlg);
   trace.populate(n->getFirstChild());

   tagName = "info";
   OD_Utl_XMLDataString info(tagName, infoFlg);
   info.populate(n->getFirstChild());

   payload.debug = (debugFlg == std::string("enabled")) ? true : false;
   payload.trace = (traceFlg == std::string("enabled")) ? true : false;
   payload.info  = (infoFlg == std::string("enabled")) ? true : false;

   AAA_XMLDataLogFlags::print(payload);

   return (0);
}

void AAA_XMLDataLogFlags::print(AAA_DataLogFlags &data)
{
   AAA_LOG(LM_INFO, "(%P|%t)           Debug Log : %s\n", 
                 data.debug ? "enabled" : "disabled");
   AAA_LOG(LM_INFO, "(%P|%t)           Trace Log : %s\n", 
                 data.trace ? "enabled" : "disabled");
   AAA_LOG(LM_INFO, "(%P|%t)            Info Log : %s\n", 
                 data.info ? "enabled" : "disabled");
}

int AAA_XMLDataLogTargets::svc(DOMNode *n)
{
   std::string tagName;
   std::string consoleTarget;
   std::string syslogTarget;

   tagName = "console";
   OD_Utl_XMLDataString console(tagName, consoleTarget);
   console.populate(n->getFirstChild());

   tagName = "syslog";
   OD_Utl_XMLDataString syslog(tagName, syslogTarget);
   syslog.populate(n->getFirstChild());

   payload.console = (consoleTarget == std::string("enabled")) ? true : false;
   payload.syslog  = (syslogTarget == std::string("enabled")) ? true : false;

   AAA_XMLDataLogTargets::print(payload);

   return (0);
}

void AAA_XMLDataLogTargets::print(AAA_DataLogTragetFlags &data)
{
   AAA_LOG(LM_INFO, "(%P|%t)         Console Log : %s\n", 
                 data.console ? "enabled" : "disabled");
   AAA_LOG(LM_INFO, "(%P|%t)          Syslog Log : %s\n", 
                 data.syslog  ? "enabled" : "disabled");
}

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

   tagName = "flags";
   AAA_XMLDataLogFlags flags(tagName, payload.flags);
   flags.populate(n->getFirstChild());

   tagName = "target";
   AAA_XMLDataLogTargets targets(tagName, payload.targets);
   targets.populate(n->getFirstChild());

   return (0);
}

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

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

   tagName = "parser";
   AAA_XMLDataParser parser(tagName, payload.parser);
   parser.populate(n->getFirstChild());

   tagName = "transport_mngt";
   AAA_XMLDataTransportMngt transport(tagName,
                                      payload.transport,
                                      task);
   transport.populate(n->getFirstChild());

   tagName = "session_mngt";
   AAA_XMLDataSessionMngt session(tagName,
                                  payload.session);
   session.populate(n->getFirstChild());

   tagName = "log";
   AAA_XMLDataLog log(tagName, payload.log);
   log.populate(n->getFirstChild());

   return (0);
}