hsms_statemachine.cpp

/*   
 *   (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/>.
 */
#include "hsms_cnx.h"
#include "hsms_statemachine.h"
#include "log.h"

#define HSMS_SM_LOG_LEVEL 10

using namespace freesecs;

inline void
check_init_pdata(freesecs::hsms_sm_t::pdata_t& pdata)
{
    if(NULL == pdata.get())
    {
        pdata = new hsms_sm_t::pdata_t::value_type;
    }
}

hsms_sm_t::hsms_sm_t()
:_state(e_hsms_not_connected), _tid(0)
{
    t5.add_handler(this, &hsms_sm_t::t5_handler);
    t6.add_handler(this, &hsms_sm_t::t6_handler);
    t7.add_handler(this, &hsms_sm_t::t7_handler);
    t8.add_handler(this, &hsms_sm_t::t8_handler);
    linktest_timer.add_handler(this, &hsms_sm_t::linktest_handler);
}

hsms_sm_t::~hsms_sm_t()
{
    t5.stop();
    t6.stop();
    t7.stop();
    t8.stop();
    linktest_timer.stop();
}

hsms_state_et 
hsms_sm_t::get_state() const
{
    return _state;
}


int 
hsms_sm_t::t5_handler()
{
    TRACE_DEBUG(HSMS_SM_LOG_LEVEL, "HSMS SM: T5 timeout");
    hsms_event_t ev = {e_t5_timeout,};

    *this << ev;

    return 0;
}

int 
hsms_sm_t::t6_handler()
{
    TRACE_DEBUG(HSMS_SM_LOG_LEVEL, "HSMS SM: T6 timeout");
    hsms_event_t ev = {e_t6_timeout,};

    *this << ev;

    return 0;
}

int 
hsms_sm_t::t7_handler()
{
    TRACE_DEBUG(HSMS_SM_LOG_LEVEL, "HSMS SM: T7 timeout");
    hsms_event_t ev = {e_t7_timeout,};

    *this << ev;

    return 0;
}

int 
hsms_sm_t::t8_handler()
{
    TRACE_DEBUG(HSMS_SM_LOG_LEVEL, "HSMS SM: T8 timeout");
    hsms_event_t ev = {e_t8_timeout,};

    *this << ev;

    return 0;
}

int 
hsms_sm_t::linktest_handler()
{
    TRACE_DEBUG(HSMS_SM_LOG_LEVEL, "HSMS SM: linktest sending timeout");
    hsms_event_t ev = {e_linktest_timeout,};

    *this << ev;

    return 0;
}

void
hsms_sm_t::close_cnx()
{
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "HSMS SM", __func__, "");
    t5.stop();
    t6.stop();
    t7.stop();
    t8.stop();
    linktest_timer.stop();
    
    close_tcp();
}


passive_hsms_sm_t::passive_hsms_sm_t(hsms_passive_params_t params)
:_params(params)
{
    _params.t6          *= 1000;
    _params.t7          *= 1000;
    _params.t8          *= 1000;
    _params.linktest    *= 1000;
}

passive_hsms_sm_t::~passive_hsms_sm_t()
{}

