pana_paa_fsm.h

/* 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                                                          */

#ifndef __PANA_PAA_FSM_H__
#define __PANA_PAA_FSM_H__

#include "ace/Singleton.h"
#include "pana_exports.h"
#include "pana_fsm.h"
#include "pana_paa.h"
#include "pana_database.h"

class PANA_EXPORT PANA_PaaStateTable : public AAA_StateTable<PANA_Paa>
{
   public:
      class PaaReceiveDiscover : public AAA_Action<PANA_Paa> {
         virtual void operator()(PANA_Paa &a) { a.ReceiveDiscover(); }
      };

      class PaaReceiveStartAnswer : public AAA_Action<PANA_Paa> {
         virtual void operator()(PANA_Paa &a) { a.ReceiveStartAnswer(); }
      };

      class PaaReceiveEapReAuth : public AAA_Action<PANA_Paa> {
         virtual void operator()(PANA_Paa &a) { a.ReceiveEapReAuth(); }
      };

      class PaaReceiveEapResponse : public AAA_Action<PANA_Paa> {
         virtual void operator()(PANA_Paa &a) { a.ReceiveEapResponse(); }
      };

      class PaaReceive2ndEapStart : public AAA_Action<PANA_Paa> {
         virtual void operator()(PANA_Paa &a) { a.Receive2ndEapStart(); }
      };

      class PaaSendReAuthRequest : public AAA_Action<PANA_Paa> {
         virtual void operator()(PANA_Paa &a) { a.SendReAuthenticateRequest(); }
      };

      class PaaReceiveReAuthRequest : public AAA_Action<PANA_Paa> {
         virtual void operator()(PANA_Paa &a) { a.ReceiveReAuthenticateRequest(); }
      };

      class PaaReceiveReAuthAnswer : public AAA_Action<PANA_Paa> {
         virtual void operator()(PANA_Paa &a) { a.ReceiveReAuthenticateAnswer(); }
      };

      class PaaReceiveBindAnswer : public AAA_Action<PANA_Paa> {
         virtual void operator()(PANA_Paa &a) { a.ReceiveBindAnswer(); }
      };

      class PaaSendTermRequest : public AAA_Action<PANA_Paa> {
         virtual void operator()(PANA_Paa &a) { a.SendTerminationRequest(); }
      };

      class PaaReceiveTermRequest : public AAA_Action<PANA_Paa> {
         virtual void operator()(PANA_Paa &a) { a.ReceiveTerminationRequest(); }
      };

      class PaaReceiveTermAnswer : public AAA_Action<PANA_Paa> {
         virtual void operator()(PANA_Paa &a) { a.ReceiveTerminationAnswer(); }
      };

      class PaaDisconnect : public AAA_Action<PANA_Paa> {
         virtual void operator()(PANA_Paa &a) { a.Disconnect(PANA_AUTHENTICATION_REJECTED); }
      };

      class PaaReAuthTimeout : public AAA_Action<PANA_Paa> {
         virtual void operator()(PANA_Paa &a) { a.Disconnect(PANA_SESSION_TIMEOUT); }
      };

      class PaaBindRequestTimeout : public AAA_Action<PANA_Paa> {
        virtual void operator()(PANA_Paa &a) { a.RetryBindRequest(); }
      };

      class PaaReAuthRequestTimeout : public AAA_Action<PANA_Paa> {
        virtual void operator()(PANA_Paa &a) { a.RetryReAuthenticateRequest(); }
      };

      class PaaTermRequestTimeout : public AAA_Action<PANA_Paa> {
        virtual void operator()(PANA_Paa &a) { a.RetryTerminationRequest(); }
      };
    
      class PaaRetryTimeout : public AAA_Action<PANA_Paa> {
        virtual void operator()(PANA_Paa &a) { a.Disconnect(PANA_RETRY_TIMEOUT); }
      };

      typedef AAA_NullAction<PANA_Paa> PaaNullAction;

