basic_socketbuf.h

Go to the documentation of this file.

// -*- Socket Streams -*-

// Copyright (C) 2003, 2004, 2005 Pedro Lamarão <pedro.lamarao@mndfck.org>

// This file is part of the Socket Streams Library.  This 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 2.1 of the License
// or (at your option) any later version.

// This 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 library; see the file COPYING. If not, write to the Free
// Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307,
// USA

#ifndef SOCKETSTREAM_BASIC_SOCKETBUF_H
#define SOCKETSTREAM_BASIC_SOCKETBUF_H 1

#include <socketstream/config.h>

#include <cerrno>
#include <streambuf>
#include <socketstream/basic_socket.h>
#include <socketstream/address_factory.h>

#ifdef WIN32
# define EWOULDBLOCK WSAEWOULDBLOCK
#endif

#define SOCKETSTREAM_BUFSIZE 32

namespace ss {

  template <typename _CharT, typename _Traits>
  class basic_socketbuf
  : public std::basic_streambuf<_CharT, _Traits>
  {
  public:


    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;
    typedef basic_socketbuf<char_type, traits_type> __socketbuf_type;
    
    template <typename C, typename T>
    friend class basic_socketstream;

    basic_socketbuf()
    : __streambuf_type(), _M_socket(), _M_flags(sockets_base::def::flag),
      _M_buf(0), _M_buf_size(SOCKETSTREAM_BUFSIZE),
      _M_put_buf_size(), _M_get_buf_size(),
      _M_buf_allocated(false),
          _M_open(false)
    {}

    basic_socketbuf (sockets_base::family __f, sockets_base::style __s)
    : __streambuf_type(), _M_socket(__f, __s), _M_flags(sockets_base::def::flag),
      _M_buf(0), _M_buf_size(SOCKETSTREAM_BUFSIZE),
      _M_put_buf_size(), _M_get_buf_size(),
      _M_buf_allocated(false),
          _M_open(false)
    {}

    virtual
    ~basic_socketbuf()
    { _M_destroy_internal_buffer(); }

        template <typename AddressT>
    __socketbuf_type*
    connect (AddressT& __addr)
    {
      try
      {
        _M_socket.connect(&__addr, sizeof(__addr));
        _M_allocate_internal_buffer();
      }
      catch (const socket_exception& se)
      {
        switch (se.code())
        {
          case EWOULDBLOCK:
            // we can't return anything sensible anywhere else, be consistent
          default:
            throw;
        }
      }

      _M_open = true;
      return this;
    }

    bool
    is_open () const throw ()
    {
      return _M_open; // TODO: FIXME!
    }

    __socketbuf_type*
    shutdown (sockets_base::shutmode __mode = sockets_base::rw) throw ()
    {
      if (is_open())
        _M_socket.shutdown(__mode);
      _M_open = false;
      return this;      
    }

    basic_socket&
    socket ()
    {
      return _M_socket;
    }

    sockets_base::flag
    setf (sockets_base::flag __f)
    {
      sockets_base::flag __old = _M_flags;
      _M_flags = __f;
      return __old;
    }

  protected:

    basic_socketbuf(basic_socket::descriptor_t descriptor)
    : __streambuf_type(), _M_socket(descriptor),
      _M_flags(sockets_base::def::flag),
      _M_buf(0), _M_buf_size(SOCKETSTREAM_BUFSIZE),
      _M_put_buf_size(), _M_get_buf_size(),
      _M_buf_allocated(false),
          _M_open(false)
    {}

    virtual int_type
    underflow ()
    {
      int_type __ret = traits_type::eof();
      try
      {
        if (_M_get_buf_size > 0) // buffered input
        {
          const size_t __buflen = _M_get_buf_size;
          int __num = _M_socket.receive(this->eback(), __buflen, _M_flags);
          if (__num > 0)
          {
            this->setg(this->eback(), this->eback(), this->eback() + __num);
            __ret = traits_type::to_int_type(*this->gptr());
          }
        }
        else // unbuffered input
        {
          char_type c = __ret;
          if (_M_socket.receive(&c, 1, _M_flags) > 0)
          {
            __ret = traits_type::to_int_type(c);
          }
        }
      }
      catch (const socket_exception& e)
      {
        switch (e.code())
        {
          case EWOULDBLOCK:
            // we can't return anything sensible, can we?
          case EINTR:
          default:
            throw;
        }
      }
      return __ret;
    }

     virtual int_type
     uflow ()
     {
       int_type __ret = this->underflow();
       if (__ret != traits_type::eof() && _M_get_buf_size > 0)
       {
         this->gbump(1);
       }
       return __ret;
     }
     
    virtual int_type
    overflow (int_type __c = traits_type::eof())
    {
      int_type __ret = traits_type::eof();
      const bool __testeof = traits_type::eq_int_type(__c, __ret);
      try
      {
        if (!__testeof)
        {
          *this->pptr() = traits_type::to_char_type(__c);
          this->pbump(1);
        }
        int __num = _M_socket.send(this->pbase(), this->pptr() - this->pbase(), _M_flags);
        if (__num > 0)
        {
          this->pbump(-__num);
          __ret = __c;
        }
      }
      catch (const socket_exception& e)
      {
        switch (e.code())
        {
          case EPIPE:
            return traits_type::eof();
          case EWOULDBLOCK:
            // we can't return anything sensible, can we?
          case EINTR:
          default:
            throw;
        }
      }
      return __ret;
    }

    virtual __streambuf_type*
    setbuf (char_type *__s, std::streamsize __n)
    {
      if (!this->is_open() && __s == 0 && __n == 0)
      {
        _M_buf_size = 1;
      }
      else if (__s && __n > 0)
      {
        _M_destroy_internal_buffer();
        _M_buf = __s;
        _M_buf_size = __n;
        _M_get_buf_size = _M_buf_size / 2;
        _M_put_buf_size = _M_buf_size - _M_get_buf_size;
        this->setp(_M_buf, _M_buf + _M_put_buf_size - 1); // -1 for the overflow char
        this->setg(_M_buf + _M_put_buf_size,
                          _M_buf + _M_put_buf_size,
                          _M_buf + _M_put_buf_size);
      }
      return this;
    }

    virtual int
    sync ()
    {
      int __ret = 0;
      if (this->pbase() < this->pptr())
      {
        this->overflow();
      }
      return __ret;
    }
    
    virtual std::streamsize
    showmanyc ()
    {
      std::streamsize __ret = -1;
      if (this->is_open())
      {
        __ret = this->egptr() - this->gptr();
        char_type c;
        __ret += _M_socket.receive(&c, 1, sockets_base::peek);
      }
      return __ret;
    }
    
    virtual int_type
    pbackfail (int_type = traits_type::eof())
    {
      return traits_type::eof();
    }
  
  private:
  
    void
    _M_allocate_internal_buffer ()
    {
      if (!_M_buf_allocated && _M_buf_size)
      {
        _M_buf = new char_type[_M_buf_size];
        _M_buf_allocated = true;
      }
      _M_get_buf_size = _M_buf_size / 2;
      _M_put_buf_size = _M_buf_size - _M_get_buf_size;
      this->setp(_M_buf, _M_buf + _M_put_buf_size - 1); // -1 for the overflow char
      this->setg(_M_buf + _M_put_buf_size,
                        _M_buf + _M_put_buf_size,
                        _M_buf + _M_put_buf_size);
    }

    void
    _M_destroy_internal_buffer () throw ()
    {
      if (_M_buf_allocated)
      {
        delete [] _M_buf;
        _M_buf = 0;
        _M_buf_allocated = false;
      }
      this->setp(0, 0);
      this->setg(0, 0, 0);
    }

  private:

        basic_socketbuf (basic_socketbuf<char_type, traits_type> const&);
        basic_socketbuf<char_type, traits_type>&
        operator= (basic_socketbuf<char_type, traits_type> const&);

    basic_socket _M_socket;
  
    sockets_base::flag _M_flags;
  
    char_type* _M_buf;
    size_t     _M_buf_size;
    size_t     _M_put_buf_size;
    size_t     _M_get_buf_size;
    bool       _M_buf_allocated;

        bool       _M_open;

  };

  typedef basic_socketbuf<char, std::char_traits<char> > socketbuf;

}

#endif  // SOCKETSTREAM_BASIC_SOCKETBUF_H

---