pana_client.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 "pana_client.h"
#include "pana_device_id.h"
#include "pana_serial_num.h"
#include "pana_config_manager.h"

void PANA_Client::SendDiscover()
{
   /* Draft 3 notes:
      
      When a PaC attaches to a network, and knows that it has to discover
      PAA for PANA, it SHOULD send a PANA-PAA-Discover message to a well-
      known link local multicast address (TBD) and UDP port (TBD).  PANA
      PAA discovery assumes that PaC and PAA are one hop away from each
      other. If PaC knows the IP address of the PAA (some
      pre-configuration), it MAY unicast the PANA discovery message to that
      address. PAA SHOULD answer to the PANA-PAA-Discover message with a
      PANA-Start-Request message.


      PaC      PAA         Message 
      ------------------------------------------------------ 
      ----->            PANA-PAA-Discover(0,0) 
      <-----            PANA-Start-Request(x,0)[Cookie] 
      ----->            PANA-Start-Answer(x,y)[ Cookie] 
                        (continued to authentication phase) 

     9.3.2 PANA-PAA-Discover (PDI)

        The PANA-PAA-Discover (PDI) message is used to discover the address
        of PAA(s). Both sequence numbers in this message are set to zero (0).
        If the EP detects a new PaC and sends the PANA-PAA-Discover to the
        PAA, it MUST include the Device-Id of the PaC.

              PANA-PAA-Discover ::= < PANA-Header: 1 >
                        0*1 < Device-Id >
                        0*1 < Session-Id >
                         *  [ AVP ]
    */

   AAAAvpContainerManager cm;
   AAAAvpContainerEntryManager em;
   PANA_Message *msg;

   ACE_NEW_NORETURN(msg, PANA_Message);
   if (msg == NULL) {
      throw (PANA_Exception(PANA_Exception::NO_MEMORY, 
                            "Failed to allocate msg message"));
   }

   // Populate header
   PANA_MsgHeader::Flags flg = { 0, 0, 0, 0 }; 
   msg->flags(flg);
   msg->type(PANA_MTYPE_DISCOVER);
   msg->tseq(0);
   msg->rseq(0);

   // Populate AVP's
   AAAAvpContainerEntry *e;
   AAAAvpContainer *c_deviceId = cm.acquire("Device-Id");

   // Add the AVP's to containers
   e = em.acquire(AAA_AVPDataType(AAA_AVP_DEVICEID_TYPE));
   PANA_TVData_t &deviceId = e->dataRef(Type2Type<PANA_TVData_t>());
   c_deviceId->add(e);

   // Add containers to list
   msg->avpList().add(c_deviceId);

   // check for pre-established session-id for re-auth
   if (m_SessionId.size() > 0) {
      AAAAvpContainer *c_sessionId = cm.acquire("Session-Id");

      // Add the AVP's to containers
      e = em.acquire(AAA_AVP_UTF8_STRING_TYPE);
      diameter_utf8string_t &sid = e->dataRef(Type2Type<diameter_utf8string_t>());
      c_sessionId->add(e);

      msg->avpList().add(c_sessionId);
      sid.assign(m_SessionId.data(), m_SessionId.size());

      // inherit sequence nums
      msg->tseq(++ m_LastTransmittedTsec);
      msg->rseq(m_LastReceivedTsec);
      
      // Notify EAP
      ReAuthenticate(PANA_REAUTH_EAP);
   }

   // resolve source address
   PANA_DeviceIdContainer srcDevices;
   m_TxChannel.GetLocalAddress(srcDevices);

   // Fill MAC address 
   PANA_DeviceId *id = srcDevices.search(PANA_DeviceId::LL_ADDRESS);
   if (id == NULL) {
      id = srcDevices.search(PANA_DeviceId::IPV4_ADDRESS);
   }

   if (id) {
      deviceId.type = id->type();
      deviceId.value.assign(id->id().data(), id->id().size());
   }
   else {
      throw (PANA_Exception(PANA_Exception::FAILED, 
                           "No device ID available"));
   }

   DestinationAddressFormatting(*msg);
   m_TxChannel.Send(*this, *msg);

   PANA_RtQueueNullData data;
   if (m_RtQueue.Schedule(data)) {
       m_Timer.Schedule(PANA_TID_DISC_RETRY, data.Timeout());       
   }

   ACE_DEBUG((LM_INFO, "(%P|%t) SEND: Discover, tseq=%d, rseq=%d\n",
              msg->tseq(), msg->rseq()));
}

