---

more/io/socket.h

Go to the documentation of this file.

//  Copyright (C) 2001--2002  Petter Urkedal (petter.urkedal@matfys.lth.se)
//
//  This file 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 2 of the License, or
//  (at your option) any later version.
//
//  This file 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 this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//  As a special exception, you may use this file as part of a free
//  software library without restriction.  Specifically, if other files
//  instantiate templates or use macros or inline functions from this
//  file, or you compile this file and link it with other files to
//  produce an executable, this file does not by itself cause the
//  resulting executable to be covered by the GNU General Public
//  License.  This exception does not however invalidate any other
//  reasons why the executable file might be covered by the GNU General
//  Public License.
//
//  $Id: socket.h,v 1.2 2002/07/30 17:46:03 petter_urkedal Exp $


#ifndef MORE_IO_SOCKET_H
#define MORE_IO_SOCKET_H

#include <iostream>
#include <more/lang/stdint.h>
#include <more/gen/utility.h>
#include <more/bits/fdstreambuf.h>
#include <string>
#include <list>
#include <stdexcept>

namespace more {
namespace io {

  ///\if bits
  struct socket_base
  {
      typedef int family_type;
//       static const int family_local;
      static const int family_inet4;
      static const int family_inet6;
//       static const int family_ipx;
      // XXX
  };
  ///\endif

  /** \class internet_address socket.h more/io/socket.h
   ** An IP number. */
  struct internet_address : socket_base
  {
      /** Construct an undefined address. */
      internet_address() : m_ptr_in_addr(0)/*, m_size_in_addr(0)*/ {}

      /** Don't use this, use 'host_address' for name lookup an pick
       ** one of the IP addresses from the provided iterator range. */
      explicit internet_address(std::string);

      /** Construct a deep copy of the address. */
      internet_address(internet_address const&);

      ~internet_address();

      /** Assign a deep copy. */
      internet_address& operator=(internet_address const&);

      /** The IP address family.  This is typically 'family_inet4'
       ** meaning and IP version 4 quad. */
      family_type family() const { return m_family; }

      /** Return true of the address is defined. */
      bool is_defined() const { return m_ptr_in_addr; }

      void from_unix_in_addr(family_type family, void*);
      void* to_unix_in_addr() { return m_ptr_in_addr; }
      void const* to_unix_in_addr() const { return m_ptr_in_addr; }
      void to_unix(void*) const;
      std::size_t unix_size() const;

    protected:
      void* m_ptr_in_addr;
//       size_t m_size_in_addr;
      family_type m_family;
  };

  std::istream& operator>>(std::istream&, internet_address&);
  std::ostream& operator<<(std::ostream&, internet_address const&);

  struct address_ipv4 : internet_address
  {
      address_ipv4(unsigned char* bytes);
  };

  struct address_ipv6 : internet_address
  {
      address_ipv6(unsigned char* bytes);
  };

  /** \class host_address socket.h more/io/socket.h
   ** Internet name and address information for a host. */
  struct host_address : socket_base
  {
      typedef std::list<internet_address>::const_iterator ip_address_iterator;
      typedef std::pair<ip_address_iterator, ip_address_iterator>
              ip_address_range;

      typedef std::list<std::string>::const_iterator host_alias_iterator;
      typedef std::pair<host_alias_iterator, host_alias_iterator>
              host_alias_range;

      /** Construct a host address from \a name possibly using
       ** nameserver lookup. */
      host_address(std::string const& name);

      /** Return the official name of this host. */
      std::string const& host_name() const { return m_name; }

      /** Return a range of aliases for this host. */
      host_alias_range
      host_aliases() const
      { return host_alias_range(m_aliases.begin(), m_aliases.end()); }

      /** Return a range of the IP addresses of this host. */
      ip_address_range
      ip_addresses() const
      { return ip_address_range(m_numbers.begin(), m_numbers.end()); }

    private:
      std::string m_name; // official name
      std::list<std::string> m_aliases;
      std::list<internet_address> m_numbers;
  };


  /** \class socket_address socket.h more/io/socket.h
   ** A socket address.  For network connections, this contains an
   ** internet address and information needed by the specified
   ** protocol family, like the port number for IP V4 and IP V6. */
  struct socket_address : socket_base
  {
      typedef lang::uint16_t port_type;

      /** Construct an undefined socket address. */
      socket_address() : m_ptr_sockaddr(0), m_size_sockaddr(0) {}

      /** Construct a deep copy of a socket address. */
      socket_address(socket_address const&);

      ~socket_address();

      /** Assign a deep copy of a socket address. */
      socket_address& operator=(socket_address const&);

      /** true if it contains a socket address. */
      bool is_defined() const { return m_ptr_sockaddr; }

      /** returns the protocol family. */
      family_type family() const;

      /** returns the port if applicable. */
      port_type port() const;

      void from_unix(void*, std::size_t size);
      void* to_unix() { return m_ptr_sockaddr; }
      void const* to_unix() const { return m_ptr_sockaddr; }
      std::size_t unix_size() const;

    protected:
      void assert_defined() const {
          if (!is_defined())
              throw std::logic_error("more::socket_address: "
                                     "Uninitialized socket address.");
      }
      void* m_ptr_sockaddr;
      std::size_t m_size_sockaddr;
      friend std::ostream& operator<<(std::ostream&, socket_address const&);
      friend std::istream& operator>>(std::istream&, socket_address&);
  };

