async_reception.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 _ASYNC_RECEPTION_H
#define _ASYNC_RECEPTION_H

#include <pthread.h>
#include <list>
#include "signals.h"

#define MAX_FSM_NAME 48

namespace freesecs
{
    class async_reception_t
    {
    public:
        typedef enum
        {
            IDLE = 0,
            WTG_FOR_DATA,
            RECEIVED
        }state_t;

        async_reception_t(int fd, const char *name);
        virtual ~async_reception_t();

        void start_recv(void *buf, size_t count);

        void stop_recv();

        state_t get_state();

        size_t  get_bytes_read();

        signal_one_arg_t<size_t>    data_partially_recvd_signal;
        signal_one_arg_t<size_t>    data_recvd_signal;
        signal_one_arg_t<int>       recv_error_signal;

    private:
        typedef union
        {
            struct
            {
                void    *buf;/*beginning of user data pool*/
                size_t  count;/*length of data to receive*/
            }e0;
            struct
            {
                int     rx_error;
                ssize_t  bytes_read;
            }e1;
        }event_data_t;

        void process(int e, event_data_t data);

        void stop_read();

        void z1_0(event_data_t);
        void z2_0(event_data_t);
        void z1(event_data_t);
        void z2(event_data_t);
        void z3(event_data_t);
        bool x1();
        bool x2();

        bool check_fd_process(const fd_set*);

    private:
        char _name[MAX_FSM_NAME];

    private:
        int             _fd;
        void           *_buf;
        size_t          _bytes_to_read;
        size_t          _bytes_read;
        int             _rx_error;
        state_t         _state;

    private:
        static int                              _subscr_count;
        static int                              _update_fd[2];
        typedef std::list<async_reception_t*>   thisv_t;
        static thisv_t                          _thisv;
        static pthread_mutex_t                  _thisv_mx;
        
        static pthread_t                        _sigthread_id;
        static void                            *signalthread(void *arg);

    private:
        static void set_need_update_fdset();
        static void set_need_exit();
        static bool get_need_update_fdset();
        static void update_fdset(int *fdn, fd_set *fds, thisv_t *thisv, bool clear_cache);


    /*no default ctors, no copies*/
    private:
        async_reception_t();
        async_reception_t(const async_reception_t&);
        async_reception_t& operator = (const async_reception_t&);
    };
}//namespace
#endif/*_ASYNC_RECEPTION_H*/

---