pana_paa_fsm.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_paa_fsm.h"

PANA_PaaStateTable PANA_PaaSession::m_StateTable;
typedef PANA_SessionRxInterface<PANA_Paa> PANA_PaaSessionRxInterface;

class PANA_PsmRxDiscover : public PANA_PaaSessionRxInterface
{
   public:
      PANA_PsmRxDiscover(PANA_Paa &a, PANA_PaaSession &s) : 
         PANA_PaaSessionRxInterface(a),
         m_Session(s) { }
      virtual void operator()(PANA_Message &msg) { 
         // first level validation
         m_arg.ValidateMessage(msg);

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

         m_arg.m_RxMessageQueue.push_back(&msg);         
         m_Session.Notify(PANA_RX_DISCOVER); 
      }
      virtual PANA_PaaSessionRxInterface *clone() { return (new PANA_PsmRxDiscover(*this)); }
   private:
      PANA_PaaSession &m_Session;
};

class PANA_PsmRxStartMsg : public PANA_PaaSessionRxInterface
{
   public:
      PANA_PsmRxStartMsg(PANA_Paa &a, PANA_PaaSession &s) : 
         PANA_PaaSessionRxInterface(a),
         m_Session(s) { }
      virtual void operator()(PANA_Message &msg) { 
         // first level validation
         if (msg.flags().request) {
            throw (PANA_Exception(PANA_Exception::INVALID_MESSAGE, 
                  "server received invalid message in discovery state"));
         }
         // PSA processing with mobility support 
         if (m_arg.m_SessionId.size() > 0) {
            if (! PANA_CONFIG_AUTHAGENT().use_cookie_) {
                throw (PANA_Exception(PANA_Exception::INVALID_MESSAGE, 
                      "PSA w/ session id received under stateful mode"));
            }
            if (! PANA_CONFIG_GENERAL().mobility_) {
                throw (PANA_Exception(PANA_Exception::INVALID_MESSAGE, 
                      "Session resumption not enabled, discarding message"));
            }
            PANA_Paa::ValidateCookie(msg);
            m_Session.Notify(PANA_RX_START_ANSWER_SR);
            return;
         }
         // second level validation
         m_arg.ValidateMessage(msg);
         // trigger event
         m_arg.m_RxMessageQueue.push_back(&msg);         
         m_Session.Notify(PANA_RX_START_ANSWER); 
      }
      virtual PANA_PaaSessionRxInterface *clone() { return (new PANA_PsmRxStartMsg(*this)); }
   private:
      PANA_PaaSession &m_Session;
};

class PANA_PsmRxAuthMsg : public PANA_PaaSessionRxInterface
{
   public:
      PANA_PsmRxAuthMsg(PANA_Paa &a, PANA_PaaSession &s) : 
         PANA_PaaSessionRxInterface(a),
         m_Session(s) { }
      virtual void operator()(PANA_Message &msg) { 
         // first level validation
         m_arg.ValidateMessage(msg);
         // second level validation
         if (msg.flags().request) {
            throw (PANA_Exception(PANA_Exception::INVALID_MESSAGE, 
                                 "server received invalid message"));
         }
         m_arg.m_RxMessageQueue.push_back(&msg); 
         m_Session.Notify(PANA_RX_AUTH_ANSWER); 
      }
      virtual PANA_PaaSessionRxInterface *clone() { return (new PANA_PsmRxAuthMsg(*this)); }
   private:
      PANA_PaaSession &m_Session;
};

class PANA_PsmRxBindMsg : public PANA_PaaSessionRxInterface
{
   public:
      PANA_PsmRxBindMsg(PANA_Paa &a, PANA_PaaSession &s) : 
         PANA_PaaSessionRxInterface(a),
         m_Session(s) { }
      virtual void operator()(PANA_Message &msg) {
         // first level validation
         m_arg.ValidateMessage(msg);
         
         // second level validation
         if ((msg.type() != PANA_MTYPE_BIND) && msg.flags().request) {
            throw (PANA_Exception(PANA_Exception::INVALID_MESSAGE, 
                                 "server received invalid message"));
         }

         ACE_DEBUG((LM_INFO, "(%P|%t) RECV: Bind answer [session], S-flag %d, tseq=%d, rseq=%d\n",
                    msg.flags().separate, msg.tseq(), msg.rseq()));

         AAA_Event ev;
         AAAAvpContainer *c_keyId;
         switch (m_arg.BindResult()) {
            case PANA_BIND_SUCCESS_INITIAL: 
            case PANA_BIND_SUCCESS_FINAL:
               // key id validation
               if ((c_keyId = msg.avpList().search("Key-Id"))) {
                   diameter_integer32_t &id = (*c_keyId)[0]->dataRef
                          (Type2Type<diameter_integer32_t>());
                   if (id != m_arg.SA().KeyId()) {
                      throw (PANA_Exception(PANA_Exception::INVALID_MESSAGE, 
                                     "server received bind answer with mis-match key id"));
                   }
                   ACE_DEBUG((LM_INFO, "(%P|%t) key id=%d\n", id));
               }
         
               // schedule session timeout
               m_Session.Timer().Schedule(PANA_TID_SESSION,
                                          PANA_CONFIG_AUTHAGENT().sessionLifetime_);
               // fall through
            case PANA_BIND_FAILED:  ev = PANA_RX_BIND_ANSWER;        break;
            case PANA_BIND_INTERIM: ev = PANA_RX_BIND_ANSWER_2NDEAP; break;
            default:
               throw (PANA_Exception(PANA_Exception::INVALID_MESSAGE, 
                                    "server computed invalid bind result"));
         }
         m_arg.m_RxMessageQueue.push_back(&msg); 
         m_Session.Notify(ev);
      };
      virtual PANA_PaaSessionRxInterface *clone() { return (new PANA_PsmRxBindMsg(*this)); }
   private:
      PANA_PaaSession &m_Session;
};

