BioSocketBuffer.h

Go to the documentation of this file.

#ifndef BIOSOCKETBUFFER_H
#define BIOSOCKETBUFFER_H

#include <new>
#include <streambuf>
#include <memory>
#include <cstdio>
#include <cstring>

#include "BioSocketBase.h"

template<typename _CharT, typename _Traits = std::char_traits<_CharT> >
class BioBasicSocketBuffer : public std::basic_streambuf<_CharT, _Traits>
{
public:
        // Types:
        typedef _CharT                          char_type;
        typedef _Traits                         traits_type;
        typedef typename traits_type::int_type  int_type;
        typedef typename traits_type::pos_type  pos_type;
        typedef typename traits_type::off_type  off_type;

        typedef std::basic_streambuf<char_type, traits_type> __streambuf_type;

protected:

        BioSocket _M_socket;

        char *_M_ibuffer, *_M_obuffer;

        int _M_buf_size;


public:
        BioBasicSocketBuffer() :
                _M_socket(BioSocket::invalid_socket)
        {
                _M_buffer_init();
        }

        explicit BioBasicSocketBuffer(BioSocket sock_)
        :       _M_socket(sock_)
        {
                _M_buffer_init();
        }
        

        explicit BioBasicSocketBuffer(const BioSocketAddressIn& _sin)
        :       _M_socket(BioSocket::invalid_socket)
        {
                _M_buffer_init();
                connect(_sin);
        }
        

        virtual ~BioBasicSocketBuffer()
        {
                sync();
                close();
                _M_buffer_delete();
        }

        BioSocket socket() const
        throw()
        {
               return _M_socket;
        }


        void socket(BioSocket sock_)
        throw()
        {
                _M_socket = sock_;
        }
        
        bool connect(const BioSocketAddressIn& _sin)
        throw ()
        {
                if (_M_socket.fd == BioSocket::invalid_socket)
                        if (!_M_socket.create(  BioSocket::pf_inet,
                                                BioSocket::sock_stream,
                                                BioSocket::proto_ip))
                                return false;
                                                
                return _M_socket.connect(_sin);
        }
        
        bool connect(const std::string& _addr, uint16_t _port)
        throw()
        {
                BioSocketAddressIn _sin;

                if (!_sin.ip(_addr))
                        if (!_sin.resolve(_addr))
                                return false;

                _sin.port(_port);

                return connect(_sin);
        }


        BioBasicSocketBuffer* close()
        throw()
        {
                bool _s = _M_socket.close();
                _M_socket.fd = BioSocket::invalid_socket;

                return  _s ? 0 : this;
        }
        
        bool can_read(uint32_t usec_=0, uint32_t sec_ = 0)
        throw (std::ios_base::failure)
        {
                if (_M_socket.can_read(usec_, sec_))
                        return true;
                if (_M_socket.error)
                        throw std::ios_base::failure("BioBasicSocketBuffer::can_read()");
                return false;
        }
        
        bool can_write(uint32_t _usec=0, uint32_t _sec = 0)
        throw (std::ios_base::failure)
        {
                if (_M_socket.can_write(_usec, _sec))
                        return true;
                if (_M_socket.error)
                        throw std::ios_base::failure("BioBasicSocketBuffer::can_write");
                return false;
        }
        

        bool is_connected() const
        throw()
        {
                BioSocketAddressIn _sin;
                if (!_M_socket.peername(_sin))
                        return false;
                return true;
        }

protected:
        // Common initialization code for both ctors goes here.
        void _M_buffer_init(int _sz = 1024)
        {
                _M_buf_size = _sz;
                _M_ibuffer = new char_type[ (_M_buf_size+1) * 2 ];
                _M_obuffer = _M_ibuffer + _M_buf_size + 1;

                this->setg(_M_ibuffer, _M_ibuffer + 1, _M_ibuffer + 1);
                this->setp(_M_obuffer, _M_obuffer + _M_buf_size);
        }
        
        void _M_buffer_delete()
        {
                delete[] _M_ibuffer;
        }


        virtual int_type underflow()
        {
                *this->eback() = -1[this->gptr()];  // to allow putback operations

                int result = _M_socket.recv(this->eback() + 1 , _M_buf_size);

                if (result < 1)
                        return traits_type::eof();

                this->setg(this->eback(), this->eback()+1, this->eback() + result + 1);
                
                return traits_type::to_int_type(*this->gptr());
        }
        

        virtual int showmanyc()
        {
                unsigned long data;
                if (!_M_socket.ioctl(BioSocket::fionread, data))
                        return -1;
                return data;
        }
        

        virtual int_type overflow(int_type __c = traits_type::eof())
        {
                char *s1 = this->pbase();
                char *s2 = this->pptr();
                
                int num = s2-s1;

                /* TODO (DanielKO#2#): Make overflow use socklibpp::sock::sendall() */
                if (__c != traits_type::eof()) {
                        *this->pptr() = __c;
                        ++num;
                }
                
                if (!num)
                        return traits_type::eof();

                int result = _M_socket.send(s1, num);

                if (_M_socket.error)
                        return traits_type::eof();

                if (result != num)      // didn't write everything
                        memmove(
                        //std::memmove(
                                s1,
                                s1 + result,
                                num - result);

                this->setp(_M_obuffer, _M_obuffer + _M_buf_size);

                return traits_type::to_int_type(num);
        }


        virtual int sync()
        {
                while (this->pptr() > this->pbase())
                        if (overflow(traits_type::eof()) == traits_type::eof())
                                return -1;
                                
                return 0;
        }

        virtual __streambuf_type* setbuf(char_type*, std::streamsize _n)
        {
                if (_n<2)
                        return 0;
                try {
                        _M_buffer_delete();
                        _M_buffer_init(_n);
                        return this;
                }
                catch(...)
                {
                        return 0;
                }
        }

};


typedef BioBasicSocketBuffer<char>     BioSocketBuffer;

#endif