aaa_peer_fsm.cxx

Diameter协议栈

        AAA_Utf8AvpContainerWidget errorMsg(dwa->acl);
        diameter_utf8string_t *strMsg = errorMsg.GetAvp
            (AAA_AVPNAME_ERRORMESSAGE);
        if (strMsg) {
            AAA_LOG(LM_INFO,
                  "(%P|%t) Peer returned an error on Watchdog: %s, closing peer\n",
                       strMsg->data());
        }
        fsm.Cleanup();       
    }
}

void AAA_PeerI_SendMessage::operator()(AAA_PeerStateMachine &fsm)
{
#if ASYNC_SEND
    boost::shared_ptr<AAAMessage> msg = fsm.DequeueSendMsg();
    if (fsm.Send(*msg, fsm.PeerData().m_IOInitiator.get()) < 0) {
        AAA_LOG(LM_INFO, "(%P|%t) Error sending message: %d\n",
                   msg->hdr.code);
    }    
#endif
}

void AAA_PeerI_SendCEA::operator()(AAA_PeerStateMachine &fsm)
{
    std::auto_ptr<AAAMessage> cer = fsm.m_CurrentPeerEventParam->m_Msg;
   
    fsm.DisassembleCE(*cer);
    
    std::string message;
    diameter_unsigned32_t rcode;
    if (! fsm.ValidatePeer(rcode, message)) {
        AAA_LOG(LM_INFO, "(%P|%t) %s during cap re-negotiation\n",
                   message.data());
    }
    fsm.SendCEA(rcode, message);
}

void AAA_PeerI_SendDPR::operator()(AAA_PeerStateMachine &fsm)
{
    fsm.CancelTimer(AAA_PEER_EV_WATCHDOG);
    fsm.ScheduleTimer(AAA_PEER_EV_TIMEOUT,
                      AAA_PEER_CONNECT_ATTEMPT_TOUT,
                      0,
                      AAA_PEER_EV_TIMEOUT);
    fsm.SendDPR(true);
}

void AAA_PeerR_SendDPR::operator()(AAA_PeerStateMachine &fsm)
{
    fsm.CancelTimer(AAA_PEER_EV_WATCHDOG);
    fsm.ScheduleTimer(AAA_PEER_EV_TIMEOUT,
                      AAA_PEER_CONNECT_ATTEMPT_TOUT,
                      0,
                      AAA_PEER_EV_TIMEOUT);
    fsm.SendDPR(false);
}

void AAA_PeerI_SendDPADisconnect::operator()(AAA_PeerStateMachine &fsm)
{
    std::auto_ptr<AAAMessage> dpr = fsm.m_CurrentPeerEventParam->m_Msg;
    
    AAA_LOG(LM_INFO, "(%P|%t) Peer initiator requested termination, disconnecting\n");
    std::string message = "Disconnected";
    fsm.SendDPA(true, AAA_SUCCESS, message);
    
    AAA_UInt32AvpContainerWidget cause(dpr->acl);
    diameter_unsigned32_t *uint32 = cause.GetAvp(AAA_AVPNAME_DISCONNECT_CAUSE);   
    
    fsm.Cleanup();    
    fsm.PeerFsmDisconnected
         ((uint32) ? *uint32 : AAA_DISCONNECT_UNKNOWN);   
}

void AAA_PeerR_SendDPADisconnect::operator()(AAA_PeerStateMachine &fsm)
{
    std::auto_ptr<AAAMessage> dpr = fsm.m_CurrentPeerEventParam->m_Msg;
    
    AAA_LOG(LM_INFO, "(%P|%t) Peer responder requested termination, disconnecting\n");
    std::string message = "Disconnected";
    fsm.SendDPA(false, AAA_SUCCESS, message);
    
    AAA_UInt32AvpContainerWidget cause(dpr->acl);
    diameter_unsigned32_t *uint32 = cause.GetAvp(AAA_AVPNAME_DISCONNECT_CAUSE);   
    
    fsm.Cleanup();    
    fsm.PeerFsmDisconnected
         ((uint32) ? *uint32 : AAA_DISCONNECT_UNKNOWN);   
}