int
passive_hsms_sm_t::process(const hsms_event_t &e)
{
    int err = 0;
    hsms_state_et old_y0 = _state;
    
    TRACE_FSM_BEGIN(HSMS_SM_LOG_LEVEL, "PSM", _state, e.type);

    switch (_state)
    {
        case e_hsms_not_connected:
            if(e_tcpip_established == e.type)
            {
                _state = e_hsms_not_selected;
            }
            else
            {
                goto passive_sm_wrong_ev;
            }
        break;
        case e_hsms_not_selected:
            if(e_hsms_msg_rcvd == e.type)
            {
                err = z11(e.pdata);
                if(!x0(e.pdata))
                {
                    err = z1(e.pdata);
                    _state = e_hsms_not_connected;
                }
                else if(!x1(e.pdata))
                {
                    _state = e_hsms_not_connected;
                }
                else
                {
                    _state = e_hsms_selected;
                    err = z2(e.pdata);
                    err = z12(e.pdata);
                }
            }
            else if(e_t7_timeout == e.type ||
                    e_t8_timeout == e.type)
            {
                _state = e_hsms_not_connected;
            }
            else if(e_tcpip_error == e.type)
            {
                _state = e_hsms_not_connected;
            }
            else if(e_data_received == e.type)
            {
                err = z10(e.pdata);
            }
            else
            {
                goto passive_sm_wrong_ev;
            }
        break;
        case e_hsms_selected:
            if(e_hsms_msg_rcvd == e.type)
            {
                err = z11(e.pdata);
                if(!x2(e.pdata))
                {
                    err = z4(e.pdata);
                    _state = e_hsms_not_connected;
                }
                else if(x3(e.pdata))
                {
                    _state = e_hsms_not_connected;
                }
                else
                {
                    if(x4(e.pdata))
                    {
                        err = z3(e.pdata);
                    }
                    else if(x5(e.pdata))
                    {
                        err = z7(e.pdata);
                    }
                    else if(x6(e.pdata))
                    {
                        err = z6(e.pdata);
                    }
                    err = z12(e.pdata);
                }
            }
            else if(e_linktest_timeout == e.type)
            {
                err = z5(e.pdata);
            }
            else if(e_datamsg_send_req == e.type)
            {
                err = z9(e.pdata);
            }
            else if(e_cnx_term_req == e.type)
            {
                err = z4(e.pdata);
                err = z11(e.pdata);
                _state = e_hsms_not_connected;
            }
            else if(e_tcpip_error == e.type)
            {
                err = z4(e.pdata);
                err = z11(e.pdata);
                _state = e_hsms_not_connected;
            }
            else if(e_t6_timeout == e.type)
            {
                err = z4(e.pdata);
                err = z11(e.pdata);
                _state = e_hsms_not_connected;
            }
            else
            {
                goto passive_sm_wrong_ev;
            }
        break;
        default:
            err = ENOSYS;
        break;
    };
    if (err || old_y0 == _state)
    {
        goto passive_a0_end;
    }

    TRACE_FSM_TRANS(HSMS_SM_LOG_LEVEL, "PSM", old_y0, _state);

    switch (_state)
    {
        case e_hsms_not_connected:
            err = z0_0(e);
        break;
        case e_hsms_not_selected:
            err = z1_0(e.pdata);
        break;
        case e_hsms_selected:
            err = z2_0(e.pdata);
        break;
        default:
            err = ENOSYS;
        break;
    };
passive_a0_end:
    TRACE_FSM_END(HSMS_SM_LOG_LEVEL, "PSM", _state, e.type);
    return err;

passive_sm_wrong_ev:
    TRACE_FSM_ERROR(HSMS_SM_LOG_LEVEL, "PSM", "event %d not handled in state %d", e.type, _state);
    TRACE_FSM_END(HSMS_SM_LOG_LEVEL, "PSM", _state, e.type);
    return EPERM;
};

/*TODO: implement upper bl query for readiness*/
bool
passive_hsms_sm_t::x0(pdata_t d)//System is ready to accept hsms cnx
{
    bool result = true;

    return result;
}
bool
passive_hsms_sm_t::x1(pdata_t d)//Msg received is Select.req
{
    select_req<data_t> sel_req;
    bool valid = sel_req.valid(*d);
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, ": %d",valid);
    return valid;
}
bool
passive_hsms_sm_t::x2(pdata_t d)//Msg is a valid hsms-msg
{
    hsms_msg_base<data_t> msg;
    bool valid = msg.valid(*d);
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, ": %d", valid);
    return valid;
}
bool
passive_hsms_sm_t::x3(pdata_t d)//Msg received is Separate.req
{
    separate_req<data_t> sep_req;
    bool valid = sep_req.valid(*d);
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, ": %d", valid);
    return valid;
}
bool
passive_hsms_sm_t::x4(pdata_t d)//Msg received is Linktest.req
{
    linktest_req<data_t> lnktest_req;
    bool valid = lnktest_req.valid(*d);
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, ": %d", valid);
    return valid;
}
bool
passive_hsms_sm_t::x5(pdata_t d)//Msg received is Linktest.rsp
{
    linktest_rsp<data_t> lnktest_rsp;
    bool valid = lnktest_rsp.valid(*d);
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, ": %d", valid);
    return valid;
}
bool
passive_hsms_sm_t::x6(pdata_t d)//Msg received is data-msg
{
    data_msg<data_t> data_msg;
    bool valid = data_msg.valid(*d);
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, ": %d", valid);
    return valid;
}

