cabal_socket.h

/*
   cabal_socket.h
   Basic socket object for cabal

   $Id: cabal_socket.h,v 1.5 2004/03/29 02:15:52 jonnymind Exp $
---------------------------------------------
   Begin      : 2003-12-13 05:00
   Author     : Giancarlo Niccolai

   Last modified because:

*/

#ifndef CABAL_SOCKET_H
#define CABAL_SOCKET_H

#include <cabal_address.h>
#include <cabal_recpt.h>
#include <cabal_error.h>
#include <cabal_os.h>
#include <cabal_ref.h>

#include <string>


#define CABAL_DOMAIN    PF_INET

namespace Cabal
{

class Channel;

typedef enum
{
   ST_TCP = 1,
   ST_UDP = 2,
} SockType;

typedef enum
{
   OT_NONE = 0,
   OT_CONNECTING,
   OT_SENDINGALL,
   OT_RECEIVINGALL
} OpType;



class Socket: public Referenceable 
{

   inline void initialize( const SockType type ) 
   {
      m_type = type;
      m_timeout = -1;
      m_bTout = false;
      m_osError = 0;
      m_channel = 0;
      m_refcount = 1;
      m_recpt = 0;
   }

protected:
   SockType m_type;
   long m_timeout;
   bool m_bTout;
   int m_osError;
   int m_refcount;
   Channel *m_channel;
   Reception *m_recpt;

   Address m_remote;
   Address m_local;

   // internal socket
   RawSocket m_skCom;

   int Socket::selectFor( bool rw );
   
   virtual int rawRecv( void *data, const int len ) = 0;
   virtual int rawSend( const void *data, const int len ) = 0;
   
   Socket( const SockType type )
   {
      initialize( type );
   }

   Socket( const SockType type ,
            const char *ipaddr_local, const int port_local )
      : m_local( ipaddr_local, port_local )
   {
      initialize( type );
   }
   
   Socket( const SockType type, 
           const char *ipaddr_local, const int port_local,
           const char *ipaddr_remote, const int port_remote )
      : m_local( ipaddr_local, port_local ),
        m_remote( ipaddr_remote, port_remote )
   {
      initialize( type );
   }
      
   friend class ServerSocket;
public:
   
   virtual ~Socket()
   {
      close();
   }
   
   Socket( const Socket & ) throw( InitError );
   
   bool bind( const Address &local );
   
   virtual int recv( void *buffer, const int len );
   
   virtual int send( const void *buffer, const int len );
   
   bool continueOp();
   
   virtual bool close();
   
   inline const Address &remote() const { return m_remote; }
   
   inline const Address &local() const { return m_local; }

   inline long timeout() const { return m_timeout; }
   
   inline void timeout( const long to ) { m_timeout = to; }
   
   inline bool hasTimedOut() const { return m_bTout; }
   
   inline int osError() const { return m_osError; }
   
   inline bool closed() const { return ( ! Net::validSocket( m_skCom ) ); }

   inline RawSocket rawSocket() const { return m_skCom; }

   void channel( Channel *chn, Reception *rcpt ); 
   
   
   /* Returns the reception object used by this socket. 
   */
   inline Reception *reception() const { return m_recpt; }
   
   inline Channel *channel() const { return m_channel; }
   
   inline bool managed() const { return m_channel != 0 ; }
   
   inline const char *remote_ip() { return m_remote.ip(); }
   inline int remote_port() const { return m_remote.port(); }
   
   inline const char *local_ip() { return m_remote.ip(); }
   inline int local_port() const { return m_remote.port(); }
   
   
   virtual inline void incref() {
      m_refcount ++; 

   }
   
   virtual inline void decref() 
   {
      m_refcount--;
      if ( m_refcount == 0) {
         delete this;
      }
   }
   
};

}

#endif

/* end of cabal_ssocket.h */

---