void PANA_Client::RetryDiscover()
{
   m_Timer.Cancel(PANA_TID_DISC_RETRY);
   
   PANA_RtQueueData *data = NULL;
   if (m_RtQueue.ReSchedule(data)) {
       SendDiscover();
       m_Timer.Schedule(PANA_TID_DISC_RETRY, data->Timeout());       
   }
   else {
       m_Timer.Schedule(PANA_TID_DISCONNECT, 0);
   }
}

void PANA_Client::ReceiveStartRequest()
{ 
   PANA_Message &msg = *(m_RxMessageQueue.front());
   m_RxMessageQueue.pop_front();

   ACE_DEBUG((LM_INFO, "(%P|%t) RECV: Start Req, S-flag %d, tseq=%d, rseq=%d\n",
                       msg.flags().separate, msg.tseq(), msg.rseq()));

   // cancel discovery retry
   m_Timer.Cancel(PANA_TID_DISC_RETRY);
   m_RtQueue.ClearFront();
   
   // extract NAP info if any
   AAAAvpContainer* c_napInfo = msg.avpList().search("NAP-Information");
   if (c_napInfo) {       
      diameter_grouped_t &nap = (*c_napInfo)[0]->dataRef
          (Type2Type<diameter_grouped_t>());
      PANA_ProviderInfoTool infoTool;
      infoTool.Extract(nap, m_PreferedNAP);

      ACE_DEBUG((LM_INFO, "(%P|%t) NAP information received: [%d] %s\n",
                 m_PreferedNAP.id_, m_PreferedNAP.name_.data()));      
   }

   // extract ISP info if any
   AAAAvpContainer* c_ispInfo = msg.avpList().search("ISP-Information");
   if (c_ispInfo) {
      m_IspSelected = IspSelection(c_ispInfo);
   }

   // initialize parts of session attributes
   m_InitialPaaTsec        = msg.tseq();
   m_InitialPacTsec        = PANA_SerialNumber::generateIsn(msg.tseq());
   m_LastTransmittedTsec   = m_InitialPacTsec;
   m_LastReceivedTsec      = msg.tseq();
   m_LastReceivedRsec      = msg.rseq();
   m_PeerPort              = msg.srcPort();
   m_PeerDeviceId.clone(msg.srcDevices());
   m_ReqDeviceId           = PANA_DeviceId::IPV4_ADDRESS;

   /*
      If the S-flag of the received PANA-Start-Request message is not set,
      PaC MUST NOT set the S-flag in the PANA-Start-Answer message sent
      back to the PAA.  In this case, PaC can indicate its choice of ISP by
      including its ISP-Information AVP in the PANA-Start-Answer message.
      AAA routing will be based on the ISP choice if an ISP-Information AVP
      is specified in the PANA-Start-Answer message, otherwise it will be
      based on EAP identifier.
      
      If the S-flag of the received PANA-Start-Request message is set, PaC
      can indicate its desire to perform separate EAP authentication for
      NAP and ISP by setting the S-flag in the PANA-Start-Answer message.
      In this case, PaC can also indicate its choice of ISP by including
      its ISP-Information AVP in the PANA-Start-Answer message.  AAA
      routing for NAP authentication will be based on the NAP.  AAA routing
      for ISP authentication will be based on the ISP choice if an
      ISP-Information AVP is specified in the PANA-Start-Answer message,
      otherwise it will be based on EAP identifier.  If the S-flag of the
      received PANA-Start-Request message is set and the S-flag of the
      corresponding PANA-Start-Answer message is not set, only one EAP
      authentication occurs without distinction between NAP and ISP
      authentications.  In this case, PaC can still indicate its choice of
      ISP by including its ISP-Information AVP in the PANA-Start-Answer
      message.
   */
   bool localSFlag = PANA_CONFIG_CLIENT().s_flag_ ? true : false;
   m_SeparateAuth = (msg.flags().separate) ? localSFlag : false;
   
   /*
      Start EAP processing
    */
   static_cast<PANA_ClientEventInterface&>(m_Event).EapStart();

   /*
      When a Cookie-AVP is carried in a PANA-Start-Request message, the
      initial EAP Request MUST NOT be carried in the PANA-Start-Request
      message in order for the PAA to be stateless.
   */

   // extract cookie and eap payload if any
   AAAAvpContainer *c_cookie = msg.avpList().search("Cookie");
   AAAAvpContainer* c_eapPayload = msg.avpList().search("EAP-Payload");
   if (c_cookie) {
       m_Cookie = (*c_cookie)[0]->dataRef
           (Type2Type<diameter_octetstring_t>());
       if (c_eapPayload) {
           throw (PANA_Exception(PANA_Exception::FAILED, 
                                 "Both cookie and EAP AVP present in PSR"));
       }
       SendStartAnswer(NULL);
   }
   else if (c_eapPayload) {
       diameter_octetstring_t &eapPayload = (*c_eapPayload)[0]->
           dataRef(Type2Type<diameter_octetstring_t>());

       m_InStatefulDiscovery = true;
       
       AAAMessageBlock *block = AAAMessageBlock::Acquire
           ((char*)eapPayload.data(), eapPayload.size());              
       static_cast<PANA_ClientEventInterface&>(m_Event).EapRequest
           (block, PANA_PINFO_NONE);
       block->Release();
   }
   else {
       SendStartAnswer(NULL);
   }
}