int
passive_hsms_sm_t::z1(pdata_t pdata)//send select.req with nonzero status
{
    select_req<data_t> req;
    select_rsp<data_t> rsp;
    
    check_init_pdata(pdata);

    rsp.compose(*pdata,
           req.transaction_id(*pdata), 
           select_rsp<data_t>::e_not_ready);

    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, "sending select response...");

    return send_over_tcp(pdata);
}
int
passive_hsms_sm_t::z2(pdata_t pdata)//send select.rsp with zero-status
{
    
    select_req<data_t> req;
    select_rsp<data_t> rsp;
    
    check_init_pdata(pdata);
    
    rsp.compose(*pdata, 
           req.transaction_id(*pdata), 
           select_rsp<data_t>::e_established);

    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, "sending select response...");

    return send_over_tcp(pdata);
}
int
passive_hsms_sm_t::z3(pdata_t pdata)//send linktest.rsp
{
    linktest_req<data_t> req;
    linktest_rsp<data_t> rsp;
    
    check_init_pdata(pdata);
    rsp.compose(*pdata, req.transaction_id(*pdata));

    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, "sending linktest response...");

    return send_over_tcp(pdata);
}
int
passive_hsms_sm_t::z4(pdata_t pdata)//send separate.req
{
    separate_req<data_t> req;

    check_init_pdata(pdata);
    req.compose(*pdata, _tid++);

    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, "sending separate request...");

    return send_over_tcp(pdata);
}
int
passive_hsms_sm_t::z5(pdata_t pdata)//send linktest.req + start t6 timer
{
    linktest_req<data_t> req;

    check_init_pdata(pdata);
    req.compose(*pdata, _tid++);

    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, "sending linktest request...");

    return send_over_tcp(pdata);
}
int
passive_hsms_sm_t::z6(pdata_t d)//process data msg
{
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, "start processing message...");
    hsms_msg_received(d);

    return 0;
}
int
passive_hsms_sm_t::z7(pdata_t)//1. stop t6 timer 2. start linktest sending timer
{
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, "");
    t6.stop();

    if(_params.linktest)
    {
        linktest_timer.start(_params.linktest);
    }
    return 0;
}
int
passive_hsms_sm_t::z9(pdata_t pdata)//send msg over tcp/ip cnx
{    
    data_msg<data_t> data_msg;

    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, "");

    if(false == data_msg.valid(*pdata))
    {
        return EINVAL;
    }

    return send_over_tcp(pdata);
}
int
passive_hsms_sm_t::z10(pdata_t)//Restart T8 timeout
{
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, "restarting T8 timeout...");
    t8.stop();
    t8.start(_params.t8);
    return 0;
}
int
passive_hsms_sm_t::z11(pdata_t)//Stop T8 timeout
{
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, "stopping T8 timeout...");
    t8.stop();
    return 0;
}
int
passive_hsms_sm_t::z12(pdata_t pdata)//Start hsms message reception
{
    check_init_pdata(pdata);

    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, "started async message reception");

    recv_from_tcp(pdata);
    return 0;
}

int
passive_hsms_sm_t::z0_0(hsms_event_t e)
{
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, "");
    close_cnx();
    state_signal(_state);

    if(e_cnx_term_req != e.type)
    {
        return open_tcp();
    }
    return 0;
}

int
passive_hsms_sm_t::z1_0(pdata_t pdata)//start t7 timeout
{
    z12(pdata);
    t7.start(_params.t7);
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, "started T7 timer");

    state_signal(_state);
    return 0;
}
int
passive_hsms_sm_t::z2_0(pdata_t)//start linktest sending timeout
{
    t7.stop();

    if(_params.linktest)
    {
        TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__, "started linktest sending timeout");
        linktest_timer.start(_params.linktest);
    }
    state_signal(_state);
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "PSM", __func__,"");
    return 0;
}



active_hsms_sm_t::active_hsms_sm_t(hsms_active_params_t params)
:_params(params)
{
    _params.t5          *= 1000;
    _params.t6          *= 1000;
    _params.t8          *= 1000;
    _params.linktest    *= 1000;
}

active_hsms_sm_t::~active_hsms_sm_t(){}

