pana_paa_fsm.h

Diameter协议栈

/* 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                               */
/* [e-mail] 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 "od_utl_rbtree_dbase.h"
#include "pana_exports.h"
#include "pana_fsm.h"
#include "pana_paa.h"

class PANA_PaaEventVariable
{
    private:
        typedef union {
            struct {
               ACE_UINT32 m_Type_Msg             : 5;

               ACE_UINT32 m_Event_Eap            : 4;
               ACE_UINT32 m_Event_App            : 4;

               ACE_UINT32 m_Cfg_UseCookie        : 1;
               ACE_UINT32 m_Cfg_PiggyBack        : 1;

               ACE_UINT32 m_Flag_Separate        : 1;

               ACE_UINT32 m_Result_FirstEap      : 2;

               ACE_UINT32 m_Do_AbortOnFirstEap   : 1;
               ACE_UINT32 m_Do_Separate          : 1;
               ACE_UINT32 m_Do_RetreiveSA        : 1;
               ACE_UINT32 m_Do_Authorize         : 1;
               ACE_UINT32 m_Do_Ping              : 1;
               ACE_UINT32 m_Do_RetryTimeout      : 1;
               ACE_UINT32 m_Do_ReTransmission    : 1;
               ACE_UINT32 m_Do_EapRespTimeout    : 1;
               ACE_UINT32 m_Do_Mobility          : 1;
               ACE_UINT32 m_Do_FatalError        : 1;
               ACE_UINT32 m_Do_Missing_DeviceId  : 1;
               ACE_UINT32 m_Do_SessTimeout       : 1;

               ACE_UINT32 m_AvpExist_EapPayload  : 1;
               
               ACE_UINT32 m_Reserved             : 1;
            } i;
            ACE_UINT32 p;
        } EventParams;

    public:
        PANA_PaaEventVariable() {
            m_Event.p = 0;
        }
        void MsgType(PANA_MSG_TYPE type) {
            m_Event.i.m_Type_Msg = type;
        }
        void Event_Eap(PANA_EAP_EVENT event) {
            m_Event.i.m_Event_Eap = event;
        }
        void Event_App(PANA_APP_EVENT event) {
            m_Event.i.m_Event_App = event;
        }
        void EnableCfg_UseCookie(bool set = true) {
            m_Event.i.m_Cfg_UseCookie = set;
        }
        void EnableCfg_PiggyBack(bool set = true) {
            m_Event.i.m_Cfg_PiggyBack = set;
        }
        void EnableFlag_Separate(bool set = true) {
            m_Event.i.m_Flag_Separate = set;
        }
        void Result_FirstEap(PANA_EAP_RESULT event) {
            m_Event.i.m_Result_FirstEap = event;
        }
        void Do_AbortOnFirstEap(bool set = true) {
            m_Event.i.m_Do_AbortOnFirstEap = set;
        }
        void Do_Separate(bool set = true) {
            m_Event.i.m_Do_Separate = set;
        }
        void Do_RetreiveSA(bool set = true) {
            m_Event.i.m_Do_RetreiveSA = set;
        }
        void Do_Authorize(bool set = true) {
            m_Event.i.m_Do_Authorize = set;
        }
        void Do_Ping(bool set = true) {
            m_Event.i.m_Do_Ping = set;
        }
        void Do_RetryTimeout(bool set = true) {
            m_Event.i.m_Do_RetryTimeout = set;
        }
        void Do_ReTransmission(bool set = true) {
            m_Event.i.m_Do_ReTransmission = set;
        }
        void Do_EapRespTimeout(bool set = true) {
            m_Event.i.m_Do_EapRespTimeout = set;
        }
        void Do_Mobility(bool set = true) {
            m_Event.i.m_Do_Mobility = set;
        }
        void Do_FatalError(bool set = true) {
            m_Event.i.m_Do_FatalError = set;
        }
        void Do_MissingId(bool set = true) {
            m_Event.i.m_Do_Missing_DeviceId = set;
        }
        void Do_SessTimeout(bool set = true) {
            m_Event.i.m_Do_SessTimeout = set;
        }
        void AvpExist_EapPayload(bool set = true) {
            m_Event.i.m_AvpExist_EapPayload = set;
        }
        void Reset() {
            m_Event.p = 0;
        }
        ACE_UINT32 Get() {
            DumpEvent();
            return m_Event.p;
        }
        void DumpEvent() {
#if defined(PANA_DEBUG)
            ACE_DEBUG((LM_DEBUG, "Event: "));
            if (m_Event.i.m_Type_Msg)
                ACE_DEBUG((LM_DEBUG, "Msg[%d] ", m_Event.i.m_Type_Msg));
            if (m_Event.i.m_Event_App)
                ACE_DEBUG((LM_DEBUG, "App[%d] ", m_Event.i.m_Event_App));
            if (m_Event.i.m_Event_Eap)
                ACE_DEBUG((LM_DEBUG, "Eap[%d] ", m_Event.i.m_Event_Eap));
            if (m_Event.i.m_Cfg_UseCookie)
                ACE_DEBUG((LM_DEBUG, "CookieCfg "));
            if (m_Event.i.m_Cfg_PiggyBack)
                ACE_DEBUG((LM_DEBUG, "EapPiggy "));
            if (m_Event.i.m_Flag_Separate)
                ACE_DEBUG((LM_DEBUG, "S-flag "));
            if (m_Event.i.m_Result_FirstEap)
                ACE_DEBUG((LM_DEBUG, "1stEAP[%d] ", m_Event.i.m_Result_FirstEap));
            if (m_Event.i.m_Do_AbortOnFirstEap)
                ACE_DEBUG((LM_DEBUG, "Abort1stEap "));
            if (m_Event.i.m_Do_Separate)
                ACE_DEBUG((LM_DEBUG, "DoSep "));
            if (m_Event.i.m_Do_RetreiveSA)
                ACE_DEBUG((LM_DEBUG, "DoSA "));
            if (m_Event.i.m_Do_Authorize)
                ACE_DEBUG((LM_DEBUG, "DoAuth "));
            if (m_Event.i.m_Do_Ping)
                ACE_DEBUG((LM_DEBUG, "DoPing "));
            if (m_Event.i.m_Do_RetryTimeout)
                ACE_DEBUG((LM_DEBUG, "RetryTout "));
            if (m_Event.i.m_Do_ReTransmission)
                ACE_DEBUG((LM_DEBUG, "Retran "));
            if (m_Event.i.m_Do_EapRespTimeout)
                ACE_DEBUG((LM_DEBUG, "EapRespTout "));
            if (m_Event.i.m_Do_Mobility)
                ACE_DEBUG((LM_DEBUG, "DoMobility "));
            if (m_Event.i.m_Do_FatalError)
                ACE_DEBUG((LM_DEBUG, "Fatal "));
            if (m_Event.i.m_Do_Missing_DeviceId)
                ACE_DEBUG((LM_DEBUG, "MissingDevId "));
            if (m_Event.i.m_Do_SessTimeout)
                ACE_DEBUG((LM_DEBUG, "SessTout "));
            if (m_Event.i.m_AvpExist_EapPayload)
                ACE_DEBUG((LM_DEBUG, "EapPayload "));
            ACE_DEBUG((LM_DEBUG, "\n"));
#endif
        }

    private:
        EventParams m_Event;
};

class PANA_EXPORT PANA_PaaStateTable : public AAA_StateTable<PANA_Paa>
{
   public:
      class PaaExitActionPaaEapRestart : public AAA_Action<PANA_Paa> {
          virtual void operator()(PANA_Paa &p) { 
              p.NotifyEapRestart(); 
          }
      };
      class PaaExitActionTxPSR : public AAA_Action<PANA_Paa> {
          virtual void operator()(PANA_Paa &p) { 
              p.TxPSR();
          }
      };
      class PaaExitActionRxPSA : public AAA_Action<PANA_Paa> {
          virtual void operator()(PANA_Paa &p) { 
              p.RxPSA();
          }
      };
      class PaaExitActionEapTimeout : public AAA_Action<PANA_Paa> {
          virtual void operator()(PANA_Paa &p) { 
              p.NotifyEapTimeout();
          }
      };
      class PaaExitActionTxPAR : public AAA_Action<PANA_Paa> {
          virtual void operator()(PANA_Paa &p) { 
              p.TxPAR();
          }
      };
      class PaaExitActionTxPBREapSuccess : public AAA_Action<PANA_Paa> {
          virtual void operator()(PANA_Paa &p) { 
              p.TxPBR(PANA_SUCCESS, PANA_Paa::EAP_SUCCESS);
          }
      };
      class PaaExitActionTxPBREapSuccessFail : public AAA_Action<PANA_Paa> {
          virtual void operator()(PANA_Paa &p) { 
              p.TxPBR(PANA_AUTHENTICATION_REJECTED, 
                      PANA_Paa::EAP_SUCCESS);
          }
      };
      class PaaExitActionTxPBREapFail : public AAA_Action<PANA_Paa> {
          virtual void operator()(PANA_Paa &p) { 
              p.TxPBR(PANA_AUTHENTICATION_REJECTED, 
                      PANA_Paa::EAP_FAILURE);
          }
      };
      class PaaExitActionTxPBREapFailSuccess : public AAA_Action<PANA_Paa> {
          virtual void operator()(PANA_Paa &p) { 
              p.TxPBR(PANA_SUCCESS, 
                      PANA_Paa::EAP_FAILURE);
          }
      };
      class PaaExitActionTxPBREapTimeout : public AAA_Action<PANA_Paa> {
          virtual void operator()(PANA_Paa &p) { 
              p.TxPBR(PANA_AUTHENTICATION_REJECTED, 
                      PANA_Paa::EAP_TIMEOUT);
          }
      };
      class PaaExitActionTxPBREapTimeoutSuccess : public AAA_Action<PANA_Paa> {
          virtual void operator()(PANA_Paa &p) { 
              p.TxPBR(PANA_SUCCESS, PANA_Paa::EAP_TIMEOUT);
          }
      };
      class PaaExitActionTxPFEREapSuccess : public AAA_Action<PANA_Paa> {
          virtual void operator()(PANA_Paa &p) { 
              p.TxPFER(PANA_SUCCESS, PANA_Paa::EAP_SUCCESS);
          }
      };
      class PaaExitActionTxPFEREapFail : public AAA_Action<PANA_Paa> {
          virtual void operator()(PANA_Paa &p) { 
              p.TxPFER(PANA_AUTHENTICATION_REJECTED,
                       PANA_Paa::EAP_FAILURE);
          }
      };
      class PaaExitActionTxPFEREapTimeout : public AAA_Action<PANA_Paa> {
          virtual void operator()(PANA_Paa &p) {