void PANA_Client::SendStartAnswer(AAAMessageBlock *response)
{
   /*
      When a PaC receives the PANA-Start-Request message in response to the
      PANA-PAA-Discover message, it responds with a PANA-Start-Answer
      message if it wishes to enter the authentication phase.  The
      PANA-Start-Answer message contains the initial sequence numbers in
      the tseq and rseq fields of the PANA header, a copy of the received
      Cookie (if any) as the PANA payload.

      If the S-flag of the received PANA-Start-Request message is not set,
      PaC MUST NOT set the S-flag in the PANA-Start-Answer message sent
      back to the PAA.  In this case, PaC can indicate its choice of ISP by
      including its ISP-Information AVP in the PANA-Start-Answer message.
      AAA routing will be based on the ISP choice if an ISP-Information AVP
      is specified in the PANA-Start-Answer message, otherwise it will be
      based on EAP identifier.

     9.3.4 PANA-Start-Answer (PSA)

       PANA-Start-Answer (PSA) is sent by the PaC to the PAA in response to
       a PANA-Start-Request message.  The PANA_start message transmission
       sequence number field is copied to the received sequence number
       field.  The transmission sequence number is set to initial random
       value.

             PANA-Start-Answer ::= < PANA-Header: 2 [SEP] >
                            [ Cookie ]
                            [ EAP-Payload ]
                            [ ISP-Information ]
                         *  [ AVP ]
    */

   AAAAvpContainerManager cm;
   AAAAvpContainerEntryManager em;
   PANA_Message *msg;

   ACE_NEW_NORETURN(msg, PANA_Message);
   if (msg == NULL) {
      throw (PANA_Exception(PANA_Exception::NO_MEMORY, 
                           "Failed to allocate start answer message"));
   }

   // Populate header
   PANA_MsgHeader::Flags flg = { 0, 0, 0, 0 }; // answer
   msg->flags(flg);
   msg->type(PANA_MTYPE_START);
   msg->tseq(m_InitialPacTsec);
   msg->rseq(m_LastReceivedTsec);
   msg->flags().separate = m_SeparateAuth;

   // Populate AVP's
   AAAAvpContainerEntry *e;
   if (response == NULL) {
      // Setup cookie avp 
      AAAAvpContainer *c_cookie = cm.acquire("Cookie");
      e = em.acquire(AAA_AVPDataType(AAA_AVP_STRING_TYPE));
      diameter_octetstring_t &dest_cookie = e->dataRef(Type2Type<diameter_octetstring_t>());
      c_cookie->add(e);

      // Add containers to list
      msg->avpList().add(c_cookie);

      // Populate cookie
      dest_cookie.assign(m_Cookie.data(), m_Cookie.size());
   }
   else {
      // Setup eap payload
      AAAAvpContainer *c_eapPayload = cm.acquire("EAP-Payload");
      e = em.acquire(AAA_AVP_STRING_TYPE);
      diameter_octetstring_t &eapPayload = e->dataRef(Type2Type<diameter_octetstring_t>());
      c_eapPayload->add(e);

      // Add containers to listen
      msg->avpList().add(c_eapPayload);

      // Populate eap payload
      eapPayload.assign(response->base(), response->size());

      // done with stateful discovery
      m_InStatefulDiscovery = false;
   }

   // Populate ISP-Information if ANY
   if (m_IspSelected) {
       
       ACE_DEBUG((LM_INFO, "(%P|%t) Selected ISP: [id=%d] %s\n",
                  m_PreferedISP.id_, m_PreferedISP.name_.data()));
       
       AAAAvpContainer *c_ispInfo = cm.acquire("ISP-Information");        
       e = em.acquire(AAA_AVP_GROUPED_TYPE);
       diameter_grouped_t &ispInfo = e->dataRef(Type2Type<diameter_grouped_t>());
       c_ispInfo->add(e);

       // Add containers to list and populate
       msg->avpList().add(c_ispInfo);
       PANA_ProviderInfoTool infoTool;
       infoTool.Add(ispInfo, m_PreferedISP);
   }

   // send session-id avp if session resumption
   if (PANA_CONFIG_GENERAL().mobility_) {

      AAAAvpContainerEntry *e;
      AAAAvpContainer *c_sessionId = cm.acquire("Session-Id");

      // Add the AVP's to containers
      e = em.acquire(AAA_AVP_UTF8_STRING_TYPE);
      diameter_utf8string_t &sid = e->dataRef(Type2Type<diameter_utf8string_t>());
      c_sessionId->add(e);

      msg->avpList().add(c_sessionId);
      sid.assign(m_SessionId.data(), m_SessionId.size());
  }

  DestinationAddressFormatting(*msg);
  m_TxChannel.Send(*this, *msg);

  ACE_DEBUG((LM_INFO, "(%P|%t) SEND: Start-Answer, tseq=%d, rseq=%d\n",
             msg->tseq(), msg->rseq()));

  PANA_RtQueueMsgBlockData data(response);
  if (m_RtQueue.Schedule(data)) {
      m_Timer.Schedule(PANA_TID_PSA_RETRY, data.Timeout());       
  }
}

