hsms_socket.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_socket_class
#define hsms_socket_class

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <vector>
#include <string>
#include "async_reception.h"
#include "signals.h"
#include "shared_ptr.h"

const int MAXHOSTNAME = 200;
const int MAXCONNECTIONS = 5;

namespace freesecs
{
    class hsms_socket_t 
    {
    public:
        typedef std::vector<unsigned char>  data_t;
        typedef shared_ptr_t<data_t>   pdata_t;

        typedef enum
        {
            NOT_CONNECTED,
            CONNECTING,
            CONNECTED
        }cnx_state_et;

        signal_one_arg_t<cnx_state_et>  cnx_state_signal;
        signal_no_args_t                cnx_failed_signal;

        hsms_socket_t(const char *name, const int port);
        hsms_socket_t(const char *name, const char *host, int port);//active socket ctor
        virtual ~hsms_socket_t();

    public:
        int             connect         ();
        int             disconnect      ();
        int             send            (pdata_t);
        int             receive         (pdata_t);
        cnx_state_et    get_cnx_state   () const;

    protected:
        int         connect_tcp        ();
        virtual int disconnect_tcp     ();
        int         send_tcp           (pdata_t);
        virtual int recv_tcp           (pdata_t)=0;


    protected:
        int connect_to      ();
        int bind            ();
        int listen          ();
        int accept  ();

    protected:
        typedef enum
        {
            e_connect,
            e_connect_failed,
            e_connected,
            e_disconnect,
            e_send,
            e_recv
        }sock_cnx_ev_et;

        typedef struct
        {
            sock_cnx_ev_et  type;
            pdata_t         pdata;
        } sock_cnx_ev_t;

        int process (sock_cnx_ev_t);

    private:
        int z1      (sock_cnx_ev_t);
        int z2      (sock_cnx_ev_t);
        int z3      (sock_cnx_ev_t);
        int z1_0    (sock_cnx_ev_t);
        int z2_0    (sock_cnx_ev_t);
        int z3_0    (sock_cnx_ev_t);
        cnx_state_et    _cnx_state;
        static void     *tcp_cnx_thread(void *arg);

    protected:
        std::string _name;
        std::string _cnx_sm_name;
        std::string _remote_host;
        int         _port;
        int         _sock;
        sockaddr_in _addr;

    private:
        int create_socket();

    private:
        hsms_socket_t();
        hsms_socket_t(const hsms_socket_t&);
    };


    class hsms_socket_async_t : public hsms_socket_t
    {
    public:
        typedef enum
        {
            inactive,
            wtg_for_header,
            wtg_for_data,
        }state_t;

        signal_one_arg_t<pdata_t>     msg_signal;
        signal_no_args_t              data_partially_recvd;
        signal_no_args_t              recv_error;

    public:
        hsms_socket_async_t(const char *name, const int port);
        hsms_socket_async_t(const char *name, const char *host, const int port);
        virtual ~hsms_socket_async_t();

    protected:
        virtual int disconnect_tcp();
        virtual int recv_tcp(pdata_t);

        state_t get_state() const {return _state;}
    /*sm stuff-->*/
    private:
        typedef enum
        {
            e_i_init,
            e_i_deinit,
            e_i_data_received,
            e_i_recv_error
        }internal_event_t;

        bool x0(); 
        bool x1();
        bool x2();
        void z0();
        void z1();
        void z2();
        void z3();
        void z0_0();
        void z1_0();
        void z2_0(); 

        void process(internal_event_t);

        state_t _state;
    /*sm stuff<--*/
    private:
        pdata_t  _pmessage;
        size_t  _bytes_read;
        int     _rx_error;

    private:
        int data_rcvd_handler(const size_t&);
        int rcv_error_handler(const int&);

        shared_ptr_t<async_reception_t> _ar;

    private:
        friend class hsms_passive_cnx_t;
    };


    #ifdef USE_TIMED_SOCK
    class hsms_socket_timed_t : public hsms_socket_t
    {
    public:
        void set_non_blocking(const bool);

        int recv(data_t & data, int timeout_ms) const;

    //receive a certain number of bytes
    //wait for all data
        int recvn(data_t & data, size_t size, int timeout_ms) const;

    protected:
        int _recv(data_t & data, size_t size, bool wait_all, bool flash_unwanted,
                   int timeout) const;
       
    //if timeout_ms <= 0, timeout is reset
        static void _set_timer(int sock_fd, int timeout_ms);
    };
#endif 
}//namespace
#endif  

---