      PANA_PaaStateTable() {

         AddStateTableEntry(PANA_ST_OFFLINE, PANA_RX_DISCOVER,
                            PANA_ST_STATEFUL_DISC, m_acReceiveDiscover);

         AddStateTableEntry(PANA_ST_OFFLINE, PANA_RX_START_ANSWER,
                            PANA_ST_WAIT_AUTH_ANSWER, m_acReceiveStartAnswer);

         AddStateTableEntry(PANA_ST_OFFLINE, PANA_RX_START_ANSWER_SR,
                            PANA_ST_WAIT_AUTH_ANSWER, m_acSendReAuthRequest);

         AddWildcardStateTableEntry(PANA_ST_OFFLINE, PANA_ST_OFFLINE);
        
         AddStateTableEntry(PANA_ST_STATEFUL_DISC, PANA_SIG_EAP_REQUEST,
                            PANA_ST_STATEFUL_DISC, m_acNullAction());

         AddStateTableEntry(PANA_ST_STATEFUL_DISC, PANA_RX_START_ANSWER,
                            PANA_ST_WAIT_AUTH_ANSWER, m_acReceiveStartAnswer);

         AddWildcardStateTableEntry(PANA_ST_STATEFUL_DISC, PANA_ST_STATEFUL_DISC);
         
         AddStateTableEntry(PANA_ST_AUTH_FAILED, PANA_RX_BIND_ANSWER,
                            PANA_ST_OFFLINE, m_acDisconnect);

         AddStateTableEntry(PANA_ST_AUTH_FAILED, PANA_TM_BINDREQ_TIMEOUT,
                            PANA_ST_AUTH_FAILED, m_acBindRequestTimeout);

         AddStateTableEntry(PANA_ST_AUTH_FAILED, PANA_TM_DISCONNECT,
                            PANA_ST_OFFLINE, m_acRetryTimeout);

         AddWildcardStateTableEntry(PANA_ST_AUTH_FAILED, PANA_ST_AUTH_FAILED);
         
         AddStateTableEntry(PANA_ST_WAIT_AUTH_ANSWER, PANA_SIG_EAP_REQUEST,
                            PANA_ST_WAIT_AUTH_ANSWER, m_acNullAction());

         AddStateTableEntry(PANA_ST_WAIT_AUTH_ANSWER, PANA_RX_AUTH_ANSWER,
                            PANA_ST_WAIT_EAP, m_acReceiveEapResponse);

         AddWildcardStateTableEntry(PANA_ST_WAIT_AUTH_ANSWER, PANA_ST_WAIT_AUTH_ANSWER);
         
         AddStateTableEntry(PANA_ST_WAIT_EAP, PANA_SIG_EAP_FAILURE,
                            PANA_ST_AUTH_FAILED, m_acNullAction());

         AddStateTableEntry(PANA_ST_WAIT_EAP, PANA_SIG_EAP_REQUEST,
                            PANA_ST_WAIT_AUTH_ANSWER, m_acNullAction());

         AddStateTableEntry(PANA_ST_WAIT_EAP, PANA_SIG_EAP_SUCCESS,
                            PANA_ST_WAIT_SUCCESS_BIND_ANSWER, m_acNullAction());

         AddWildcardStateTableEntry(PANA_ST_WAIT_EAP, PANA_ST_WAIT_EAP);
         
         AddStateTableEntry(PANA_ST_WAIT_SUCCESS_BIND_ANSWER, PANA_RX_BIND_ANSWER,
                            PANA_ST_OPEN, m_acReceiveBindAnswer);

         AddStateTableEntry(PANA_ST_WAIT_SUCCESS_BIND_ANSWER, PANA_RX_BIND_ANSWER_2NDEAP,
                            PANA_ST_WAIT_AUTH_ANSWER, m_acReceive2ndEapStart);

         AddStateTableEntry(PANA_ST_WAIT_SUCCESS_BIND_ANSWER, PANA_TM_BINDREQ_TIMEOUT,
                            PANA_ST_WAIT_SUCCESS_BIND_ANSWER, m_acBindRequestTimeout);

         AddStateTableEntry(PANA_ST_WAIT_SUCCESS_BIND_ANSWER, PANA_TM_DISCONNECT,
                            PANA_ST_OFFLINE, m_acRetryTimeout);

         AddWildcardStateTableEntry(PANA_ST_WAIT_SUCCESS_BIND_ANSWER, PANA_ST_WAIT_SUCCESS_BIND_ANSWER);
         
         AddStateTableEntry(PANA_ST_OPEN, PANA_TM_SESSION_TIMEOUT,
                            PANA_ST_WAIT_AUTH_ANSWER, m_acReceiveEapReAuth);

         AddStateTableEntry(PANA_ST_OPEN, PANA_RX_DISCOVER,
                            PANA_ST_WAIT_AUTH_ANSWER, m_acReceiveEapReAuth);

         AddStateTableEntry(PANA_ST_OPEN, PANA_RX_REAUTH_REQUEST,
                            PANA_ST_OPEN, m_acReceiveReAuthRequest);

         AddStateTableEntry(PANA_ST_OPEN, PANA_SIG_TERMINATE_SESSION,
                            PANA_ST_SESSION_TERMINATION, m_acSendTermRequest);

         AddStateTableEntry(PANA_ST_OPEN, PANA_RX_TERM_REQUEST,
                            PANA_ST_OFFLINE, m_acReceiveTermRequest);

         AddStateTableEntry(PANA_ST_OPEN, PANA_SIG_REAUTH_USER,
                            PANA_ST_WAIT_REAUTH_ANSWER, m_acSendReAuthRequest);

         AddWildcardStateTableEntry(PANA_ST_OPEN, PANA_ST_OPEN);
         
         AddStateTableEntry(PANA_ST_WAIT_REAUTH_ANSWER, PANA_RX_REAUTH_ANSWER,
                            PANA_ST_OPEN, m_acReceiveReAuthAnswer);

         AddStateTableEntry(PANA_ST_WAIT_REAUTH_ANSWER, PANA_TM_REAUTHREQ_TIMEOUT,
                            PANA_ST_WAIT_REAUTH_ANSWER, m_acReAuthRequestTimeout);

         AddStateTableEntry(PANA_ST_WAIT_REAUTH_ANSWER, PANA_TM_DISCONNECT,
                            PANA_ST_OFFLINE, m_acRetryTimeout);

         AddStateTableEntry(PANA_ST_WAIT_REAUTH_ANSWER, PANA_TM_SESSION_TIMEOUT,
                            PANA_ST_OFFLINE, m_acReAuthTimeout);

         AddWildcardStateTableEntry(PANA_ST_WAIT_REAUTH_ANSWER, PANA_ST_WAIT_REAUTH_ANSWER);
         
         AddStateTableEntry(PANA_ST_SESSION_TERMINATION, PANA_TM_SESSION_TIMEOUT,
                            PANA_ST_OFFLINE, m_acDisconnect);

         AddStateTableEntry(PANA_ST_SESSION_TERMINATION, PANA_RX_TERM_ANSWER,
                            PANA_ST_OFFLINE, m_acReceiveTermAnswer);

         AddStateTableEntry(PANA_ST_SESSION_TERMINATION, PANA_TM_TERMREQ_TIMEOUT,
                            PANA_ST_SESSION_TERMINATION, m_acTermRequestTimeout);

         AddStateTableEntry(PANA_ST_SESSION_TERMINATION, PANA_TM_DISCONNECT,
                            PANA_ST_OFFLINE, m_acRetryTimeout);

         AddWildcardStateTableEntry(PANA_ST_SESSION_TERMINATION, PANA_ST_SESSION_TERMINATION);
         
         InitialState(PANA_ST_OFFLINE);
      }