void PANA_Client::RetryStartAnswer()
{
   m_Timer.Cancel(PANA_TID_PSA_RETRY);
   
   PANA_RtQueueData *data = NULL;
   if (m_RtQueue.ReSchedule(data)) {
       SendStartAnswer(static_cast<PANA_RtQueueMsgBlockData*>(data)->MsgBlock());
       m_Timer.Schedule(PANA_TID_PSA_RETRY, data->Timeout());       
   }
   else {
       m_Timer.Schedule(PANA_TID_DISCONNECT, 0);
   }
}

void PANA_Client::ReceiveEapRequest()
{
   PANA_Message &msg = *(m_RxMessageQueue.front());
   m_RxMessageQueue.pop_front();

   ACE_DEBUG((LM_INFO, "(%P|%t) RECV: EAP-Request, S-flag %d, tseq=%d, rseq=%d\n",
              msg.flags().separate, msg.tseq(), msg.rseq()));

   // cancel discovery retry if any
   m_Timer.Cancel(PANA_TID_DISC_RETRY);
   m_RtQueue.ClearFront();
   
   // cancel start answer retry if any
   m_Timer.Cancel(PANA_TID_PSA_RETRY);
   m_RtQueue.ClearFront();

   if (m_SessionId.size() == 0) {
      // save session id
      AAAAvpContainer *c_sessionId = msg.avpList().search("Session-Id");
      diameter_utf8string_t &id = (*c_sessionId)[0]->dataRef(Type2Type<diameter_utf8string_t>());
      m_SessionId.assign(id.data(), id.size());
   }

   // extract EAP payload
   AAAAvpContainer* c_eapPayload = msg.avpList().search("EAP-Payload");
   diameter_octetstring_t &eapPayload = (*c_eapPayload)[0]->dataRef(Type2Type<diameter_octetstring_t>());

   // invoke application handler
   AAAMessageBlock *block = AAAMessageBlock::Acquire((char*)eapPayload.data(), 
                                                     eapPayload.size());              

   AAAAvpContainer *c_pInfo;
   diameter_grouped_t *pList = NULL;
   PANA_PINFO type = PANA_PINFO_NONE;

   // NAP/ISP processing
   if ((c_pInfo = msg.avpList().search("NAP-Information"))) {
       pList = (*c_pInfo)[0]->dataPtr(Type2Type<diameter_grouped_t>());
       type = PANA_PINFO_NAP;
   }
   else if ((c_pInfo = msg.avpList().search("ISP-Information"))) {
       pList = (*c_pInfo)[0]->dataPtr(Type2Type<diameter_grouped_t>());
       type = PANA_PINFO_ISP;
   }

   // invoke the EAP handler
   if (pList) {
       PANA_CfgProviderInfo pInfo;
       PANA_ProviderInfoTool infoTool;
       infoTool.Extract(*pList, pInfo);
       static_cast<PANA_ClientEventInterface&>(m_Event).EapRequest(block, type, &pInfo);
   }
   else {
       static_cast<PANA_ClientEventInterface&>(m_Event).EapRequest(block, type);
   }
   block->Release();
   delete &msg;
}