void AAA_Peer_Disconnect::operator()(AAA_PeerStateMachine &fsm)
{
    AAA_LOG(LM_INFO, "(%P|%t) General disconnection\n");
    fsm.Cleanup();
    if (AAA_CFG_TRANSPORT()->retry_interval > 0) {
        fsm.ScheduleTimer(AAA_PEER_EV_CONN_RETRY,
                          AAA_CFG_TRANSPORT()->retry_interval,
                          0,
                          AAA_PEER_EV_CONN_RETRY);
    }
    
    fsm.PeerFsmDisconnected
         (AAA_DISCONNECT_TRANSPORT);
}

void AAA_Peer_DisconnectDPA::operator()(AAA_PeerStateMachine &fsm)
{
    std::auto_ptr<AAAMessage> dpa = fsm.m_CurrentPeerEventParam->m_Msg;
    
    AAA_MsgResultCode rcode(*dpa);
    if (rcode.InterpretedResultCode() ==
        AAA_MsgResultCode::RCODE_SUCCESS) {
        fsm.DisassembleDP(*dpa);
    }
    else {
        AAA_Utf8AvpContainerWidget errorMsg(dpa->acl);
        diameter_utf8string_t *strMsg = errorMsg.GetAvp
            (AAA_AVPNAME_ERRORMESSAGE);
        if (strMsg) {
            AAA_LOG(LM_INFO,
               "(%P|%t) Peer returned an error on Watchdog: %s, closing peer\n",
                    strMsg->data());
        }
    }

    fsm.PeerFsmDisconnected
        (fsm.PeerData().m_DisconnectCause);    
    fsm.Cleanup();
}

void AAA_Peer_Watchdog::operator()(AAA_PeerStateMachine &fsm)
{
    fsm.SendDWR();
}

