pana_paa_fsm.cxx

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

#include "pana_paa_fsm.h"

PANA_PaaStateTable PANA_PaaSession::m_StateTable;
typedef PANA_SessionRxStateFilter<PANA_Paa, PANA_PaaSession>
            PANA_ServerRxStateFilter;

PANA_PaaStateTable::PANA_PaaStateTable() 
{        
    PANA_PaaEventVariable ev;

    // ------------------------------
    // State: OFFLINE (Initial State)
    // ------------------------------

    /////////////////////////////////////////////////////////////////
    // ------------------------+--------------------------+------------
    // - - - - - - - - - - - - - (Stateful discovery)- - - - - - - - -
    // (Rx:PDI ||               EAP_Restart();             WAIT_EAP_MSG_
    //  PAC_FOUND) &&                                      IN_DISC
    //  USE_COOKIE==Unset &&
    //  PIGGYBACK==Set
    // 
    ev.Event_App(PANA_EV_APP_PAC_FOUND);
    ev.EnableCfg_PiggyBack();
    AddStateTableEntry(PANA_ST_OFFLINE, ev.Get(), 
                       PANA_ST_WAIT_EAP_MSG_IN_DISC, 
                       m_PaaExitActionPaaEapRestart);

    /////////////////////////////////////////////////////////////////
    // ------------------------+--------------------------+------------
    // - - - - - - - - - - - - - (Stateful discovery)- - - - - - - - -
    // (Rx:PDI ||               if (SEPARATE==Set)         STATEFUL_DISC
    //  PAC_FOUND) &&             PSR.S_flag=1;
    //  USE_COOKIE==Unset &&    if (CARRY_NAP_INFO==Set)
    //  PIGGYBACK==Unset          PSR.insert_avp
    //                             ("NAP-Information");
    //                          if (CARRY_ISP_INFO==Set)
    //                            PSR.insert_avp
    //                             ("ISP-Information");
    //                          if (CARRY_PPAC==Set)
    //                            PSR.insert_avp
    //                             ("Post-PANA-Address-
    //                               Configuration");
    //                          Tx:PSR();
    //                          RtxTimerStart();
    //
    ev.Reset();
    ev.Event_App(PANA_EV_APP_PAC_FOUND);
    AddStateTableEntry(PANA_ST_OFFLINE, ev.Get(), 
                       PANA_ST_STATEFUL_DISC, 
                       m_PaaExitActionTxPSR);

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    // - - - - - - - (PSA processing without mobility support) - - - -
    // Rx:PSA &&                if (SEPARATE==Set &&       WAIT_EAP_MSG
    // USE_COOKIE==Set &&           PSA.S_flag==0)
    // (!PSA.exist_avp            SEPARATE=Unset;
    // ("Session-Id") ||        EAP_Restart();
    // MOBILITY==Unset ||       if (SEPARATE==Set)
    // (MOBILITY==Set &&          NAP_AUTH=Set|Unset
    // !retrieve_pana_sa
    //  (PSA.SESSION_ID)))
    ev.Reset();
    ev.MsgType(PANA_EV_MTYPE_PSA);
    ev.EnableCfg_UseCookie();
    AddStateTableEntry(PANA_ST_OFFLINE, ev.Get(), 
                       PANA_ST_WAIT_EAP_MSG, 
                       m_PaaExitActionRxPSA);

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    // - - - - - - - - (PSA processing with mobility support)- - - - -
    // Rx:PSA &&                PBR.insert_avp("AUTH");     WAIT_SUCC_PBA
    // USE_COOKIE==Set &&       PBR.insert_avp("Key-Id");
    // PSA.exist_avp            if (CARRY_DEVICE_ID
    // ("Session-Id") &&           ==Set)
    // MOBILITY==Set &&           PBR.insert_avp
    // retrieve_pana_sa            ("Device-Id");   
    // (PSA.SESSION_ID)         if (PROTECTION_CAP==Set)      
    //                             PBR.insert_avp
    //                              ("Protection-Cap.");
    //                          Tx:PBR();
    //                          RtxTimerStart();
    ev.Reset();
    ev.MsgType(PANA_EV_MTYPE_PSA);
    ev.Do_Mobility();
    ev.EnableCfg_UseCookie();
    AddStateTableEntry(PANA_ST_OFFLINE, ev.Get(), 
                       PANA_ST_WAIT_SUCC_PBA, 
                       m_PaaExitActionRxPSA);

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - - - (Catch all processing)- -
    //
#if !defined(PANA_DEBUG)
    AddWildcardStateTableEntry(PANA_ST_OFFLINE, 
                               PANA_ST_OFFLINE);
#endif                            

    // ---------------------------
    // State: WAIT_EAP_MSG_IN_DISC
    // ---------------------------

    /////////////////////////////////////////////////////////////////
    // Exit Condition           Exit Action                Exist State
    // ------------------------+--------------------------+------------
    // - - - - - - - - - - - (Send PSR with EAP-Request) - - - - - - -
    // EAP_REQUEST            PSR.insert_avp             STATEFUL_DISC
    //                         ("EAP-Payload");
    //                        if (CARRY_NAP_INFO==Set)
    //                          PSR.insert_avp
    //                          ("NAP-Information");
    //                        if (CARRY_ISP_INFO==Set)
    //                          PSR.insert_avp
    //                          ("ISP-Information");
    //                        if (CARRY_PPAC==Set)
    //                          PSR.insert_avp
    //                          ("Post-PANA-Address-
    //                            Configuration");
    //                        Tx:PSR();
    //                        RtxTimerStart();
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_REQUEST);
    AddStateTableEntry(PANA_ST_WAIT_EAP_MSG_IN_DISC, ev.Get(), 
                       PANA_ST_STATEFUL_DISC, 
                       m_PaaExitActionTxPSR);

    /////////////////////////////////////////////////////////////////
    // EAP_TIMEOUT              None();                    OFFLINE
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_TIMEOUT);
    AddStateTableEntry(PANA_ST_WAIT_EAP_MSG_IN_DISC, ev.Get(), 
                       PANA_ST_WAIT_EAP_MSG_IN_DISC);
    
    /////////////////////////////////////////////////////////////////
    // - - - - - - - - - - (Catch all processing)- -
    //
