hsms_cnx.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 <iostream>
#include <pthread.h>
#include "hsms_socket.h"
#include "hsms_statemachine.h"
#include "hsms_cnx.h"

using namespace freesecs;

#define HSMS_CNX_LOG_LEVEL 10

#define ASSERT_RETURN_VALUE(a, e, v) if((e) != (a)){return v;} 
hsms_cnx_t::hsms_cnx_t (const char *name, 
                        uint16_t session_id, 
                        const char *remote_ip, 
                        unsigned remote_port)
:_socket(name, remote_ip, remote_port)
,_name(name)
,_session_id(session_id)
{
    _socket.msg_signal.add_handler(this, &freesecs::hsms_cnx_t::sock_msg_rcv_handler);
    _socket.cnx_state_signal.add_handler(this, &freesecs::hsms_cnx_t::sock_cnx_state_change_handler);
    _socket.cnx_failed_signal.add_handler(this, &freesecs::hsms_cnx_t::sock_cnx_failed_handler);

    _socket.data_partially_recvd.add_handler(this, &freesecs::hsms_cnx_t::sock_data_partially_recvd_handler);
    _socket.recv_error.add_handler(this, &freesecs::hsms_cnx_t::sock_recv_error_handler);
}

hsms_cnx_t::hsms_cnx_t (const char *name, 
                        uint16_t session_id, 
                        unsigned local_port)
:_socket(name, local_port)
,_name(name)
,_session_id(session_id)
{
    _socket.msg_signal.add_handler(this, &freesecs::hsms_cnx_t::sock_msg_rcv_handler);
    _socket.cnx_state_signal.add_handler(this, &freesecs::hsms_cnx_t::sock_cnx_state_change_handler);
    _socket.cnx_failed_signal.add_handler(this, &freesecs::hsms_cnx_t::sock_cnx_failed_handler);

    _socket.data_partially_recvd.add_handler(this, &freesecs::hsms_cnx_t::sock_data_partially_recvd_handler);
    _socket.recv_error.add_handler(this, &freesecs::hsms_cnx_t::sock_recv_error_handler);
}


hsms_cnx_t::~hsms_cnx_t ()
{
}

const char *
hsms_cnx_t::name() const
{
    return _name.c_str();
}

uint16_t 
hsms_cnx_t::session_id() const
{
    return _session_id;
}

int freesecs::hsms_cnx_t::start()
{
    return _socket.connect();
}


int
hsms_cnx_t::stop ()
{
    TRACE_DEBUG(HSMS_CNX_LOG_LEVEL, "stopping %s...", _name.c_str());
    hsms_event_t ev = {e_cnx_term_req,};
    *this << ev;
    return 0;
}

int
hsms_cnx_t::send (pdata_t pdata)
{
    data_msg<data_t> msg;

    if((HSMS_LEN_BYTES_LEN + HSMS_HDR_LEN) < pdata->size())
    {
        msg.set_session_id(*pdata, _session_id);
    }

    hsms_event_t ev = {e_datamsg_send_req, pdata};
    return process_event(ev);
}

int 
hsms_cnx_t::sock_cnx_state_change_handler(const hsms_socket_t::cnx_state_et& state)
{
    hsms_event_t ev;

    switch(state)
    {
        case hsms_socket_t::NOT_CONNECTED:
#if 0
            //hack to avoid re-entrance
            if(e_hsms_not_connected != get_state())
            {
                ev.type = e_tcpip_broken;
                *this << ev;
            }
#endif
        break;
        case hsms_socket_t::CONNECTING:
        break;
        case hsms_socket_t::CONNECTED:
            ev.type = e_tcpip_established;
            *this << ev;
        break;
        default:
        break;
    }
    return 0;
}

int
hsms_cnx_t::sock_cnx_failed_handler()
{
    hsms_event_t ev = {e_tcpip_cnx_failure,};
    *this << ev;
    return 0;
}

int 
hsms_cnx_t::sock_msg_rcv_handler(const pdata_t& pdata)
{
    hsms_event_t ev = {e_hsms_msg_rcvd, pdata};
    *this << ev;

    return 0;
}

int
hsms_cnx_t::sock_data_partially_recvd_handler()
{
    hsms_event_t ev = {e_data_received,};
    *this << ev;
    return 0;
}

int 
hsms_cnx_t::sock_recv_error_handler()
{
    hsms_event_t ev = {e_tcpip_error,};
    *this << ev;
    return 0;
}

int 
hsms_cnx_t::open_tcp()
{
    return _socket.connect();
}

int 
hsms_cnx_t::close_tcp()
{
    return _socket.disconnect();
}

int 
hsms_cnx_t::send_over_tcp(hsms_socket_t::pdata_t pd)
{
    return _socket.send(pd);
}

int 
hsms_cnx_t::recv_from_tcp(hsms_socket_t::pdata_t pd)
{
    return _socket.receive(pd);
}

void 
hsms_cnx_t::hsms_msg_received(hsms_socket_t::pdata_t pd)
{
    rx_signal(pd);
}

hsms_passive_cnx_t::hsms_passive_cnx_t(const hsms_passive_params_t &params)
:hsms_cnx_t(params.name.c_str(), params.session_id, params.port)
,passive_hsms_sm_t(params)
{
}

hsms_passive_cnx_t::~hsms_passive_cnx_t()
{
}

hsms_active_cnx_t::hsms_active_cnx_t(const hsms_active_params_t &params)
:hsms_cnx_t(params.name.c_str(), params.session_id, params.ip.c_str(), params.port)
,active_hsms_sm_t(params)
{
}

hsms_active_cnx_t::~hsms_active_cnx_t()
{
}

---