class PANA_PsmRxReAuthMsg : public PANA_PaaSessionRxInterface
{
   public:
      PANA_PsmRxReAuthMsg(PANA_Paa &a, PANA_PaaSession &s) : 
         PANA_PaaSessionRxInterface(a),
         m_Session(s) { }
      virtual void operator()(PANA_Message &msg) {
         // first level validation
         m_arg.ValidateMessage(msg);

         if (msg.flags().request) {
            m_arg.m_RxMessageQueue.push_back(&msg); 
            m_Session.Notify(PANA_RX_REAUTH_REQUEST);
         }
         else if ((m_arg.SA().MSK().size() > 0) && PANA_CONFIG_GENERAL().mobility_) {
            m_arg.m_RxMessageQueue.push_back(&msg); 
            m_Session.Notify(PANA_RX_REAUTH_ANSWER); 
         }
         else {
            delete &msg;
         }
      };
      virtual PANA_PaaSessionRxInterface *clone() { return (new PANA_PsmRxReAuthMsg(*this)); }
   private:
      PANA_PaaSession &m_Session;
};

class PANA_PsmRxTermMsg : public PANA_PaaSessionRxInterface
{
   public:
      PANA_PsmRxTermMsg(PANA_Paa &a, PANA_PaaSession &s) : 
         PANA_PaaSessionRxInterface(a),
         m_Session(s) { }
      virtual void operator()(PANA_Message &msg) {
         // first level validation
         m_arg.ValidateMessage(msg);
  
         m_arg.m_RxMessageQueue.push_back(&msg); 
         (msg.flags().request) ?  m_Session.Notify(PANA_RX_TERM_REQUEST) :
                                  m_Session.Notify(PANA_RX_TERM_ANSWER); 
      };
      virtual PANA_PaaSessionRxInterface *clone() { return (new PANA_PsmRxTermMsg(*this)); }
   private:
      PANA_PaaSession &m_Session;
};

void PANA_PaaSession::InitializeMsgMaps()
{
   PANA_PsmRxDiscover discover(m_Paa, *this);
   m_MsgHandlers.Register(PANA_MTYPE_DISCOVER, discover);

   PANA_PsmRxStartMsg startMsg(m_Paa, *this);
   m_MsgHandlers.Register(PANA_MTYPE_START, startMsg);

   PANA_PsmRxAuthMsg authMsg(m_Paa, *this);
   m_MsgHandlers.Register(PANA_MTYPE_AUTH, authMsg);

   PANA_PsmRxBindMsg bindMsg(m_Paa, *this);
   m_MsgHandlers.Register(PANA_MTYPE_BIND, bindMsg);

   PANA_PsmRxReAuthMsg reAuthMsg(m_Paa, *this);
   m_MsgHandlers.Register(PANA_MTYPE_REAUTH, reAuthMsg);

   PANA_PsmRxTermMsg termMsg(m_Paa, *this);
   m_MsgHandlers.Register(PANA_MTYPE_TERM, termMsg);
}

void PANA_PaaSession::FlushMsgMaps()
{
   m_MsgHandlers.Remove(PANA_MTYPE_START);
   m_MsgHandlers.Remove(PANA_MTYPE_AUTH);
   m_MsgHandlers.Remove(PANA_MTYPE_BIND);
   m_MsgHandlers.Remove(PANA_MTYPE_REAUTH);
   m_MsgHandlers.Remove(PANA_MTYPE_TERM);
}

PANA_PaaSessionChannel::PANA_PaaSessionChannel(PANA_Node &n) :
          m_Node(n),
          m_UdpChannel(n.Job(), "PAA UDP Channel"),
          m_McastChannel(n.Job(), "PAA Mcast Channel") 
{
   ACE_INET_Addr addr;
   PANA_UdpTransport tempSock;
   try {
       if (tempSock.open(PANA_CONFIG_GENERAL().iface_name_, addr) < 0) {
           throw (0);
       }
             
       PANA_DeviceIdContainer dev;
       if (tempSock.get_local_addr(dev) < 0) {
           throw (1);
       }
             
       PANA_DeviceId *id = dev.search(PANA_DeviceId::IPV4_ADDRESS);
       if (id == NULL) {
           throw (1);
       }
             
       ACE_UINT32 *ipAddr = (ACE_UINT32*)id->id().data();
       addr.set((u_short)PANA_CONFIG_GENERAL().listen_port_, *ipAddr);             
       tempSock.close();
    }
    catch (int rc) {
       if (rc) {
           tempSock.close();
       }
       char localBuf[64];
       ACE_OS::sprintf(localBuf, "Failed to retrieve local address for %s",
                       PANA_CONFIG_GENERAL().iface_name_.data());
       throw (PANA_Exception(PANA_Exception::FAILED, localBuf));
    }
         
    m_UdpChannel.Open(addr);

    char strAddr[64];
    ACE_OS::sprintf(strAddr, "%s:%d",
                    PANA_CONFIG_AUTHAGENT().mcast_address_.data(),
                    PANA_CONFIG_AUTHAGENT().mcast_port_number_);
    addr.set(strAddr);
    m_McastChannel.Open(addr);
}

PANA_PaaSessionChannel::~PANA_PaaSessionChannel()
{
    m_UdpChannel.Close();
    m_McastChannel.Close();
}

---