#if !defined(PANA_DEBUG)
    AddWildcardStateTableEntry(PANA_ST_WAIT_EAP_MSG_IN_DISC, 
                               PANA_ST_WAIT_EAP_MSG_IN_DISC);
#endif                               

    // --------------------
    // State: STATEFUL_DISC
    // --------------------

    /////////////////////////////////////////////////////////////////
    // Exit Condition           Action                     Next-State
    // ------------------------+--------------------------+------------
    // - - - - - - - - - - - - - (Stateful discovery)- - - - - - - - -
    // Rx:PSA                   if (SEPARATE==Set &&       WAIT_EAP_MSG
    //                          PSA.S_flag==0)
    //                             SEPARATE=Unset;
    //                          if PSA.Exist("EAP-Payload")
    //                             TxEAP();
    //                          else {
    //                             if (SEPARATE==Set) 
    //                                 NAP_AUTH=Set|Unset
    //                             EAP_Restart();
    //                          }
    //                          RtxTimerStop();
    //
    ev.Reset();
    ev.MsgType(PANA_EV_MTYPE_PSA);
    AddStateTableEntry(PANA_ST_STATEFUL_DISC, ev.Get(), 
                       PANA_ST_WAIT_EAP_MSG, 
                       m_PaaExitActionRxPSA);

    /////////////////////////////////////////////////////////////////
    // EAP_TIMEOUT              if (key_available())       WAIT_PEA
    //                            PER.insert_avp("AUTH");
    //                          Tx:PER();
    //                          RtxTimerStart();
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_TIMEOUT);
    AddStateTableEntry(PANA_ST_STATEFUL_DISC, ev.Get(), 
                       PANA_ST_WAIT_PEA, 
                       m_PaaExitActionTxPER);

    /////////////////////////////////////////////////////////////////
    // RTX_TIMEOUT &&           Disconnect();              CLOSED
    // RTX_COUNTER>=
    // RTX_MAX_NUM
    //
    ev.Reset();
    ev.Do_RetryTimeout();
    AddStateTableEntry(PANA_ST_STATEFUL_DISC, ev.Get(), 
                       PANA_ST_CLOSED, 
                       m_PaaExitActionTimeout);

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - - - (Reach maximum number of retransmission)- -
    // RTX_TIMEOUT &&           Retransmit();              (no change)
    // RTX_COUNTER<
    // RTX_MAX_NUM
    //
    ev.Reset();
    ev.Do_ReTransmission();
    AddStateTableEntry(PANA_ST_STATEFUL_DISC, ev.Get(), 
                       PANA_ST_STATEFUL_DISC, 
                       m_PaaExitActionRetransmission);

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - - - (PANA-Error-Message-Processing)- -
    // Rx:PER &&                PEA.insert_avp("AUTH");     CLOSED
    // fatal                    Tx:PEA();
    // (PER.RESULT_CODE) &&     Disconnect();
    // PER.exist_avp("AUTH") &&
    // key_available()
    //
    ev.Reset();
    ev.MsgType(PANA_EV_MTYPE_PER);
    ev.Do_FatalError(); // fatal(PER.RESULT_CODE) &&
                        // PER.exist_avp("AUTH") &&
                        // key_available()
    AddStateTableEntry(PANA_ST_STATEFUL_DISC, ev.Get(), 
                       PANA_ST_CLOSED, 
                       m_PaaExitActionTxPEA);

    /////////////////////////////////////////////////////////////////
    // Rx:PER &&                Tx:PEA();                  (no change)
    // !fatal
    // (PER.RESULT_CODE) ||
    // !PER.exist_avp("AUTH") ||
    // !key_available()
    //
    ev.Reset();
    ev.MsgType(PANA_EV_MTYPE_PER);
    AddStateTableEntry(PANA_ST_STATEFUL_DISC, ev.Get(), 
                       PANA_ST_STATEFUL_DISC, 
                       m_PaaExitActionTxPEA);

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - - - (Catch all processing)- -
    //