  struct socket_address_ipv4 : socket_address
  {
      socket_address_ipv4(port_type port, internet_address const& addr);
  };

  struct socket_address_ipv6 : socket_address
  {
      socket_address_ipv6(port_type port, lang::uint32_t flowinfo,
                          internet_address const& addr,
                          lang::uint32_t scope_id);
  };


  /** A stream that can be attached to a socket.  Using the default
   ** ctor, a socket is initially in \c state_unbound.  The scenario
   ** then depends on whether the program is a client or a server.
   **
   ** If the program
   ** is a server, it will typically call the \c bind member function
   ** to associate to a port, and then \c listen to indicate that it
   ** is ready to accept connections from clients.  The socket will
   ** then be in \c state_listening.  Requests from clients are
   ** processed by constructing new sockets from the return value of
   ** \c accept.  The new sockets will be in \c state_accepted,
   ** whereas the socket from which the connections are popped will
   ** stay in \c state_listening.
   **
   ** A client program simply calls \c connect to establish a
   ** connection with the server.  It will then enter \c
   ** state_connected.
   **
   ** Some members returns <tt>false</tt> in case of failure.  This
   ** will also store the corresponding error condition internally,
   ** which can be probed with <tt>errno()</tt>.  Member functions
   ** will throw a logic error if it detects an error from the callers
   ** side, i.e. not originating from the unpredictable outside
   ** world. */
  struct socket
      : std::iostream, gen::noncopyable, socket_base
  {
      /* The state of a socket. */
      enum state_type
      {
          state_unbound,
          state_bound,
          state_listening,
          state_accepted,
          state_connected
      };

    private:
      struct _sub_init
      {
          _sub_init() {}
          _sub_init(_sub_init const& x) : m_fd(x.m_fd), m_sa(x.m_sa) {}
          _sub_init& operator=(_sub_init const& x) { return *this; }

      private:
          int m_fd;
          socket_address m_sa;
          int m_errno;
          friend class socket;
      };

    public:
      // Protcol families (see manpage socket(2)).

      // Communication types
      static const int type_stream;
//       static const int type_dgram;
//       static const int type_seqpacket;
//       static const int type_raw;
//       static const int type_rdm;
//       static const int type_packet;

      /** Construct a socket in \c states_unbound, i.e. not attached
       ** to any port. */
      socket();

      /** Construct a socket from the return value of accept.  The
       ** socket will be in \c state_accepted, meaning that it has
       ** accepted a connection from a client and is ready to serve it
       ** by communicating over the \c std::iostream base class. */
      socket(_sub_init init);

      /** Destruction which closes the socket. */
      ~socket() { delete rdbuf(); close(); }

    private:
      /** open the socket. You don't need to do this explicitely, just
       ** call bind or connect directly. */
      bool open(family_type family);

      /** Open a socket based on the return value of accept.  Return
       ** true if the corresponding call to <tt>accept</tt> was
       ** successful, otherwise return false.  */
      bool open(_sub_init init);

    public:
      /** Close the socket. Normally you don't need to call this, see
       ** open(). */
      void close();

      /** Return the state of the socket. */
      state_type state() const { return m_state; }

      /** Return true iff the socket can be read from or written
       ** to. This is the case iff it is in the connected or the
       ** accepted state. */
      bool is_streamable() const
      {
          return m_state == state_connected || m_state == state_accepted;
      }

      /** Connect a socket to a remote IP V4 or V6 address.  If
       ** successful, return true and change to
       ** <tt>state_connected</tt>, else return false. */
      bool connect(socket_address const&);

      /** Bind a socket to a local IP V4 or V6 address.  After binding
       ** to the address, you may call \c listen to make the server
       ** accessible at this address.  If successful, change to \c
       ** state_bound and return true, else return false. */
      bool bind(socket_address const&);

      /** Signal that we are ready to accept connections.  If
       ** successful switch to <tt>state_listening</tt> and return
       ** true, else return false. */
      bool listen(int backlog = 5);

      /** Pop a connection off a listening socket. The return type can
       ** be used as an argument to the ctor or \c open member of
       ** another socket object.  If successful the socket constructed
       ** will be in <tt>state_accepted</tt>, otherwise it will be in
       ** <tt>state_unbound</tt>.  A failure of this member function
       ** does not affect the state of the listening socket which it
       ** was called from.  */
      _sub_init accept();

      /** Returns the address of the socket. */
      socket_address const& address() const { return m_sa; }

      /** Returns the C \c errno from the last error.  This can be
       ** passed to <tt>diag::strerror</tt> to obtain an informative
       ** description of the failure, or to
       ** <tt>diag::errno_exception</tt> to throw an exception with
       ** such a message.  The result of this function only makes
       ** sense if there has been an error. */
      int the_errno() const { return m_errno; }

    private:
      io::bits::fdstreambuf*
      rdbuf()
      {
          return static_cast<bits::fdstreambuf*>(std::iostream::rdbuf());
      }

      socket_address    m_sa;
      state_type        m_state;
      int               m_fd;
      int               m_errno;
  };

}} // more::io

#endif

---