void PANA_Client::ReceiveEapReAuthRequest()
{
   PANA_Message &msg = *(m_RxMessageQueue.front());
   m_RxMessageQueue.pop_front();

   ACE_DEBUG((LM_INFO, "(%P|%t) RECV: EAP-ReAuth-Request, S-flag %d, tseq=%d, rseq=%d\n",
              msg.flags().separate, msg.tseq(), msg.rseq()));

   // notify EAP
   ReAuthenticate(PANA_REAUTH_EAP);
   
   // extract EAP payload
   AAAAvpContainer* c_eapPayload = msg.avpList().search("EAP-Payload");
   diameter_octetstring_t &eapPayload = (*c_eapPayload)[0]->dataRef(Type2Type<diameter_octetstring_t>());

   // invoke application handler
   AAAMessageBlock *block = AAAMessageBlock::Acquire((char*)eapPayload.data(), 
                                                     eapPayload.size());              

   static_cast<PANA_ClientEventInterface&>(m_Event).EapRequest(block, PANA_PINFO_NONE);
   block->Release();
   delete &msg;
}

void PANA_Client::SendEapResponse(AAAMessageBlock *response)
{
   /*
       PaC      PAA  Message(tseq,rseq)[AVPs] 
       ------------------------------------------------- 
                     (continued from discovery and initial handshake phase) 
          <-----     PANA-Auth-Request(x+1,y)[EAP{Request}] 
          ----->     PANA-Auth-Answer(y+1,x+1)[EAP{Response}] 
            . 
            . 
          <-----     PANA-Auth-Request (x+2,y+1)[EAP{Request}] 
          ----->     PANA-Auth-Answer (y+2,x+2)[EAP{Response}] 
          <-----     PANA-Bind-Request(x+3,y+2)                // F-flag 
       set 
                       [EAP{Success}, Device-Id, Protection-Cap., MAC]  
          ----->     PANA-Bind-Answer(y+3,x+3) 
                       [Device-Id, Protection-Cap., MAC]  // F-flag set 

      9.3.6 PANA-Auth-Answer (PAN)

         PANA-Auth-Answer (PAN) is sent by the PaC to the PAA in response to a
         PANA-Auth-Request message.

              PANA-Auth-Answer ::= < PANA-Header: 3 >
                            < Session-Id >
                            < EAP-Payload >
                         *  [ AVP ]
                        0*1 < MAC >
    */
   AAAAvpContainerManager cm;
   AAAAvpContainerEntryManager em;
   PANA_Message *msg;

   ACE_NEW_NORETURN(msg, PANA_Message);
   if (msg == NULL) {
      throw (PANA_Exception(PANA_Exception::NO_MEMORY, 
                           "Failed to allocate msg message"));
   }

   // Populate header
   PANA_MsgHeader::Flags flg = { 0, 0, 0, 0 }; // TBD: answer
   msg->flags(flg);
   msg->type(PANA_MTYPE_AUTH);
   msg->tseq(++ m_LastTransmittedTsec);
   msg->rseq(m_LastReceivedTsec);

   // Populate AVP's
   AAAAvpContainerEntry *e;
   AAAAvpContainer *c_sessionId = cm.acquire("Session-Id");
   AAAAvpContainer *c_eapPayload = cm.acquire("EAP-Payload");

   // Add the AVP's to containers
   e = em.acquire(AAA_AVP_UTF8_STRING_TYPE);
   diameter_utf8string_t &sessionId = e->dataRef(Type2Type<diameter_utf8string_t>());
   c_sessionId->add(e);

   e = em.acquire(AAA_AVP_STRING_TYPE);
   diameter_octetstring_t &eapPayload = e->dataRef(Type2Type<diameter_octetstring_t>());
   c_eapPayload->add(e);

   // Add containers to listen
   msg->avpList().add(c_sessionId);
   msg->avpList().add(c_eapPayload);

   /*
     The EAP-Payload AVP (AVP Code 402) is of type OctetString and 
     is used to encapsulate the actual EAP packet [RFC2284] that is 
     being exchanged between the EAP client and the home Diameter 
     server.
    */

   sessionId.assign(m_SessionId.data(), m_SessionId.size());
   eapPayload.assign(response->base(), response->size());

   DestinationAddressFormatting(*msg, response);
   m_TxChannel.Send(*this, *msg);

   ACE_DEBUG((LM_INFO, "(%P|%t) SEND: EAP-Response, tseq=%d, rseq=%d\n",
              msg->tseq(), msg->rseq()));
}