#if !defined(PANA_DEBUG)
    AddWildcardStateTableEntry(PANA_ST_STATEFUL_DISC, 
                               PANA_ST_STATEFUL_DISC);
#endif

    // -------------------
    // State: WAIT_EAP_MSG
    // -------------------

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - - - - -(Receiving EAP-Request)- - - - - - - - -
    // EAP_REQUEST            if (key_available())       WAIT_PAN_OR_PAR
    //                          PAR.insert_avp("AUTH");
    //                        if (SEPARATE==Set) {
    //                          PAR.S_flag=1;
    //                          if (NAP_AUTH==Set)
    //                            PAR.N_flag=1;
    //                        }
    //                        Tx:PAR();
    //                        RtxTimerStart();
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_REQUEST);
    AddStateTableEntry(PANA_ST_WAIT_EAP_MSG, ev.Get(), 
                       PANA_ST_WAIT_PAN_OR_PAR, 
                       m_PaaExitActionTxPAR);

    /////////////////////////////////////////////////////////////////
    // - - - - - -(Receiving EAP-Success/Failure single EAP)- - - - -
    // EAP_FAILURE &&           PBR.insert_avp            WAIT_FAIL_PBA
    // 1ST_EAP==Unset &&        ("EAP-Payload");
    // SEPARATE==Unset          if (key_available())
    //                           PBR.insert_avp("AUTH");
    //                          Tx:PBR();
    //                          RtxTimerStart();
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_FAILURE);
    ev.Result_FirstEap(PANA_EAP_RESULT_UNSET);
    AddStateTableEntry(PANA_ST_WAIT_EAP_MSG, ev.Get(), 
                       PANA_ST_WAIT_FAIL_PBA, 
                       m_PaaExitActionTxPBREapFail);

    /////////////////////////////////////////////////////////////////