pana_client_fsm.cxx

Diameter协议栈

    // RTX_COUNTER>=
    // RTX_MAX_NUM
    //
    ev.Reset();
    ev.Do_RetryTimeout();
    AddStateTableEntry(PANA_ST_WAIT_PAA, 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_WAIT_PAA, 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_WAIT_PAA, ev.Get(), 
                       PANA_ST_WAIT_PAA, 
                       m_PacExitActionTxPEA);

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

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

    /////////////////////////////////////////////////////////////////
    // - - - - - - - - - - - - - - (Return PSA)- - - - - - - - - - - -
    // EAP_RESPONSE &&          EAP_RespTimerStop()        WAIT_PAA
    // eap_piggyback()          PAN.insert_avp
    //                          ("EAP-Payload");
    //                          if (key_available())
    //                            PAN.insert_avp("AUTH");
    //                          PAN.S_flag=PAR.S_flag;
    //                          PAN.N_flag=PAR.N_flag;
    //                          Tx:PAN();
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_RESPONSE);
    ev.EnableCfg_EapPiggyback();
    AddStateTableEntry(PANA_ST_WAIT_EAP_MSG, ev.Get(), 
                       PANA_ST_WAIT_PAA, 
                       m_PacWaitEapMsgExitActionTxPAN);

    /////////////////////////////////////////////////////////////////
    // EAP_RESPONSE &&          EAP_RespTimerStop()        WAIT_PAA
    // !eap_piggyback()         PAR.insert_avp
    //                          ("EAP-Payload");
    //                          if (key_available())
    //                            PAR.insert_avp("AUTH");
    //                          PAR.S_flag=PAN.S_flag;
    //                          PAR.N_flag=PAN.N_flag;
    //                          Tx:PAR();
    //                          RtxTimerStart();
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_RESPONSE);
    AddStateTableEntry(PANA_ST_WAIT_EAP_MSG, ev.Get(), 
                       PANA_ST_WAIT_PAA, 
                       m_PacWaitEapMsgExitActionTxPAR);

    /////////////////////////////////////////////////////////////////
    // EAP_RESP_TIMEOUT       if (key_available())       WAIT_EAP_MSG
    //                          PAN.insert_avp("AUTH");
    //                        PAN.S_flag=PAR.S_flag;
    //                        PAN.N_flag=PAR.N_flag;
    //                        Tx:PAN();
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_RESP_TIMEOUT);
    AddStateTableEntry(PANA_ST_WAIT_EAP_MSG, ev.Get(), 
                       PANA_ST_WAIT_EAP_MSG, 
                       m_PacWaitEapMsgExitActionTxPANTout);

    /////////////////////////////////////////////////////////////////
    // EAP_INVALID_MSG ||       None();                    WAIT_PAA
    // EAP_SUCCESS ||
    // EAP_FAILURE
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_INVALID_MSG);
    AddStateTableEntry(PANA_ST_WAIT_EAP_MSG, ev.Get(), 
                       PANA_ST_WAIT_PAA);
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_SUCCESS);
    AddStateTableEntry(PANA_ST_WAIT_EAP_MSG, ev.Get(), 
                       PANA_ST_WAIT_PAA);
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_FAILURE);
    AddStateTableEntry(PANA_ST_WAIT_EAP_MSG, ev.Get(), 
                       PANA_ST_WAIT_PAA);


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

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

    // ----------------------
    // State: WAIT_EAP_RESULT
    // ----------------------


    /////////////////////////////////////////////////////////////////
    // - - - - - - - - - - - - - (EAP Result) - - - - - - - - - - - -
    // EAP_SUCCESS &&          PBA.insert_avp("AUTH");      OPEN
    // PBR.exist_avp           PBA.insert_avp("Key-Id");
    // ("Key-Id") &&           if (CARRY_DEVICE_ID)
    // ppac_available() &&       PBA.insert_avp
    // (!PBR.exist_avp           ("Device-Id");
    // ("Protection-           PBA.insert_avp("PPAC");
    //  Capability") ||        Tx:PBA();
    // (PBR.exist_avp          Authorize();
    // ("Protection-           SessionTimerStart();
    //  Capability") &&
    // pcap_supported()))
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_SUCCESS);
    ev.AvpExist_KeyId();
    AddStateTableEntry(PANA_ST_WAIT_EAP_RESULT, ev.Get(), 
                       PANA_ST_OPEN, 
                       m_PacWaitEapResultExitActionEapOpen);

    /////////////////////////////////////////////////////////////////
    // EAP_SUCCESS &&          if (key_available())        OPEN
    // !PBR.exist_avp            PBA.insert_avp("AUTH");
    // ("Key-Id") &&           if (CARRY_DEVICE_ID)
    // ppac_available() &&       PBA.insert_avp
    // (!PBR.exist_avp           ("Device-Id");
    // ("Protection-           PBA.insert_avp("PPAC");
    //   Capability") ||       Tx:PBA();
    // (PBR.exist_avp          Authorize();
    // ("Protection-           SessionTimerStart();
    //   Capability") &&
    // pcap_supported()))
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_SUCCESS);
    AddStateTableEntry(PANA_ST_WAIT_EAP_RESULT, ev.Get(), 
                       PANA_ST_OPEN, 
                       m_PacWaitEapResultExitActionEapOpen);

    /////////////////////////////////////////////////////////////////
    // EAP_SUCCESS &&          if (key_available())        WAIT_PEA
    // !ppac_available()         PER.insert_avp("AUTH");
    //                         PER.RESULT_CODE=
    //                           PANA_PPAC_CAPABILITY_
    //                             UNSUPPORTED
    //                         Tx:PER();
    //                         RtxTimerStart();
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_SUCCESS);
    ev.NotSupported_Ppac();
    AddStateTableEntry(PANA_ST_WAIT_EAP_RESULT, ev.Get(), 
                       PANA_ST_WAIT_PEA, 
                       m_PacWaitEapResultExitActionTxPERPpac);

    /////////////////////////////////////////////////////////////////
    // EAP_SUCCESS &&          if (key_available())        WAIT_PEA
    // (PBR.exist_avp            PER.insert_avp("AUTH");
    // ("Protection-           PER.RESULT_CODE=
    //   Capability") &&         PANA_PROTECTION_
    // !pcap_supported())          CAPABILITY_UNSUPPORTED
    //                         Tx:PER();
    //                         RtxTimerStart();
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_SUCCESS);
    ev.NotSupported_Pcap();
    AddStateTableEntry(PANA_ST_WAIT_EAP_RESULT, ev.Get(), 
                       PANA_ST_WAIT_PEA, 
                       m_PacWaitEapResultExitActionTxPERPcap);

    /////////////////////////////////////////////////////////////////
    // EAP_FAILURE &&          if (key_available())        OPEN
    // (SEPARATE==Set) &&        PBA.insert_avp("AUTH");
    // ppac_available() &&     if (CARRY_DEVICE_ID)
    // (!PBR.exist_avp           PBA.insert_avp
    // ("Protection-             ("Device-Id");
    //  Capability") ||        PBA.insert_avp("PPAC");
    // (PBR.exist_avp          Tx:PBA();
    // ("Protection-           Authorize();
    //   Capability") &&       SessionTimerStart();
    // pcap_supported()))
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_FAILURE);
    ev.Do_Separate();
    AddStateTableEntry(PANA_ST_WAIT_EAP_RESULT, ev.Get(), 
                       PANA_ST_OPEN, 
                       m_PacWaitEapResultExitActionEapOpen);

    /////////////////////////////////////////////////////////////////
    // EAP_FAILURE &&          if (key_available())        WAIT_PEA
    // (SEPARATE==Set) &&        PER.insert_avp("AUTH");
    // !ppac_available()       PER.RESULT_CODE=
    //                           PANA_PPAC_CAPABILITY_
    //                             UNSUPPORTED
    //                         Tx:PER();
    //                         RtxTimerStart();
    // 
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_FAILURE);
    ev.NotSupported_Ppac();
    ev.Do_Separate();
    AddStateTableEntry(PANA_ST_WAIT_EAP_RESULT, ev.Get(), 
                       PANA_ST_WAIT_PEA, 
                       m_PacWaitEapResultExitActionTxPERPpac);

    /////////////////////////////////////////////////////////////////
    // EAP_FAILURE &&          if (key_available())        WAIT_PEA
    // (SEPARATE==Set) &&        PER.insert_avp("AUTH");
    // (PBR.exist_avp          PER.RESULT_CODE=
    // ("Protection-             PANA_PROTECTION_
    //   Capability") &&           CAPABILITY_UNSUPPORTED
    // !pcap_supported())      Tx:PER();
    //                         RtxTimerStart();
    // 
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_FAILURE);
    ev.NotSupported_Pcap();
    ev.Do_Separate();
    AddStateTableEntry(PANA_ST_WAIT_EAP_RESULT, ev.Get(), 
                       PANA_ST_WAIT_PEA, 
                       m_PacWaitEapResultExitActionTxPERPcap);

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

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

    // ----------------------------
    // State: WAIT_EAP_RESULT_CLOSE
    // ----------------------------

    /////////////////////////////////////////////////////////////////
    // EAP_SUCCESS &&          PBA.insert_avp("AUTH");      CLOSED
    // PBR.exist_avp           PBA.insert_avp("Key-Id");
    // ("Key-Id")              Tx:PBA();
    //                         Disconnect();
    //
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_SUCCESS);
    ev.AvpExist_KeyId();
    AddStateTableEntry(PANA_ST_WAIT_EAP_RESULT_CLOSE, ev.Get(), 
                       PANA_ST_CLOSED, 
                       m_PacWaitEapResultCloseExitAction);

    /////////////////////////////////////////////////////////////////
    // EAP_SUCCESS &&          if (key_available())        CLOSED
    // !PBR.exist_avp            PBA.insert_avp("AUTH");
    // ("Key-Id")              Tx:PBA();
    //                         Disconnect();
    // 
    ev.Reset();
    ev.Event_Eap(PANA_EV_EAP_SUCCESS);
    AddStateTableEntry(PANA_ST_WAIT_EAP_RESULT_CLOSE, ev.Get(), 
                       PANA_ST_CLOSED, 
                       m_PacWaitEapResultCloseExitAction);

    /////////////////////////////////////////////////////////////////
    // EAP_FAILURE             Tx:PBA();                   CLOSED
    //                         Disconnect();
    //