void PANA_Client::ReceiveBindRequest()
{
   PANA_Message &msg = *(m_RxMessageQueue.front());
   m_RxMessageQueue.pop_front();

   // cancel discovery retry if any
   m_Timer.Cancel(PANA_TID_DISC_RETRY);
   m_RtQueue.ClearFront();
   
   // cancel start answer retry if any
   m_Timer.Cancel(PANA_TID_PSA_RETRY);
   m_RtQueue.ClearFront();

   if (BindResult() == PANA_BIND_SUCCESS_FINAL) {      
      AAAAvpContainer* c_sessionLifetime = msg.avpList().search
          ("Session-Lifetime");
      if (c_sessionLifetime) {
         diameter_unsigned32_t &sessLifetime = (*c_sessionLifetime)
                 [0]->dataRef(Type2Type<diameter_unsigned32_t>());
         m_SessionLifetime = sessLifetime;
         m_Timer.Schedule(PANA_TID_SESSION, sessLifetime);
      }
   }
               
   // extract EAP payload
   AAAAvpContainer* c_eapPayload = msg.avpList().search("EAP-Payload");
   if (c_eapPayload == NULL) {
      throw (PANA_Exception(PANA_Exception::INVALID_MESSAGE, 
                           "PANA client received bind msg with no EAP payload"));
   }
   diameter_octetstring_t &eapPayload = (*c_eapPayload)[0]->dataRef(
       Type2Type<diameter_octetstring_t>());

   AAAMessageBlock *block = AAAMessageBlock::Acquire((char*)eapPayload.data(), 
                                                     eapPayload.size());

   AAAAvpContainer* c_rcode = msg.avpList().search("Result-Code");
   if (c_rcode == NULL) {
      throw (PANA_Exception(PANA_Exception::INVALID_MESSAGE, 
                           "PANA client received bind msg with no result code"));
   }
   diameter_unsigned32_t &rcode = (*c_rcode)[0]->dataRef(Type2Type<diameter_unsigned32_t>());

   diameter_unsigned32_t pcap = PANA_PCAP_UNKNOWN;
   AAAAvpContainer* c_pcap = msg.avpList().search("Protection-Capability");
   if (c_pcap) {
       pcap = (*c_pcap)[0]->dataRef(Type2Type<diameter_unsigned32_t>());
   }

   AAAAvpContainer* c_keyId = msg.avpList().search("Key-Id");
   if (c_keyId) {
       diameter_integer32_t &id = (*c_keyId)[0]->dataRef
           (Type2Type<diameter_integer32_t>());
       if (m_SA.KeyId() != id) {
           m_SA.KeyId(id);
           m_RegenerateKey = true;
       }
   }

   PANA_DeviceIdContainer epId;
   AAAAvpContainer* c_epId = msg.avpList().search("EP-Device-Id");
   if (c_epId) {
       for (unsigned int i=0; i<c_epId->size(); i++) {           
           PANA_TVData_t &deviceId = (*c_epId)[i]->dataRef(Type2Type<PANA_TVData_t>());
           PANA_DeviceId newId(PANA_DeviceId::TYPE(deviceId.type));
           std::string &value = const_cast<std::string&>(newId.id());
           value.assign(deviceId.value.data(), deviceId.value.size());
           epId.clone(newId);
       }
   }
   
   AAAAvpContainer* c_deviceId = msg.avpList().search("Device-Id");
   if (c_deviceId) {
       PANA_TVData_t &deviceId = (*c_deviceId)[0]->dataRef(Type2Type<PANA_TVData_t>());
       m_ReqDeviceId = PANA_DeviceId::TYPE(deviceId.type);
   }

   ACE_DEBUG((LM_INFO, "(%P|%t) RECV: Bind-Request, tseq=%d, rseq=%d\n",
              msg.tseq(), msg.rseq()));

   static_cast<PANA_ClientEventInterface&>(m_Event).EapRequest
       (block, rcode, pcap, epId);
   block->Release();

   if (BindResult() == PANA_BIND_FAILED) {
       // For INITIAL, INTERIM and FINAL, API must
       // be called to send a bind answer
       SendBindAnswer();
       PANA_Session::Disconnect(PANA_TC_ADMINISTRATIVE);
   }
   delete &msg;
}

