hsms_statemachine.h

/*   
 *   (c) Copyright 2008 Philipp Skadorov (philipp_s@users.sourceforge.net)
 *
 *   This file is part of FREESECS.
 *
 *   FREESECS is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   FREESECS 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 General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with FREESECS, see COPYING.
 *   If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef _HSMS_SM_H
#define _HSMS_SM_H

#include <string>
#include "shared_ptr.h"
#include "hsms_socket.h"
#include "event_pump.h"
#include "timer.h"

namespace freesecs
{
    typedef struct
    {
        std::string     name;
        uint32_t        port;
        uint16_t        t6;
        uint16_t        t7;
        uint16_t        t8;
        uint16_t        linktest;
        uint16_t        session_id;
    }hsms_passive_params_t;

    typedef struct
    {
        std::string     name;
        std::string     ip;
        uint32_t        port;
        uint16_t        t5;
        uint16_t        t6;
        uint16_t        t8;
        uint16_t        linktest;
        uint16_t        session_id;
    }hsms_active_params_t;

    typedef enum
    {
        e_tcpip_established = 0,//e0
        e_hsms_msg_rcvd,        //e1
        e_tcpip_error,          //e2
        e_cnx_term_req,         //e3
        e_cnx_start_req,        //e4
        e_datamsg_send_req,     //e5
        e_linktest_timeout,     //e6
        e_t5_timeout,           //e7-active
        e_t6_timeout,           //e8
        e_t7_timeout,           //e9
        e_t8_timeout,           //e10
        e_data_received,        //e11
        e_tcpip_broken,         //e12
        e_tcpip_cnx_failure     //e13
    }
    hsms_ev_et;

    typedef enum
    {
        e_hsms_not_connected,
        e_hsms_not_selected,
        e_hsms_selected,
        e_hsms_not_connected_t5 //used to handle t5 timeout in active mode
    }
    hsms_state_et;

    typedef struct
    {
        hsms_ev_et type;
        hsms_socket_t::pdata_t pdata;
    }
    hsms_event_t;

    class hsms_sm_t : public simple_event_pump_t<hsms_event_t>
    {
    public:
        typedef hsms_socket_t::data_t data_t;
        typedef hsms_socket_t::pdata_t pdata_t;

    public:
        hsms_sm_t();
        virtual ~hsms_sm_t();

        signal_one_arg_t<hsms_state_et> state_signal;
#if 0

        signal_one_arg_t<pdata_t>       rx_signal;
#endif

        hsms_state_et get_state() const;

    protected:
        virtual int open_tcp()                     = 0;
        virtual int close_tcp()                    = 0;
        virtual int send_over_tcp(pdata_t)         = 0;
        virtual int recv_from_tcp(pdata_t)         = 0;
        virtual void hsms_msg_received(pdata_t)    = 0;

    protected:
        void close_cnx();
        virtual int process(const hsms_event_t&)   = 0;

    protected:
        hsms_state_et _state;

    /* timer stuff */
    protected:
        ms_timer_t t5;
        ms_timer_t t6;
        ms_timer_t t7;
        ms_timer_t t8;
        ms_timer_t linktest_timer;

        int t5_handler();
        int t6_handler();
        int t7_handler();
        int t8_handler();
        int linktest_handler();

    protected:
        unsigned short _tid;
    };

    class passive_hsms_sm_t : public virtual hsms_sm_t
    {
    public:
        passive_hsms_sm_t(hsms_passive_params_t);
        virtual ~passive_hsms_sm_t();

    protected:
        virtual int process(const hsms_event_t&);

    protected:
        bool x0(pdata_t);
        bool x1(pdata_t);
        bool x2(pdata_t);
        bool x3(pdata_t);
        bool x4(pdata_t);
        bool x5(pdata_t);
        bool x6(pdata_t);

        //z
        int z1(pdata_t);
        int z2(pdata_t);
        int z3(pdata_t);
        int z4(pdata_t);
        int z5(pdata_t);
        int z6(pdata_t);
        int z7(pdata_t);
        int z9(pdata_t);
        int z10(pdata_t);
        int z11(pdata_t);
        int z12(pdata_t);
        int z0_0(hsms_event_t);
        int z1_0(pdata_t);
        int z2_0(pdata_t);

    private:
        hsms_passive_params_t _params;
    };

    class active_hsms_sm_t : public virtual hsms_sm_t
    {
    public:
        active_hsms_sm_t(hsms_active_params_t);
        virtual ~active_hsms_sm_t();

    protected:
        virtual int process(const hsms_event_t &);

    protected:
        bool x0(pdata_t);
        bool x1(pdata_t);
        bool x2(pdata_t);
        bool x3(pdata_t);
        bool x4(pdata_t);
        bool x5(pdata_t);
        bool x6(pdata_t);
        int z1(pdata_t);
        int z3(pdata_t);
        int z4(pdata_t);
        int z5(pdata_t);
        int z6(pdata_t);
        int z7(pdata_t);
        int z8(pdata_t);
        int z9(pdata_t);
        int z10(pdata_t);
        int z11(pdata_t);
        int z12(pdata_t);
        int z13(pdata_t);
        int z14(pdata_t);
        int z0_0(pdata_t);
        int z1_0(pdata_t);
        int z2_0(pdata_t);

    private:
        hsms_active_params_t _params;
    };
}//namespace
#endif //_HSMS_SM_H

---