void AAA_PeerStateMachine::AssembleCE(AAAMessage &msg,
                                      bool request)
{
   AAADiameterHeader &h = msg.hdr;
   ACE_OS::memset(&msg.hdr, 0, sizeof(msg.hdr));
   h.ver = AAA_PROTOCOL_VERSION;
   h.length = 0;
   h.flags.r = request ? AAA_FLG_SET : AAA_FLG_CLR;
   h.flags.p = AAA_FLG_CLR;
   h.flags.e = AAA_FLG_CLR;
   h.code = AAA_MSGCODE_CAPABILITIES_EXCHG;
   h.appId = AAA_BASE_APPLICATION_ID;
   MsgIdTxMessage(msg);

   AAA_IdentityAvpWidget originHost(AAA_AVPNAME_ORIGINHOST);
   AAA_IdentityAvpWidget originRealm(AAA_AVPNAME_ORIGINREALM);
   AAA_AddressAvpWidget  hostIp(AAA_AVPNAME_HOSTIP);
   AAA_UInt32AvpWidget   vendorId(AAA_AVPNAME_VENDORID);
   AAA_Utf8AvpWidget     product(AAA_AVPNAME_PRODUCTNAME);
   AAA_UInt32AvpWidget   originStateId(AAA_AVPNAME_ORIGINSTATEID);
   AAA_UInt32AvpWidget   supportedVendorId(AAA_AVPNAME_SUPPORTEDVENDORID);
   AAA_UInt32AvpWidget   authId(AAA_AVPNAME_AUTHAPPID);
   AAA_UInt32AvpWidget   acctId(AAA_AVPNAME_ACCTAPPID);
   AAA_GroupedAvpWidget  vendorSpecificId(AAA_AVPNAME_VENDORAPPID);
   AAA_UInt32AvpWidget   firmware(AAA_AVPNAME_FIRMWAREREV);
   AAA_UInt32AvpWidget   inbandSecId(AAA_AVPNAME_INBANDSECID);

   originHost.Get() = AAA_CFG_TRANSPORT()->identity;
   originRealm.Get() = AAA_CFG_TRANSPORT()->realm;
   firmware.Get() = AAA_CFG_GENERAL()->version;
   inbandSecId.Get() = m_Data.m_TLS;
  
   // Host-IP-Address
   AAA_IpAddress tool;
   if (AAA_CFG_TRANSPORT()->advertised_host_ip.size() > 0) {
       std::list<std::string>::iterator i = 
           AAA_CFG_TRANSPORT()->advertised_host_ip.begin();
       for (; i != AAA_CFG_TRANSPORT()->advertised_host_ip.end(); 
            i++) {
           ACE_INET_Addr hostAddr((*i).data());           
           diameter_address_t &ipAvp = hostIp.Get();
           ipAvp.type = AAA_ADDRESS_IP;
           ipAvp.value.assign((char*)tool.GetAddressPtr(hostAddr),
                              tool.GetAddressSize(hostAddr));
       }
   }
   else {
       size_t count;
       ACE_INET_Addr *addrs;
       if (tool.GetLocalAddresses(count, addrs) == 0) {
           for(size_t i = 0; i < count; i++) {
               diameter_address_t &ipAvp = hostIp.Get();
               ipAvp.type = AAA_ADDRESS_IP;
               ipAvp.value.assign((char*)tool.GetAddressPtr(addrs[i]),
                                   tool.GetAddressSize(addrs[i]));
           }
	   if (count > 0) {
               delete[] addrs;
	   }
       }
   }
   
   vendorId.Get() = AAA_CFG_GENERAL()->vendor;
   product.Get() = AAA_CFG_GENERAL()->product;
   originStateId.Get() = AAA_CFG_RUNTIME()->originStateId;

   AAA_ApplicationIdLst *idList[] = {
       &AAA_CFG_GENERAL()->supportedVendorIdLst,
       &AAA_CFG_GENERAL()->authAppIdLst,
       &AAA_CFG_GENERAL()->acctAppIdLst
   };
   AAA_UInt32AvpWidget *widgets[] = {
       &supportedVendorId,
       &authId,
       &acctId
   };
   for (int i=0; i<sizeof(widgets)/sizeof(AAA_UInt32AvpWidget*); i++) {
       AAA_ApplicationIdLst::iterator x = idList[i]->begin();
       for (; x != idList[i]->end(); x++) {
           widgets[i]->Get() = *x;
       }
       if (! widgets[i]->empty()) {
           msg.acl.add((*widgets[i])());
       }
   }
   
   AAA_VendorSpecificIdLst::iterator y =
       AAA_CFG_GENERAL()->vendorSpecificId.begin();
   for (; y != AAA_CFG_GENERAL()->vendorSpecificId.end();
        y++) {
       AAA_DataVendorSpecificApplicationId vid = *y;
       diameter_grouped_t &grp = vendorSpecificId.Get();

       if (vid.authAppId > 0) {
           AAA_UInt32AvpWidget gAuthId(AAA_AVPNAME_AUTHAPPID, vid.authAppId);
           grp.add(gAuthId());
       }
       if (vid.acctAppId > 0) {
           AAA_UInt32AvpWidget gAcctId(AAA_AVPNAME_ACCTAPPID, vid.acctAppId);
           grp.add(gAcctId());
       }       

       AAA_UInt32AvpWidget gVendorId(AAA_AVPNAME_VENDORID);       
       AAA_ApplicationIdLst::iterator z = vid.vendorIdLst.begin();
       for (; z != vid.vendorIdLst.end(); z++) {
           gVendorId.Get() = *z;
       }
       grp.add(gVendorId());
   }

   if (! vendorSpecificId.empty()) {
       msg.acl.add(vendorSpecificId());
   }
   
   msg.acl.add(originHost());
   msg.acl.add(originRealm());
   msg.acl.add(hostIp());
   msg.acl.add(vendorId());
   msg.acl.add(product());
   msg.acl.add(originStateId());
   msg.acl.add(firmware());
   msg.acl.add(inbandSecId());
}