void PANA_Client::SendBindAnswer()
{
   /*
       PaC      PAA  Message(tseq,rseq)[AVPs] 
       ------------------------------------------------- 
                     (continued from discovery and initial handshake phase) 
          <-----     PANA-Auth-Request(x+1,y)[EAP{Request}] 
          ----->     PANA-Auth-Answer(y+1,x+1)[EAP{Response}] 
            . 
            . 
          <-----     PANA-Auth-Request (x+2,y+1)[EAP{Request}] 
          ----->     PANA-Auth-Answer (y+2,x+2)[EAP{Response}] 
          <-----     PANA-Bind-Request(x+3,y+2) // F-flag set 
                       [EAP{Success}, Device-Id, Protection-Cap., MAC]  
          ----->     PANA-Bind-Answer(y+3,x+3) 
                       [Device-Id, Protection-Cap., MAC]  // F-flag set 

       9.3.8 PANA-Bind-Answer (PBA)

        PANA-Bind-Answer (PBA) is sent by the PaC to the PAA in response to a
        PANA-Result-Request message.

              PANA-Bind-Answer ::= < PANA-Header: 4 >
                            < Session-Id >
                            < Device-Id >
                            [ Key-Id ]
                         *  [ AVP ]
                        0*1 < MAC >
   */

   AAAAvpContainerManager cm;
   AAAAvpContainerEntryManager em;
   PANA_Message *msg;

   ACE_NEW_NORETURN(msg, PANA_Message);
   if (msg == NULL) {
      throw (PANA_Exception(PANA_Exception::NO_MEMORY, 
                           "Failed to allocate msg message"));
   }

   // Populate header
   PANA_MsgHeader::Flags flg = { 0, 0, 0, 0 }; // answer
   msg->flags(flg);
   msg->type(PANA_MTYPE_BIND);
   msg->tseq(++ m_LastTransmittedTsec);
   msg->rseq(m_LastReceivedTsec);

   // Populate AVP's
   AAAAvpContainerEntry *e;
   AAAAvpContainer *c_sessionId = cm.acquire("Session-Id");
   AAAAvpContainer *c_deviceId = cm.acquire("Device-Id");

   // Add the AVP's to containers
   e = em.acquire(AAA_AVP_UTF8_STRING_TYPE);
   diameter_utf8string_t &sessionId = e->dataRef(Type2Type<diameter_utf8string_t>());
   c_sessionId->add(e);

   e = em.acquire(AAA_AVPDataType(AAA_AVP_DEVICEID_TYPE));
   PANA_TVData_t &deviceId = e->dataRef(Type2Type<PANA_TVData_t>());
   c_deviceId->add(e);

   // Add containers to list
   msg->avpList().add(c_sessionId);
   msg->avpList().add(c_deviceId);

   // Fill session id
   sessionId.assign(m_SessionId.data(), m_SessionId.size());

   // resolve source address
   PANA_DeviceIdContainer srcDevices;
   m_TxChannel.GetLocalAddress(srcDevices);

   // Fill device id
   PANA_DeviceId *id = srcDevices.search(m_ReqDeviceId);
   if (id == NULL) {
      throw (PANA_Exception(PANA_Exception::FAILED, 
            "No IPV4/MAC address given in the peer device list"));
   }
   deviceId.type = id->type();
   deviceId.value.assign(id->id().data(), id->id().size());

   // Fill in key id
   if (m_SA.MSK().length() > 0) {
       
       AAAAvpContainer *c_keyId = cm.acquire("Key-Id");
       
       e = em.acquire(AAA_AVP_INTEGER32_TYPE);
       diameter_integer32_t &keyId = e->dataRef(Type2Type<diameter_integer32_t>());
       c_keyId->add(e);
       
       msg->avpList().add(c_keyId);
       keyId = m_SA.KeyId();
       
       ACE_DEBUG((LM_INFO, "(%P|%t) key id=%d\n", id));
   }
   
   DestinationAddressFormatting(*msg);
   m_TxChannel.Send(*this, *msg);

   ACE_DEBUG((LM_INFO, "(%P|%t) SEND: Bind-Answer, tseq=%d, rseq=%d\n",
              msg->tseq(), msg->rseq()));
}

