cabal_socket.cpp

/*
   CABAL Protocol
   Socket class implementation

   $Id: cabal_socket.cpp,v 1.4 2004/03/26 12:03:02 jonnymind Exp $
---------------------------------------------
   Begin      :
   Author     : Giancarlo Niccolai

   Last modified because:

*/

#ifdef __MSC_VER
#pragma warning ( disable : 4786 )
#endif

#include <cabal_socket.h>
#include <cabal_channel.h>
#include <fcntl.h>
#include <string>
#include <cassert>

namespace Cabal {

Socket::Socket( const Socket &orig )
   throw( InitError )
{
   m_skCom = Net::dup( orig.m_skCom );
   if ( ! Net::validSocket( m_skCom ) )
      throw InitError( "Can't create a new file descriptor", Net::errorCode() );

   m_timeout = orig.m_timeout;
   m_bTout = orig.m_bTout;
   m_type = orig.m_type;

   m_remote = orig.m_remote;
   m_local = orig.m_local;
   
   m_channel = 0;
   m_recpt = 0;
}


bool Socket::bind( const Address &local ) 
{
   if ( ! Net::bind( m_skCom, local.address() )  ) 
   {
      m_osError = Net::errorCode();
      return false;
   }

   m_osError = 0;
   m_local =  local;
   return true;
}

int Socket::selectFor( bool rw )
{
   // if this socket is managed, always return as if data was ready.
   if ( managed() ) return 1;

   fd_set set;
   struct timeval tv;

   FD_ZERO( &set );
   FD_SET(m_skCom, &set);
   Net::resetError();

   if ( m_timeout == -1 )
   {
      if ( rw )
         select(m_skCom+1, NULL, &set, NULL, NULL);
      else
         select(m_skCom+1, &set, NULL, NULL, NULL);
   }
   else
   {
      tv.tv_sec = m_timeout/ 1000;
      tv.tv_usec = (m_timeout % 1000) * 1000;
      if ( rw )
         select(m_skCom + 1, NULL, &set, NULL, &tv);
      else
         select(m_skCom + 1, &set, NULL, NULL, &tv);
   }

   return FD_ISSET( m_skCom, &set );
}


int Socket::recv( void *buffer, const int len )
{
   int retlen;
   
   if( selectFor( false ) ) //read
   {
      retlen = rawRecv( buffer, len );
         
      if ( retlen <  0 )
         m_osError = Net::errorCode();
      else {
         m_osError = 0;
         // closed.
         if ( retlen == 0 ) {
            Net::closeSocket( m_skCom );
            Net::invalidate( m_skCom );
         }
      }

      m_bTout = false;
      return retlen;
   }
   else
   {
      m_osError = 0;
      m_bTout = true;
      return 0;
   }
}

int Socket::send( const void *buffer, const int len )
{
   if ( ! Net::validSocket( m_skCom ) ) return -1;

   int readin;
   if( selectFor( true ) ) //write
   {
      readin = rawSend( buffer, len );
      
      if ( readin <  0 ) {
         if ( Net::errorPipe() ) {
            // connection closed
            Net::closeSocket( m_skCom );
            Net::invalidate( m_skCom );
            readin = 0;
            m_osError = 0;
         }
         else
            m_osError = Net::errorCode();
      }
      else
         m_osError = 0;
      m_bTout = false;
      return readin;
   }
   else
   {
      m_osError = 0;
      m_bTout = true;
      return 0;
   }
}

bool Socket::close()
{
   m_osError = 0;
   if ( m_recpt != 0 )
   {
      m_recpt->terminate( this );
      delete m_recpt;
      m_recpt = 0;
   }

   if ( ! Net::validSocket( m_skCom ) ) 
      return false;
   
   if (  Net::closeSocket( m_skCom ) == 0 ) {
      Net::invalidate( m_skCom );
      return true;
   }
   else {
      m_osError = Net::errorCode();
      return false;
   }
}


void Socket::channel( Channel *chn, Reception* rcpt )
{ 
   if ( m_recpt != 0 )
   {
      m_recpt->terminate( this );
      delete m_recpt;
   }
   
   m_recpt = rcpt;
   m_recpt->init( this );
   
   if ( m_channel ) 
      m_channel->removeSocket( this );
   
   m_channel = chn; 
   
   if ( m_channel )
      m_channel->addSocket( this );
}

} //namespace

---