socket.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2001 by Rick L. Vinyard, Jr.                            *
 *   rvinyard@cs.nmsu.edu                                                  *
 *                                                                         *
 *   This file is part of the conexus library.                             *
 *                                                                         *
 *   The conexus library is free software; you can redistribute it and/or  *
 *   modify it under the terms of the GNU General Public License           *
 *   version 3 as published by the Free Software Foundation.               *
 *                                                                         *
 *   The conexus 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   *
 *   General Public License for more details.                              *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this software. If not see <http://www.gnu.org/licenses/>.  *
 ***************************************************************************/
#ifndef CONEXUSSOCKET_H
#define CONEXUSSOCKET_H

#include <sys/types.h>
#include <utility>

#include <conexus/enums.h>
#include <conexus/filedescriptor.h>
#include <conexus/address.h>
#include <conexus/except.h>

#include <iostream>

namespace Conexus
{

  class Socket: public FileDescriptor
  {
    protected:

      Socket( int domain = -1, int type = -1, int protocol = 0 ) throw ();

    public:

      typedef ConexusPointer<Socket> pointer;

      static pointer create( int domain = -1, int type = -1, int protocol = 0 ) throw ();

      virtual ~Socket() throw ();

      virtual void open() throw ( open_exception );

      virtual void close( bool force = false ) throw ( close_exception );

      virtual void bind() throw ( bind_exception );

      virtual void bind( const Conexus::Address& a ) throw ( bind_exception );

      virtual void connect() throw ( connect_exception );

      virtual void connect( const Address& a ) throw ( connect_exception );

      virtual void listen( int backlog = 0 );

      int domain() throw ();

      void set_domain( int ) throw ();

      int type() throw ();

      void set_type( int ) throw ();

      int protocol() throw ();

      void set_protocol( int ) throw ();

      virtual size_t writeto( Address& a, const void* data, size_t size, Timeout timeout=Timeout(-1) ) throw ( write_exception );

      virtual size_t writeto( Address& a, const Data data, Timeout timeout=Timeout(-1) ) throw ( write_exception );

      virtual void set_option( int option, bool b, long required_state=SOCKET_BOUND );

      template <typename T>
      void set_option( int level, int optname, T& value, long required_state=SOCKET_BOUND );

      template <typename T>
      void option( int level, int optname, T& value, long required_state=SOCKET_BOUND );

      void enable_reuse_address( bool enable=true );

      virtual void change_state( long states ) throw ( state_exception );

      sigc::signal<void> signal_bound();

      sigc::signal<void> signal_connected();

      sigc::signal<void> signal_listening();

      bool is_bound();

      bool is_connected();

      bool is_listening();

      bool is_accepted();

    protected:
      int m_domain;
      int m_type;
      int m_protocol;

      virtual void read_thread_main();

      virtual void set_state_closed();
      virtual void set_state_bound();
      virtual void set_state_connected();
      virtual void set_state_listening();

      sigc::signal<void> m_signal_bound;
      sigc::signal<void> m_signal_connected;
      sigc::signal<void> m_signal_listening;

      virtual size_t write_data( const Data data, Timeout timeout ) throw ( write_exception );

      virtual Data read_data( size_t size, Timeout timeout ) throw ( read_exception );

  };

  template <typename T>
  inline
  void Socket::set_option( int level, int optname, T& value, long required_state )
  {
    try {
      change_state( required_state );
    } catch ( exception::state::failed ) {
      return ;
    }

    int result = ::setsockopt(m_fd, level, optname, &value, sizeof(T));

    if ( result == -1 ) throw_socket_exception( errno );
  }

  template <typename T>
  inline
  void Socket::option( int level, int optname, T& value, long required_state )
  {
    try {
      change_state( required_state );
    } catch ( exception::state::failed ) {
      return ;
    }

    socklen_t size = sizeof( T );
    ::getsockopt( m_fd, level, optname, &value, &size );
  }
}

#endif