void PANA_Client::DestinationAddressFormatting(PANA_Message &msg,
                                               AAAMessageBlock *eapPayload)
{
   // Save the payload
   if (eapPayload) {
      if (m_LastPayload) {
         m_LastPayload->Release();
      }
      m_LastPayload = AAAMessageBlock::Acquire(eapPayload);
   }

   PANA_CfgClient &c = PANA_CONFIG_CLIENT();

   // compute output address
   PANA_DeviceId *ipId, *hwId;

   // Proper destination IP address hierarchy is as follows:
   //   a. locally stored peer device id if present
   //   b. configured ip address if present
   //   c. configured mcast address if present
   //   d. undeliverable if not found
   ipId = m_PeerDeviceId.search(PANA_DeviceId::IPV4_ADDRESS);
   if (ipId) {
      msg.srcDevices().clone(*ipId);
      msg.srcPort(m_PeerPort);
   }
   else {
      // have to compute peer IP address
      std::string *destIp;

      if (c.paa_ip_address_.size() > 0) {
         destIp = &c.paa_ip_address_;
         msg.srcPort(PANA_CONFIG_CLIENT().paa_port_number_);
      }
      else if (c.paa_mcast_address_.size() > 0) {
         destIp = &c.paa_mcast_address_;
         msg.srcPort(PANA_CONFIG_CLIENT().paa_mcast_port_number_);
      }
      else {
         throw (PANA_Exception(PANA_Exception::FAILED, 
                              "Unable to configure a destination address"));
      }

      char buf[64];
      ACE_OS::sprintf(buf, "%s:%d", destIp->data(), c.paa_port_number_);
      ACE_INET_Addr paaAddr(buf);

      ACE_NEW_NORETURN(ipId, PANA_DeviceId(PANA_DeviceId::IPV4_ADDRESS));

      if (ipId == NULL) {
         throw (PANA_Exception(PANA_Exception::NO_MEMORY, 
                              "Failed to allocate IP device id"));
      }

      ACE_UINT32 ipAddr = paaAddr.get_ip_address();
      const_cast<std::string&>(ipId->id()).assign((char*)&ipAddr, sizeof(ACE_UINT32));

      msg.srcDevices().push_back(ipId);
   }

   // Proper destination L2 address hierarchy is as follows:
   //   a. locally stored peer device id if present
   hwId = m_PeerDeviceId.search(PANA_DeviceId::LL_ADDRESS);
   if (hwId) {
      msg.srcDevices().clone(*hwId);
   }
}

bool PANA_Client::IspSelection(AAAAvpContainer* c_ispInfo)
{
   ACE_DEBUG((LM_INFO, "(%P|%t) ISP information received [count=%d]\n", c_ispInfo->size()));

   PANA_CfgProviderList ispList;
   PANA_CfgProviderList::iterator n;
   PANA_CfgProviderInfo *ispInfo, *ispChoice = NULL;
   
   try {
       // ask user to choose isp
       for (unsigned int i = 0; i < c_ispInfo->size(); i ++) {

          ACE_NEW_NORETURN(ispInfo, PANA_CfgProviderInfo);
          if (ispInfo) {
              PANA_ProviderInfoTool infoTool;
              diameter_grouped_t &isp = (*c_ispInfo)[i]->dataRef(Type2Type<diameter_grouped_t>());
              infoTool.Extract(isp, *ispInfo);
              ispList.push_back(ispInfo);
          }
          else {
             throw (PANA_Exception(PANA_Exception::NO_MEMORY, 
                                  "Failed to allocate ISP structure"));
          }
       }

       static_cast<PANA_ClientEventInterface&>(m_Event).ChooseISP(ispList, ispChoice);
       if (ispChoice) {
           throw(true);
       }
   
       // select from configuration
       if (PANA_CONFIG_CLIENT().isp_info_.name_.length() > 0) {
           for (n = ispList.begin(); n != ispList.end(); n++) {
               ispChoice = *n;
               if (PANA_CONFIG_CLIENT().isp_info_.name_ == ispChoice->name_) {
                   throw (true);
               }
           }
       }
       throw (false);
   }
   catch (const PANA_Exception &c) {
       ACE_UNUSED_ARG(c);
   }
   catch (bool rc) {
       if (rc) {
           m_PreferedISP.name_ = ispChoice->name_;
           m_PreferedISP.id_   = ispChoice->id_;
           
           ACE_DEBUG((LM_INFO, "(%P|%t) ISP information choosen: id=%d %s\n",
                 m_PreferedISP.id_, m_PreferedISP.name_.data()));      
       }
       n = ispList.begin();
       while (! ispList.empty()) {
           ispChoice = ispList.front();
           ispList.pop_front();
           delete ispChoice;
       }
       return (rc);
   }
   
   return (false);
}

---