/*int active_hsms_sm_t::_sm_func (const hsms_event_t& e)*/
int
active_hsms_sm_t::process(const hsms_event_t &e)
{
    int err = 0;
    hsms_state_et old_y0 = this->_state;

    TRACE_FSM_BEGIN(HSMS_SM_LOG_LEVEL, "ASM", _state, e.type);

    switch (_state)
    {
        case e_hsms_not_connected:
            /*if(e_cnx_start_req == e.type)
            {
                err = z8(e.pdata);
                err = z14(e.pdata);
            }*/
            if(e_t5_timeout == e.type)
            {
                err = z8(e.pdata);
            }
            else if(e_tcpip_established == e.type)
            {
                _state = e_hsms_not_selected;
                err = z13(e.pdata);
            }
            else if(e_tcpip_cnx_failure == e.type)
            {
                err = z14(e.pdata);
            }
            else
            {
                goto active_sm_wrong_ev;
            }
        break;
        case e_hsms_not_selected:
            if(e_hsms_msg_rcvd == e.type)
            {
                err = z11(e.pdata);
                if(!x0(e.pdata))
                {
                    this->_state = e_hsms_not_connected;
                }
                else if(!x1(e.pdata))
                {
                    this->_state = e_hsms_not_connected;
                }
                else if(!x2(e.pdata))
                {
                    this->_state = e_hsms_not_connected;
                }
                else
                {
                    this->_state = e_hsms_selected;
                }
            }
            else if(e_t6_timeout == e.type)
            {
                _state = e_hsms_not_connected;
            }
            else if(e_t8_timeout == e.type)
            {
                _state = e_hsms_not_connected;
            }
            else if(e_tcpip_error == e.type)
            {
                _state = e_hsms_not_connected;
            }
            else if(e_data_received == e.type)
            {
                err = z10(e.pdata);
            }
            else
            {
                goto active_sm_wrong_ev;
            }
        break;
        case e_hsms_selected:
            if(e_hsms_msg_rcvd == e.type)
            {
                err = z11(e.pdata);
                if(!x2(e.pdata))
                {
                    err = z4(e.pdata);
                    _state = e_hsms_not_connected;
                }
                else if(x3(e.pdata))
                {
                    _state = e_hsms_not_connected;
                }
                else
                {
                    if(x4(e.pdata))
                    {
                        err = z3(e.pdata);
                    }
                    else if(x5(e.pdata))
                    {
                        err = z7(e.pdata);
                    }
                    else if(x6(e.pdata))
                    {
                        err = z6(e.pdata);
                    }
                    err = z12(e.pdata);
                }
            }
            else if(e_linktest_timeout == e.type)
            {
                err = z5(e.pdata);
            }
            else if(e_datamsg_send_req == e.type)
            {
                err = z9(e.pdata);
            }
            else if(e_cnx_term_req == e.type)
            {
                err = z4(e.pdata);
                err = z11(e.pdata);
                _state = e_hsms_not_connected;
            }
            else if(e_tcpip_error == e.type)
            {
                err = z4(e.pdata);
                err = z11(e.pdata);
                _state = e_hsms_not_connected;
            }
            else if(e_t6_timeout == e.type)
            {
                err = z4(e.pdata);
                err = z11(e.pdata);
                _state = e_hsms_not_connected;
            }
            else
            {
                goto active_sm_wrong_ev;
            }
        break;
        default:
            err = ENOSYS;
        break;
    };
    if (err || old_y0 == _state)
    {
        goto active_sm_end;
    }

    TRACE_FSM_TRANS(HSMS_SM_LOG_LEVEL, "ASM", old_y0, _state);

    switch (_state)
    {
        case e_hsms_not_connected:
            err = z0_0(e.pdata);
        break;
        case e_hsms_not_selected:
            err = z1_0(e.pdata);
        break;
        case e_hsms_selected:
            err = z2_0(e.pdata);
        break;
        default:
            err = ENOSYS;
        break;
    };
active_sm_end:
    TRACE_FSM_END(HSMS_SM_LOG_LEVEL, "ASM", _state, e.type);
    return err;

active_sm_wrong_ev:
    TRACE_FSM_ERROR(HSMS_SM_LOG_LEVEL, "ASM", "event %d not handled in state %d", e.type, _state);
    TRACE_FSM_END(HSMS_SM_LOG_LEVEL, "ASM", _state, e.type);
    return EPERM;

};

bool 
active_hsms_sm_t::x0(pdata_t d)//select.rsp has sero status
{
    select_rsp<data_t> select_rsp;
    bool valid = select_rsp.valid(*d) && 0 == select_rsp.status(*d);
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "%d", valid);
    return valid;
}
bool 
active_hsms_sm_t::x1(pdata_t d)//msg received is select.rsp
{
    select_rsp<data_t> select_rsp;
    bool valid = select_rsp.valid(*d);
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "%d", valid);
    return valid;
}
bool 
active_hsms_sm_t::x2(pdata_t d)//msg received is a valid hsms msg
{
    hsms_msg_base<data_t> msg;
    bool valid = msg.valid(*d);
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "%d", valid);
    return valid;
}
bool 
active_hsms_sm_t::x3(pdata_t d)//msg received is separate.req
{
    separate_req<data_t> separate_req;
    bool valid = separate_req.valid(*d);
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "%d", valid);
    return valid;
}
bool 
active_hsms_sm_t::x4(pdata_t d)//msg received is linktest.req
{
    linktest_req<data_t> linktest_req;
    bool valid = linktest_req.valid(*d);
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "%d", valid);
    return valid;
}
bool 
active_hsms_sm_t::x5(pdata_t d)//msg received is linktest.rsp
{
    linktest_rsp<data_t> linktest_rsp;
    bool valid = linktest_rsp.valid(*d);
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "%d", valid);
    return valid;
}
bool 
active_hsms_sm_t::x6(pdata_t d)//msg received is data-msg
{
    data_msg<data_t> data_msg;
    bool valid = data_msg.valid(*d);
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "%d", valid);
    return valid;
}