   private:
      PaaReceiveDiscover      m_acReceiveDiscover;
      PaaReceiveStartAnswer   m_acReceiveStartAnswer;
      PaaReceiveEapResponse   m_acReceiveEapResponse;
      PaaReceiveEapReAuth     m_acReceiveEapReAuth;
      PaaReceive2ndEapStart   m_acReceive2ndEapStart;
      PaaReceiveBindAnswer    m_acReceiveBindAnswer;
      PaaSendReAuthRequest    m_acSendReAuthRequest;
      PaaReceiveReAuthRequest m_acReceiveReAuthRequest;
      PaaReceiveReAuthAnswer  m_acReceiveReAuthAnswer;
      PaaSendTermRequest      m_acSendTermRequest;
      PaaReceiveTermRequest   m_acReceiveTermRequest;
      PaaReceiveTermAnswer    m_acReceiveTermAnswer;
      PaaReAuthTimeout        m_acReAuthTimeout;
      PaaReAuthRequestTimeout m_acReAuthRequestTimeout;
      PaaBindRequestTimeout   m_acBindRequestTimeout;
      PaaTermRequestTimeout   m_acTermRequestTimeout;
      PaaRetryTimeout         m_acRetryTimeout;
      PaaDisconnect           m_acDisconnect;
      PaaNullAction           m_acNullAction;
};

class PANA_EXPORT PANA_PaaSessionChannel
{
   public:
      PANA_PaaSessionChannel(PANA_Node &n);
      ~PANA_PaaSessionChannel();

