pana_client_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_CLIENT_FSM_H__
#define __PANA_CLIENT_FSM_H__

#include "framework.h"
#include "pana_fsm.h"
#include "pana_client.h"

class PANA_EXPORT PANA_ClientStateTable : public AAA_StateTable<PANA_Client>
{
   public:
      class PacSendDiscover : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.SendDiscover(); }
      };

      class PacReceiveStartRequest : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.ReceiveStartRequest(); }
      };

      class PacReceiveBindRequest : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.ReceiveBindRequest(); }
      };

      class PacReceiveAuthRequest : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.ReceiveEapRequest(); }
      };

      class PacReceiveEapReAuthRequest : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.ReceiveEapReAuthRequest(); }
      };

      class PacSendReAuthRequest : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.SendReAuthenticateRequest(); }
      };

      class PacReceiveReAuthRequest : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.ReceiveReAuthenticateRequest(); }
      };

      class PacReceiveReAuthAnswer : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.ReceiveReAuthenticateAnswer(); }
      };

      class PacSendTermRequest : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.SendTerminationRequest(); }
      };

      class PacReceiveTermRequest : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.ReceiveTerminationRequest(); }
      };

      class PacReceiveTermAnswer : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.ReceiveTerminationAnswer(); }
      };

      class PacDiscoverTimeout : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.RetryDiscover(); }
      };

      class PacStartAnswerTimeout : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.RetryStartAnswer(); }
      };

      class PacSessionTimeout : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.Disconnect(PANA_SESSION_TIMEOUT); }
      };

      class PacReAuthRequestTimeout : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.RetryReAuthenticateRequest(); }
      };

      class PacTermRequestTimeout : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.RetryTerminationRequest(); }
      };
    
      class PacRetryTimeout : public AAA_Action<PANA_Client> {
        virtual void operator()(PANA_Client &c) { c.Disconnect(PANA_RETRY_TIMEOUT); }
      };

      typedef AAA_NullAction<PANA_Client> PacNullAction;

      PANA_ClientStateTable() {

        AddStateTableEntry(PANA_ST_OFFLINE, PANA_SIG_AUTH_USER,
                           PANA_ST_DISCOVER, m_acSendDiscover);

        AddStateTableEntry(PANA_ST_OFFLINE, PANA_RX_START_REQUEST,
                           PANA_ST_WAIT_PAA, m_acReceiveStartRequest);

        AddWildcardStateTableEntry(PANA_ST_OFFLINE, PANA_ST_OFFLINE);
        
        AddStateTableEntry(PANA_ST_DISCOVER, PANA_RX_START_REQUEST,
                           PANA_ST_WAIT_PAA, m_acReceiveStartRequest);

        AddStateTableEntry(PANA_ST_DISCOVER, PANA_TM_DISCOVER_TIMEOUT,
                           PANA_ST_DISCOVER, m_acDiscoverTimeout);

        AddStateTableEntry(PANA_ST_DISCOVER, PANA_TM_DISCONNECT,
                           PANA_ST_OFFLINE, m_acRetryTimeout);

        AddWildcardStateTableEntry(PANA_ST_DISCOVER, PANA_ST_DISCOVER);
        
        AddStateTableEntry(PANA_ST_WAIT_PAA, PANA_RX_AUTH_REQUEST,
                           PANA_ST_WAIT_PAA, m_acReceiveAuthRequest);

        AddStateTableEntry(PANA_ST_WAIT_PAA, PANA_TM_DISCOVER_TIMEOUT,
                           PANA_ST_WAIT_PAA, m_acDiscoverTimeout);

        AddStateTableEntry(PANA_ST_WAIT_PAA, PANA_TM_STARTANSR_TIMEOUT,
                           PANA_ST_WAIT_PAA, m_acStartAnswerTimeout);

        AddStateTableEntry(PANA_ST_WAIT_PAA, PANA_TM_DISCONNECT,
                           PANA_ST_OFFLINE, m_acRetryTimeout);

        AddStateTableEntry(PANA_ST_WAIT_PAA, PANA_RX_BIND_FAILURE,
                           PANA_ST_OFFLINE, m_acReceiveBindRequest);

        AddStateTableEntry(PANA_ST_WAIT_PAA, PANA_RX_BIND_FIRST,
                           PANA_ST_SECOND_EAP, m_acReceiveBindRequest);

        AddStateTableEntry(PANA_ST_WAIT_PAA, PANA_RX_BIND_FINAL,
                           PANA_ST_OPEN, m_acReceiveBindRequest);

        AddStateTableEntry(PANA_ST_WAIT_PAA, PANA_RX_REAUTH_REQUEST,
                           PANA_ST_OPEN, m_acReceiveReAuthRequest);

        AddWildcardStateTableEntry(PANA_ST_WAIT_PAA, PANA_ST_WAIT_PAA);
        
        AddStateTableEntry(PANA_ST_SECOND_EAP, PANA_RX_AUTH_REQUEST,
                           PANA_ST_WAIT_PAA, m_acReceiveAuthRequest);

        AddWildcardStateTableEntry(PANA_ST_SECOND_EAP, PANA_ST_SECOND_EAP);
        
        AddStateTableEntry(PANA_ST_OPEN, PANA_RX_AUTH_REQUEST,
                           PANA_ST_WAIT_PAA, m_acReceiveEapReAuthRequest);

        AddStateTableEntry(PANA_ST_OPEN, PANA_RX_REAUTH_REQUEST,
                           PANA_ST_OPEN, m_acReceiveReAuthRequest);

        AddStateTableEntry(PANA_ST_OPEN, PANA_SIG_REAUTH_PAA,
                           PANA_ST_WAIT_REAUTH_ANSWER, m_acSendReAuthRequest);

        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_TM_SESSION_TIMEOUT,
                           PANA_ST_OFFLINE, m_acSessionTimeout);

        AddStateTableEntry(PANA_ST_OPEN, PANA_SIG_EAP_REAUTH,
                           PANA_ST_WAIT_PAA, m_acSendDiscover);

        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);

        AddWildcardStateTableEntry(PANA_ST_WAIT_REAUTH_ANSWER, PANA_ST_WAIT_REAUTH_ANSWER);
        
        AddStateTableEntry(PANA_ST_SESSION_TERMINATION, PANA_RX_TERM_ANSWER,
                           PANA_ST_OFFLINE, m_acReceiveTermAnswer);

        AddStateTableEntry(PANA_ST_SESSION_TERMINATION, PANA_TM_SESSION_TIMEOUT,
                           PANA_ST_OFFLINE, m_acSessionTimeout);

        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:
      PacSendDiscover             m_acSendDiscover;
      PacReceiveStartRequest      m_acReceiveStartRequest;
      PacReceiveBindRequest       m_acReceiveBindRequest;
      PacReceiveAuthRequest       m_acReceiveAuthRequest;
      PacReceiveEapReAuthRequest  m_acReceiveEapReAuthRequest;
      PacSendReAuthRequest        m_acSendReAuthRequest;
      PacReceiveReAuthRequest     m_acReceiveReAuthRequest;
      PacReceiveReAuthAnswer      m_acReceiveReAuthAnswer;
      PacSendTermRequest          m_acSendTermRequest;
      PacReceiveTermRequest       m_acReceiveTermRequest;
      PacReceiveTermAnswer        m_acReceiveTermAnswer;
      PacDiscoverTimeout          m_acDiscoverTimeout;
      PacStartAnswerTimeout       m_acStartAnswerTimeout;
      PacReAuthRequestTimeout     m_acReAuthRequestTimeout;
      PacSessionTimeout           m_acSessionTimeout;
      PacTermRequestTimeout       m_acTermRequestTimeout;
      PacRetryTimeout             m_acRetryTimeout;
      PacNullAction               m_acNullAction;
};