int 
active_hsms_sm_t::z3(pdata_t pdata)//Send Linktest.rsp
{
    linktest_req<data_t> req;
    linktest_rsp<data_t> rsp;

    check_init_pdata(pdata);

    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "sending linktest response...");
    rsp.compose(*pdata, req.transaction_id(*pdata));
    return send_over_tcp(pdata);
}
int
active_hsms_sm_t::z4(pdata_t pdata)//send separate.req
{
    separate_req<data_t> req;

    check_init_pdata(pdata);

    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "sending separate request...");
    req.compose(*pdata, _tid++);
    return send_over_tcp(pdata);
}
int 
active_hsms_sm_t::z5(pdata_t pdata)//1. Send Linktest.req 2. Start T6 timer
{
    int error;

    linktest_req<data_t> req;

    check_init_pdata(pdata);

    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "sending linktest request...");

    req.compose(*pdata, _tid++);
    
    error = send_over_tcp(pdata);

    t6.start(_params.t6);

    return error;
}
int 
active_hsms_sm_t::z6(pdata_t pdata)//Process data msg
{
    int err = 0;
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "start processing message...");
    hsms_msg_received(pdata);
    return err;
}
int 
active_hsms_sm_t::z7(pdata_t)//1. Stop T6 timer 2. Start linktest sending timer
{
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "");

    t6.stop();

    if(_params.linktest)
    {
        linktest_timer.start(_params.linktest);
    }
    return 0;
}
int 
active_hsms_sm_t::z8(pdata_t)//Start tcp/ip connect in active mode
{
    state_signal(e_hsms_not_connected_t5);

    return open_tcp();
}
int 
active_hsms_sm_t::z9(pdata_t pdata)//Send msg over hsms cnx
{
    data_msg<data_t> data_msg;

    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "");

    if(false == data_msg.valid(*pdata))
    {
        return EINVAL;
    }

    return send_over_tcp(pdata);
}
int
active_hsms_sm_t::z10(pdata_t)//Restart T8 timeout
{
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "restarting T8 timeout...");
    t8.stop();
    t8.start(_params.t8);
    return 0;
}
int
active_hsms_sm_t::z11(pdata_t)//Stop T8 timeout
{
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "stopping T8 timeout...");
    t8.stop();
    return 0;
}
int
active_hsms_sm_t::z12(pdata_t pdata)//restart active connection
{
    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "started async message reception");
    return recv_from_tcp(pdata);
}
int
active_hsms_sm_t::z13(pdata_t)
{
    t5.stop();
    return 0;
}
int
active_hsms_sm_t::z14(pdata_t)
{
    t5.start(_params.t5);
    return 0;
}
int 
active_hsms_sm_t::z0_0(pdata_t)
{
    close_cnx();
    //t5.start(_params.t5);
    //fire t5 immediately to init tcp cnx
    //later on, t5 will take the value from
    //config params
    t5.start(1);
    state_signal(_state);
    return 0;
}
int 
active_hsms_sm_t::z1_0(pdata_t pdata)//1. Send Select.req 2. Start T6 timeout
{
    select_req<data_t> req;

    check_init_pdata(pdata);

    recv_from_tcp(pdata);

    req.compose(*pdata, _tid++);
    int err = send_over_tcp(pdata);
    
    if(err)
    {
        TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "send select.req: %s (%d)", strerror(err), err);
    }
    
    t6.start(_params.t6);


    state_signal(_state);

    return err;
}
int 
active_hsms_sm_t::z2_0(pdata_t pdata)//1. Cancel T6 timeout 2. Start linktest sending timeout 3. Start message reception
{
    int err;

    TRACE_FSM_ACTION(HSMS_SM_LOG_LEVEL, "ASM", __func__, "");

    t6.stop();

    if(_params.linktest)
    {
        linktest_timer.start(_params.linktest);
    }
    
    err = recv_from_tcp(pdata);

    state_signal(_state);

    return err;
}

---