      PANA_Node &Node() {
          return m_Node;
      }
      PANA_UdpChannel &UdpChannel() {
          return m_UdpChannel;
      }
      PANA_McastChannel &McastChannel() {
          return m_McastChannel;
      }
      void RegisterHandler(AAA_CbFunction1<PANA_Message&> &h) {
          m_UdpChannel.RegisterHandler(h);
          m_McastChannel.RegisterHandler(h);
      }
      void RegisterHandler(AAA_CbFunction1<int> &h) {
          m_UdpChannel.RegisterHandler(h);
          m_McastChannel.RegisterHandler(h);
      }
      void RemoveHandler() {
          m_UdpChannel.RemoveHandler();
          m_McastChannel.RemoveHandler();
      }
          
   protected:
      PANA_Node &m_Node;
      PANA_UdpChannel m_UdpChannel;
      PANA_McastChannel m_McastChannel;
};

class PANA_EXPORT PANA_PaaSession : public PANA_StateMachine<PANA_Paa>
{
   public:
      PANA_PaaSession(PANA_PaaSessionChannel &ch,
                      PANA_PaaEventInterface &eif) :
         PANA_StateMachine<PANA_Paa>(m_Paa,
                                     m_StateTable,
                                     ch.Node(),
                                     ch.UdpChannel()),
         m_Paa(m_TxChannel, m_Timer, eif) {
         InitializeMsgMaps();
         PANA_StateMachine<PANA_Paa>::Start(); 
      }
      virtual ~PANA_PaaSession() { 
         PANA_StateMachine<PANA_Paa>::Stop(); 
         FlushMsgMaps(); 
      }
      virtual void Start() throw (AAA_Error) { 
      }
      virtual void SendEapRequest(AAAMessageBlock *request,
                                  PANA_PINFO type = PANA_PINFO_NONE) {
         m_Paa.SendEapMessage(request, type);
         Notify(PANA_SIG_EAP_REQUEST);
      }
      virtual void SendBindRequest(AAAMessageBlock *request, 
                                   ACE_UINT32 resultCode) {
         PANA_SIG ev;
         switch (m_Paa.BindResult(resultCode)) {
            case PANA_BIND_SUCCESS_INITIAL: 
            case PANA_BIND_SUCCESS_FINAL: 
            case PANA_BIND_INTERIM: ev = PANA_SIG_EAP_SUCCESS; break;
            case PANA_BIND_FAILED:  ev = PANA_SIG_EAP_FAILURE; break;
            default:
               throw (PANA_Exception(PANA_Exception::INVALID_MESSAGE, 
                                    "PANA paa received invalid bind event"));
         }
         m_Paa.SendBindRequest(request, resultCode);
         Notify(ev);
      }
      virtual void InstallMSK(diameter_octetstring_t &msk) {
         m_Paa.MSK(msk);
      }
      virtual PANA_DeviceId *PeerDeviceId() {
          return m_Paa.PeerDeviceId();
      }
      PANA_CfgProviderInfo &PreferedISP() {
          return m_Paa.PreferedISP();
      }
      PANA_CfgProviderInfo &PreferedNAP() {
          return m_Paa.PreferedNAP();
      }
      virtual void ReAuthenticate() { 
         Notify(PANA_SIG_REAUTH_USER); 
      }         
      virtual void Stop() { 
         m_Paa.m_TerminationCause = PANA_TC_ADMINISTRATIVE;
         Notify(PANA_SIG_TERMINATE_SESSION); 
      }

   private:
      void InitializeMsgMaps();
      void FlushMsgMaps();

      static PANA_PaaStateTable m_StateTable;
      PANA_Paa m_Paa;
};

typedef PANA_SessionTree<PANA_PaaSession> PANA_SessionDb;
typedef ACE_Singleton<PANA_SessionDb, ACE_Recursive_Thread_Mutex> PANA_SessionDb_S;

#define PANA_SESSIONDB()           PANA_SessionDb_S::instance()
#define PANA_SESSIONDB_ADD(x, y)   PANA_SessionDb_S::instance()->Add((x), (y))
#define PANA_SESSIONDB_DEL(x, y)   PANA_SessionDb_S::instance()->Remove((x), (y))
#define PANA_SESSIONDB_SEARCH(x)   PANA_SessionDb_S::instance()->Search((x))

#endif /* __PANA_PAA_FSM_H__ */

---