class PANA_EXPORT PANA_PacSession : public PANA_StateMachine<PANA_Client>
{
   public:
      PANA_PacSession(PANA_Node &n, PANA_ClientEventInterface &eif) :
         PANA_StateMachine<PANA_Client>(m_Client, m_StateTable, n, m_Udp),
         m_Client(m_TxChannel, m_Timer, eif),
         m_Node(n),
         m_Udp(n.Job(), "Pac UDP Channel") {
          
         AAA_SCSIAdapter1<PANA_PacSession, 
                           void(PANA_PacSession::*)(PANA_Message&),
                           PANA_Message&> 
                     msgHandler(*this, &PANA_PacSession::Receive);
         AAA_SCSIAdapter1<PANA_PacSession, 
                           void(PANA_PacSession::*)(int), 
                           int> 
                     errHandler(*this, &PANA_PacSession::Error);
         
         ACE_INET_Addr addr((u_short)PANA_CONFIG_GENERAL().listen_port_);
         m_Udp.Open(addr);
         m_Udp.RegisterHandler(msgHandler);
         m_Udp.RegisterHandler(errHandler);
         
         InitializeMsgMaps();
         PANA_StateMachine<PANA_Client>::Start(); 
      }
      virtual ~PANA_PacSession() { 
         PANA_StateMachine<PANA_Client>::Stop(); 
         FlushMsgMaps(); 
         m_Udp.Close();
         m_Udp.RemoveHandler();
      }
      virtual void Start() throw (AAA_Error) { 
         Notify(PANA_SIG_AUTH_USER);
      }
      virtual void SendEapResponse(AAAMessageBlock *response) {
         m_Client.SendEapMessage(response);
      }
      virtual void EapReAuthenticate() {
         Notify(PANA_SIG_EAP_REAUTH);
      }
      virtual void ReAuthenticate() {
         Notify(PANA_SIG_REAUTH_PAA);
      }
      virtual void Bind() {
         m_Client.SendBindAnswer();
      }
      virtual void Bind(diameter_octetstring_t &msk) {
         m_Client.MSK(msk);
         Bind();
      }
      PANA_CfgProviderInfo &PreferedISP() {
          return m_Client.PreferedISP();
      }
      PANA_CfgProviderInfo &PreferedNAP() {
          return m_Client.PreferedNAP();
      }
      virtual void Stop() { 
         m_Client.m_TerminationCause = PANA_TC_LOGOUT;
         Notify(PANA_SIG_TERMINATE_SESSION); 
      }
      virtual bool IsSessionResumption() {
          switch (state) {
              case PANA_ST_WAIT_PAA:
                  return (PANA_CONFIG_GENERAL().mobility_ > 0) ?
                      true : false;
              case PANA_ST_OPEN: return true;
              default: return false;
          }
      }
      virtual PANA_DeviceId *PeerDeviceId() {
          return m_Client.PeerDeviceId();
      }
      virtual std::string &CurrentInterface() {
          return PANA_CONFIG_GENERAL().iface_name_;
      }

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

      static PANA_ClientStateTable m_StateTable;
      PANA_Client m_Client;
      PANA_Node &m_Node;
      PANA_UdpChannel m_Udp;
};

#endif // __PANA_CLIENT_FSM_H__

---