void AAA_PeerStateMachine::DisassembleCE(AAAMessage &msg)
{
   int ndx; 
   AAA_PeerCapabilities &cap = m_Data.m_PeerCapabilities;
   
   AAA_IdentityAvpContainerWidget originHost(msg.acl);
   AAA_IdentityAvpContainerWidget originRealm(msg.acl);
   AAA_AddressAvpContainerWidget hostIp(msg.acl);
   AAA_UInt32AvpContainerWidget vendorId(msg.acl);
   AAA_Utf8AvpContainerWidget product(msg.acl);
   AAA_UInt32AvpContainerWidget originState(msg.acl);
   AAA_UInt32AvpContainerWidget supportedVendorId(msg.acl);
   AAA_UInt32AvpContainerWidget authAppId(msg.acl);
   AAA_UInt32AvpContainerWidget inbandSecId(msg.acl);
   AAA_UInt32AvpContainerWidget acctAppId(msg.acl);
   AAA_GroupedAvpContainerWidget vendorSpecificId(msg.acl);
   AAA_UInt32AvpContainerWidget firmware(msg.acl);

   diameter_identity_t *identity = originHost.GetAvp(AAA_AVPNAME_ORIGINHOST);
   cap.m_Host.assign((identity) ? identity->data() : "",
                     (identity) ? identity->length() : 0);
   
   identity = originRealm.GetAvp(AAA_AVPNAME_ORIGINREALM);
   cap.m_Realm.assign((identity) ? identity->data() : "",
                      (identity) ? identity->length() : 0);
              

   while (! cap.m_HostIpLst.empty()) {
       diameter_address_t *ip = cap.m_HostIpLst.front();
       cap.m_HostIpLst.pop_front();
       delete ip;
   }
   
   diameter_address_t *address = hostIp.GetAvp(AAA_AVPNAME_HOSTIP);
   for (ndx=1; address; ndx++) {
       diameter_address_t *newAddr = new diameter_address_t;
       *newAddr = *address;
       cap.m_HostIpLst.push_back(newAddr);
       address = hostIp.GetAvp(AAA_AVPNAME_HOSTIP, ndx);
   }

   diameter_unsigned32_t *uint32 = vendorId.GetAvp(AAA_AVPNAME_VENDORID);
   cap.m_VendorId = (uint32) ? *uint32 : 0;

   diameter_utf8string_t *utf8str = product.GetAvp(AAA_AVPNAME_PRODUCTNAME);
   cap.m_ProductName.assign((utf8str) ? utf8str->data() : "",
                            (utf8str) ? utf8str->length() : 0);
   
   uint32 = originState.GetAvp(AAA_AVPNAME_ORIGINSTATEID);
   cap.m_OriginStateId = (uint32) ? *uint32 : 0;
   
   uint32 = firmware.GetAvp(AAA_AVPNAME_FIRMWAREREV);
   cap.m_FirmwareRevision = (uint32) ? *uint32 : 0;
   
   uint32 = inbandSecId.GetAvp(AAA_AVPNAME_INBANDSECID);
   cap.m_InbandSecurityId = (uint32) ? *uint32 : 0;
   
   AAA_ApplicationIdLst *idList[] = {
       &cap.m_SupportedVendorIdLst,
       &cap.m_AuthAppIdLst,
       &cap.m_AcctAppIdLst
   };
   AAA_UInt32AvpContainerWidget *widgets[] = {
       &supportedVendorId,
       &authAppId,
       &acctAppId
   };
   char *avpNames[] = {
       AAA_AVPNAME_SUPPORTEDVENDORID,
       AAA_AVPNAME_AUTHAPPID,
       AAA_AVPNAME_ACCTAPPID
   };
   for (int i=0;
        i<sizeof(idList)/sizeof(AAA_ApplicationIdLst*);
        i++) {
       while (! idList[i]->empty()) {
           idList[i]->pop_front();
       }
   }
   for (int i=0;
        i<sizeof(widgets)/sizeof(AAA_UInt32AvpContainerWidget*);
        i++) {
       uint32 = widgets[i]->GetAvp(avpNames[i]);
       for (ndx=1; uint32; ndx++) {
           idList[i]->push_back(*uint32);
           uint32 = widgets[i]->GetAvp(avpNames[i], ndx);
       }
   }
   
   while (! cap.m_VendorSpecificId.empty()) {
       AAA_VendorSpecificIdLst::iterator x =
           cap.m_VendorSpecificId.begin();
       AAA_ApplicationIdLst &id = (*x).vendorIdLst;
       while (! id.empty()) {
           id.pop_front();
       }
       cap.m_VendorSpecificId.pop_front();
   }
   diameter_grouped_t *grouped = vendorSpecificId.GetAvp(AAA_AVPNAME_VENDORAPPID);
   for (ndx=1; grouped; ndx++) {
       AAA_DataVendorSpecificApplicationId vsid;
       AAA_UInt32AvpContainerWidget gAuthId(*grouped);
       AAA_UInt32AvpContainerWidget gAcctId(*grouped);
       AAA_UInt32AvpContainerWidget gVendorId(*grouped);

       uint32 = gVendorId.GetAvp(AAA_AVPNAME_VENDORID);
       for (int p=1; uint32; p++) {
           vsid.vendorIdLst.push_back(*uint32);
           uint32 = gVendorId.GetAvp(AAA_AVPNAME_VENDORID, p);
       }
       
       uint32 = gAuthId.GetAvp(AAA_AVPNAME_AUTHAPPID);
       vsid.authAppId = (uint32) ? *uint32 : 0;
       uint32 = gAcctId.GetAvp(AAA_AVPNAME_ACCTAPPID);
       vsid.acctAppId = (uint32) ? *uint32 : 0;