sockstreambuf.h

/*
*  psocksxx - A C++ wrapper for POSIX sockets
*  Copyright (C) 2013 Uditha Atukorala
*
*  This software library is free software; you can redistribute it and/or modify
*  it under the terms of the GNU Lesser General Public License as published by
*  the Free Software Foundation; either version 3 of the License, or
*  (at your option) any later version.
*
*  This software library 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 Lesser General Public License for more details.
*
*  You should have received a copy of the GNU Lesser General Public License
*  along with this software library. If not, see <http://www.gnu.org/licenses/>.
*
*/

#ifndef PSOCKSXX_SOCKSTREAMBUF_H
#define PSOCKSXX_SOCKSTREAMBUF_H

#include <psocksxx/socktimeoutexception.h>
#include <psocksxx/sockaddr.h>

#include <streambuf>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

#ifndef SOCKSTREAMBUF_SIZE
#define SOCKSTREAMBUF_SIZE 1024
#endif

#ifndef SOCKSTREAMBUF_PUTBACK_SIZE
#define SOCKSTREAMBUF_PUTBACK_SIZE 8
#endif


namespace psocksxx {

    class sockstreambuf : public std::streambuf {
    public:

        typedef int socket_t;

        enum eof_t {
            eof = -1       
        };

        enum socket_domain_t {
            pf_local   = PF_LOCAL,        
            pf_inet    = PF_INET,         
            pf_route   = PF_ROUTE,        
            pf_key     = PF_KEY,          
            pf_inet6   = PF_INET6         
        };

        enum socket_type_t {
            sock_stream     = SOCK_STREAM,
            sock_dgram      = SOCK_DGRAM,
            sock_raw        = SOCK_RAW,
            sock_rdm        = SOCK_RDM,
            sock_seqpacket  = SOCK_SEQPACKET
        };

        enum socket_protocol_t {
            proto_unspec    = 0,               
            ipproto_ip      = IPPROTO_IP,      
            ipproto_ipv6    = IPPROTO_IPV6,    
            ipproto_icmp    = IPPROTO_ICMP,    
            ipproto_raw     = IPPROTO_RAW,     
            ipproto_tcp     = IPPROTO_TCP,     
            ipproto_udp     = IPPROTO_UDP      
        };


        sockstreambuf() throw();          
        virtual ~sockstreambuf();         

        sockstreambuf( socket_t socket ) throw();

        const socket_t & socket() const throw();

        void open( socket_domain_t domain, socket_type_t type, socket_protocol_t proto = proto_unspec ) throw( sockexception );

        void close() throw();

        virtual int flush() throw( socktimeoutexception );


        void connect( const sockaddr * dest_addr, unsigned int timeout = 0 ) throw( sockexception, socktimeoutexception );

        void connect( const sockaddr * dest_addr, timeval * timeout ) throw( sockexception, socktimeoutexception );

        void bind( const sockaddr * bind_addr, bool reuse_addr = false ) throw( sockexception );

        void listen( int backlog = SOMAXCONN ) throw( sockexception );

        socket_t accept() throw( sockexception );

        const timeval * timeout( time_t sec, suseconds_t usec ) throw();

        void * clear_timeout() throw();

        bool timedout() const throw();


    protected:

        void init_buffers() throw();

        void cleanup_buffers() throw();

        virtual int sync() throw();

        virtual int overflow( int c = eof ) throw( socktimeoutexception );

        virtual int underflow() throw( socktimeoutexception );

        bool ready( timeval * timeout, bool chk_read = true, bool chk_write = true ) throw( sockexception );


    private:

        socket_t _socket;

        size_t _bufsize;
        size_t _putbacksize;

        timeval * _timeout;
        bool      _timed_out;


        void init_defaults() throw();

    };

} /* end of namespace psocksxx */

#endif /* !PSOCKSXX_SOCKSTREAMBUF_H */