pana_client_fsm.cxx

Diameter协议栈

    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_FAILURE);
    AddStateTableEntry(PANA_ST_WAIT_EAP_RESULT_CLOSE, ev.Get(), 
                       PANA_ST_CLOSED, 
                       m_PacWaitEapResultCloseExitAction);

    /////////////////////////////////////////////////////////////////
    // EAP_INVALID_MSG         None();                     WAIT_PAA
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_INVALID_MSG);
    AddStateTableEntry(PANA_ST_WAIT_EAP_RESULT_CLOSE, ev.Get(), 
                       PANA_ST_WAIT_PAA);

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

    // --------------------------
    // State: WAIT_1ST_EAP_RESULT
    // --------------------------

    /////////////////////////////////////////////////////////////////
    // EAP_SUCCESS &&          PFEA.insert_avp("Key-Id");  WAIT_PAA
    // PFER.exist_avp          PFEA.S_flag=1;
    //  ("Key-Id")              PFEA.N_flag=PFER.N_flag;
    //                         PFEA.insert_avp("AUTH");
    //                         Tx:PFEA();
    //                         EAP_Restart();
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_SUCCESS);
    ev.AvpExist_KeyId();
    AddStateTableEntry(PANA_ST_WAIT_1ST_EAP_RESULT, ev.Get(), 
                       PANA_ST_WAIT_PAA, 
                       m_PacWait1stEapResultExitAction);

    /////////////////////////////////////////////////////////////////
    // (EAP_SUCCESS &&         if (key_available())        WAIT_PAA
    // !PFER.exist_avp           PFEA.insert_avp("AUTH");
    // ("Key-Id")) ||          PFEA.S_flag=1;
    // EAP_FAILURE             PFEA.N_flag=PFER.N_flag;
    //                         Tx:PFEA();
    //                         EAP_Restart();
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_SUCCESS);
    AddStateTableEntry(PANA_ST_WAIT_1ST_EAP_RESULT, ev.Get(), 
                       PANA_ST_WAIT_PAA, 
                       m_PacWait1stEapResultExitAction);
                       
    //    
    // ("Key-Id") ||
    // EAP_FAILURE
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_FAILURE);
    AddStateTableEntry(PANA_ST_WAIT_1ST_EAP_RESULT, ev.Get(), 
                       PANA_ST_WAIT_PAA, 
                       m_PacWait1stEapResultExitAction);

    /////////////////////////////////////////////////////////////////
    // EAP_INVALID_MSG         EAP_Restart();                WAIT_PAA
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_INVALID_MSG);
    AddStateTableEntry(PANA_ST_WAIT_1ST_EAP_RESULT, ev.Get(), 
                       PANA_ST_WAIT_PAA,
                       m_PacWait1stEapResultRestartExitAction);

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

    // --------------------------------
    // State: WAIT_1ST_EAP_RESULT_CLOSE
    // --------------------------------

    /////////////////////////////////////////////////////////////////
    // EAP_SUCCESS &&          PFEA.insert_avp("Key-Id");  CLOSED
    // PFER.exist_avp          PFEA.S_flag=0;
    // ("Key-Id")              PFEA.N_flag=0;
    //                         PFEA.insert_avp("AUTH");
    //                         Tx:PFEA();
    //                         Disconnect();
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_SUCCESS);
    ev.AvpExist_KeyId();
    AddStateTableEntry(PANA_ST_WAIT_1ST_EAP_RESULT_CLOSE, ev.Get(), 
                       PANA_ST_CLOSED, 
                       m_PacWait1stEapResultCloseExitAction);

    /////////////////////////////////////////////////////////////////
    // (EAP_SUCCESS &&         if (key_available())        CLOSED
    // !PFER.exist_avp           PFEA.insert_avp("AUTH");
    // ("Key-Id")) ||          PFEA.S_flag=0;
    // EAP_FAILURE             PFEA.N_flag=0;
    //                         Tx:PFEA();
    //                         Disconnect();
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_SUCCESS);
    AddStateTableEntry(PANA_ST_WAIT_1ST_EAP_RESULT_CLOSE, ev.Get(), 
                       PANA_ST_CLOSED, 
                       m_PacWait1stEapResultCloseExitAction);
                       
    //
    // ("Key-Id")) ||
    // EAP_FAILURE
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_FAILURE);
    AddStateTableEntry(PANA_ST_WAIT_1ST_EAP_RESULT_CLOSE, ev.Get(), 
                       PANA_ST_CLOSED, 
                       m_PacWait1stEapResultCloseExitAction);

    /////////////////////////////////////////////////////////////////
    // EAP_INVALID_MSG         None();                     WAIT_PAA
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_INVALID_MSG);
    AddStateTableEntry(PANA_ST_WAIT_1ST_EAP_RESULT_CLOSE, ev.Get(), 
                       PANA_ST_WAIT_PAA);

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

    // -----------
    // State: OPEN
    // -----------

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - (liveness test based initiated by PAA)- - - - - -
    // Rx:PPR                  if (key_available())       OPEN
    //                            PPA.insert_avp("AUTH");
    //                          Tx:PPA();
    //
    ev.Reset();
    ev.MsgType(PANA_EV_MTYPE_PPR);
    AddStateTableEntry(PANA_ST_OPEN, ev.Get(), 
                       PANA_ST_OPEN, 
                       m_PacOpenExitActionRxPPR);

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - (liveness test based initiated by PaC)- - - - - -
    // PANA_PING                if (key_available())       WAIT_PPA
    //                           PPR.insert_avp("AUTH");
    //                          Tx:PPR();
    //
    ev.Reset();
    ev.Event_App(PANA_EV_APP_PING);
    AddStateTableEntry(PANA_ST_OPEN, ev.Get(), 
                       PANA_ST_WAIT_PPA, 
                       m_PacOpenExitActionTxPPR);

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - - (re-authentication initiated by PaC)- - - - - -
    // REAUTH                  SEPARATE=Set|Unset;        WAIT_PRAA
    //                         1ST_EAP=Unset;            
    //                         PANA_SA_RESUMED=Unset;
    //                         if (key_available())
    //                           PRAR.insert_avp("AUTH");
    //                         Tx:PRAR();
    //                         RtxTimerStart();
    //                         SessionTimerStop();
    //
    ev.Reset();
    ev.Event_App(PANA_EV_APP_REAUTH);
    AddStateTableEntry(PANA_ST_OPEN, ev.Get(), 
                       PANA_ST_WAIT_PRAA, 
                       m_PacOpenExitActionTxPRAR);

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - - (re-authentication initiated by PAA)- - - - - -
    // Rx:PAR &&                SEPARATE=Set|Unset;        WAIT_EAP_MSG
    // !eap_piggyback()         1ST_EAP=Unset;
    //                          PANA_SA_RESUMED=Unset;
    //                          EAP_RespTimerStart();
    //                          TxEAP();
    //                          if (key_available())
    //                             PAN.insert_avp("AUTH");
    //                          PAN.S_flag=PAR.S_flag;
    //                          PAN.N_flag=PAR.N_flag;
    //                          Tx:PAN();
    //                          SessionTimerStop();
    //                          
    ev.Reset();
    ev.MsgType(PANA_EV_MTYPE_PAR);
    AddStateTableEntry(PANA_ST_OPEN, ev.Get(), 
                       PANA_ST_WAIT_EAP_MSG, 
                       m_PacOpenExitActionRxPAR);
                       
    /////////////////////////////////////////////////////////////////
    // Rx:PAR &&                SEPARATE=Set|Unset;        WAIT_EAP_MSG
    // eap_piggyback()          1ST_EAP=Unset;
    //                          PANA_SA_RESUMED=Unset;
    //                          EAP_RespTimerStart();
    //                          TxEAP();
    //                          SessionTimerStop();
    // 
    ev.Reset();
    ev.MsgType(PANA_EV_MTYPE_PAR);
    ev.EnableCfg_EapPiggyback();
    AddStateTableEntry(PANA_ST_OPEN, ev.Get(), 
                       PANA_ST_WAIT_EAP_MSG, 
                       m_PacOpenExitActionRxPAR);

    /////////////////////////////////////////////////////////////////
    // - - - - - - - -(Session termination initiated by PAA) - - - - - -
    // Rx:PTR                   if (key_available())       CLOSED
    //                          PTA.insert_avp("AUTH");
    //                            Tx:PTA();
    //                          Disconnect();
    //
    ev.Reset();
    ev.MsgType(PANA_EV_MTYPE_PTR);
    AddStateTableEntry(PANA_ST_OPEN, ev.Get(), 
                       PANA_ST_CLOSED, 
                       m_PacOpenExitActionRxPTR);

    /////////////////////////////////////////////////////////////////
    // - - - - - - - -(Session termination initiated by PaC) - - - - - -
    // TERMINATE                if (key_available())       SESS_TERM
    //                             PTR.insert_avp("AUTH");
    //                          Tx:PTR();
    //                          RtxTimerStart();
    //
    ev.Reset();
    ev.Event_App(PANA_EV_APP_TERMINATE);
    AddStateTableEntry(PANA_ST_OPEN, ev.Get(), 
                       PANA_ST_SESS_TERM, 
                       m_PacOpenExitActionTxPTR);

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - - - - - -(Address update) - - - - - - - - - - 
    // NOTIFY                   if (key_available())       WAIT_PUA
    //                            PUR.insert_avp("AUTH");
    //                          Tx:PUR();
    //                          RtxTimerStart();
    //
    ev.Reset();
    ev.Event_App(PANA_EV_APP_NOTIFICATION);
    AddStateTableEntry(PANA_ST_OPEN, ev.Get(), 
                       PANA_ST_WAIT_PUA, 
                       m_PacOpenExitActionTxPUR);

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - - - -(Notification update)- - - - - - - - - - 
    // Rx:PUR                   if (key_available())       OPEN
    //                            PUA.insert_avp("AUTH");
    //                          Tx:PUA();
    // 
    ev.Reset();
    ev.MsgType(PANA_EV_MTYPE_PUR);
    AddStateTableEntry(PANA_ST_OPEN, ev.Get(), 
                       PANA_ST_OPEN, 
                       m_PacOpenExitActionRxPUR);

    /////////////////////////////////////////////////////////////////
    //     SESS_TIMEOUT             Disconnect();              CLOSED
    //
    ev.Reset();
    ev.Do_SessTimeout();
    AddStateTableEntry(PANA_ST_OPEN, ev.Get(), 
                       PANA_ST_CLOSED, 
                       m_PacExitActionTimeout);

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - (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_OPEN, ev.Get(), 
                       PANA_ST_CLOSED, 
                       m_PacExitActionTxPEA);

    /////////////////////////////////////////////////////////////////
    // 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_OPEN, ev.Get(), 
                       PANA_ST_OPEN, 
                       m_PacExitActionTxPEA);

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

    // ----------------
    // State: WAIT_PRAA
    // ----------------

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - -(liveness test initiated by PAA) - - - - - - -
    // Rx:PRAA                  RtxTimerStop();            WAIT_PAA
    //
    ev.Reset();
    ev.MsgType(PANA_EV_MTYPE_PRAA);
    AddStateTableEntry(PANA_ST_WAIT_PRAA, ev.Get(), 
                       PANA_ST_WAIT_PAA, 
                       m_PacWaitPRAAExitActionRxPRAA);

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - - - (Reach maximum number of retransmission)- -
    // RTX_TIMEOUT &&           Retransmit();              (no change)