macossocket.cpp

"More for C++" is a class library that provides some features that are usually common for object ori

  m_nNoOfLastReadBytes = 1;
}

////////////////////////////////////////////////////////////////////////////////

bool MacOSSocket::isValid( ) const
{
  return m_pEndpoint != kOTInvalidEndpointRef;
}

////////////////////////////////////////////////////////////////////////////////

void MacOSSocket::connect
(
  const String&  sNameOfHost,
  size_t      nNoOfPort
)
  throw( IOException )
{
  OSStatus  nStatusCode;
  TCall    call;
  DNSAddress  address;
  char    sNameOfHostAndPort[256];

  throwIfNotValid( );

  if( m_bHasBeenConnected )
  {
    throw IOException( -1, "Socket has already been connected" );
  }

  nStatusCode = OTBind( m_pEndpoint, 0, 0 );

  if( nStatusCode != noErr )
  {
    throw IOException( nStatusCode, "Could not bind socket for connecting" );
  }

  m_bHasBeenBound = true;

  OTMemzero( &call, sizeof( TCall ) );

  call.addr.buf = ( UInt8* ) &address;

  sprintf( sNameOfHostAndPort, "%s:%d", ( const char* ) sNameOfHost, nNoOfPort );

  call.addr.len = OTInitDNSAddress( &address, sNameOfHostAndPort );

  nStatusCode = OTConnect( m_pEndpoint, &call, 0 );

  if( nStatusCode == kOTLookErr )
  {
    handleOTLook( m_pEndpoint );
  }

  if( nStatusCode != noErr )
  {
    throw IOException( nStatusCode, "Unable to connect to socket" );
  }

  m_bHasBeenConnected = true;
}

////////////////////////////////////////////////////////////////////////////////

String MacOSSocket::getNameOfHost( ) const
{
  OSStatus    nStatusCode;
  TBind      bindRequest;
  InetAddress    protAddress;
  char      cBuffer[256];
  unsigned char*  pBytes = ( unsigned char* ) &protAddress.fPort;

  throwIfNotValid( );

  bindRequest.addr.buf = ( UInt8* ) &protAddress;
  bindRequest.addr.len = sizeof( InetAddress );
  bindRequest.qlen = 1;

  nStatusCode = OTGetProtAddress( m_pEndpoint, &bindRequest, 0 );

  if( nStatusCode != noErr )
  {
    throw IOException( -1, "OTGetProtAddress failed in MacOSSocket::getNoOfPort" );
  }

  sprintf( cBuffer, "%d.%d.%d.%d", ( int ) pBytes[0],
                   ( int ) pBytes[1],
                   ( int ) pBytes[2],
                   ( int ) pBytes[3] );
  return cBuffer;
}

////////////////////////////////////////////////////////////////////////////////

size_t MacOSSocket::getNoOfPort( ) const
{
  OSStatus    nStatusCode;
  TBind      bindRequest;
  InetAddress    protAddress;

  throwIfNotValid( );

  bindRequest.addr.buf = ( UInt8* ) &protAddress;
  bindRequest.addr.len = sizeof( InetAddress );
  bindRequest.qlen = 1;

  nStatusCode = OTGetProtAddress( m_pEndpoint, &bindRequest, 0 );

  if( nStatusCode != noErr )
  {
    throw IOException( -1, "OTGetProtAddress failed in MacOSSocket::getNoOfPort" );
  }

  return protAddress.fPort;
}

////////////////////////////////////////////////////////////////////////////////

p<InputStream> MacOSSocket::getInputStream( ) throw( IOException )
{
  throwIfNotValid( );

  return CREATE MacOSSocketInputStream( this );
}

////////////////////////////////////////////////////////////////////////////////

p<OutputStream> MacOSSocket::getOutputStream( ) throw( IOException )
{
  throwIfNotValid( );

  return CREATE MacOSSocketOutputStream( this );
}

////////////////////////////////////////////////////////////////////////////////

void MacOSSocket::close( ) throw( IOException )
{
  OSStatus nStatusCode;

  throwIfNotValid( );

  if( m_bHasBeenBound )
  {
    nStatusCode = OTUnbind( m_pEndpoint );

    m_bHasBeenBound = false;
  }

  nStatusCode = OTCloseProvider( m_pEndpoint );

  m_pEndpoint = kOTInvalidEndpointRef;
}

////////////////////////////////////////////////////////////////////////////////

void MacOSSocket::finalize( )
{
  if( isValid( ) )
  {
    close( );
  }
}

////////////////////////////////////////////////////////////////////////////////

size_t MacOSSocket::available( ) throw( IOException )
{
  throwIfNotValid( );

  return 0;
}

////////////////////////////////////////////////////////////////////////////////

bool MacOSSocket::hasBeenClosed( ) throw( IOException )
{
  throwIfNotValid( );

  return m_nNoOfLastReadBytes == 0;
}

////////////////////////////////////////////////////////////////////////////////

size_t MacOSSocket::read
(
  void*    pBuffer,
  size_t    nOffset,
  size_t    nMaxNoOfBytes

)  throw( IOException )
{
  OTResult  nResult;
  size_t    nAvailable;
  OTFlags    flags;

  throwIfNotValid( );

  nResult = OTCountDataBytes( m_pEndpoint, &nAvailable );

  if( nResult == noErr && nAvailable < nMaxNoOfBytes )
  {
    nMaxNoOfBytes = nAvailable;
  }

  nResult = OTRcv( m_pEndpoint, ( char* ) pBuffer + nOffset, nMaxNoOfBytes, &flags );

  if( nResult > 0 )
  {
    m_nNoOfLastReadBytes = ( size_t ) nResult;
  }
  else
  {
    m_nNoOfLastReadBytes = 0;
  }

  if( nResult == kOTLookErr )
  {
    nResult = handleOTLook( m_pEndpoint );
  }

  if( nResult < 0 )
  {
    throw IOException( nResult, "Error while reading from socket" );
  }

  return ( size_t ) nResult;
}

////////////////////////////////////////////////////////////////////////////////

size_t MacOSSocket::skip
(
  size_t bytesToSkip
)
  throw( IOException )
{
  size_t  bytesLeftToSkip = bytesToSkip;
  void*  pBuffer = OTAllocMem( 4096 );

  while( bytesLeftToSkip > 4096 )
  {
    read( pBuffer, 0, 4096 );
    bytesLeftToSkip -= 4096;
  }

  if( bytesLeftToSkip > 0 )
  {
    read( pBuffer, 0, bytesLeftToSkip );
  }

  OTFreeMem( pBuffer );

  return bytesToSkip;
}

////////////////////////////////////////////////////////////////////////////////

void MacOSSocket::write
(
  const void*    pBuffer,
  size_t      nNoOfBytes
)
  throw( IOException )
{
  OTResult  nResult;

  throwIfNotValid( );

  nResult = OTSnd( m_pEndpoint, const_cast<void*>( pBuffer ), nNoOfBytes, 0 );

  if( nResult == kOTLookErr )
  {
    handleOTLook( m_pEndpoint );
  }

  if( nResult < 0 )
  {
    throw IOException( nResult, "Error while writing to socket" );
  }
}

////////////////////////////////////////////////////////////////////////////////

void MacOSSocket::flush( ) throw( IOException )
{
  throwIfNotValid( );
}

////////////////////////////////////////////////////////////////////////////////

MacOSSocketInputStream::MacOSSocketInputStream
(
  p<MacOSSocket> pMacOSSocket
)
:  m_pMacOSSocket( pMacOSSocket )
{
}

////////////////////////////////////////////////////////////////////////////////

size_t MacOSSocketInputStream::available( ) throw( IOException )
{
  return m_pMacOSSocket -> available( );
}

////////////////////////////////////////////////////////////////////////////////

bool MacOSSocketInputStream::hasBeenClosed( ) throw( IOException )
{
  return m_pMacOSSocket -> hasBeenClosed( );
}

////////////////////////////////////////////////////////////////////////////////

size_t MacOSSocketInputStream::read
(
  void*    pBuffer,
  size_t    nOffset,
  size_t    nMaxNoOfBytes

)  throw( IOException )
{
  return m_pMacOSSocket -> read( pBuffer, nOffset, nMaxNoOfBytes );
}

////////////////////////////////////////////////////////////////////////////////

size_t MacOSSocketInputStream::skip
(
  size_t  nNoOfBytes

)  throw( IOException )
{
  return m_pMacOSSocket -> skip( nNoOfBytes );
}

////////////////////////////////////////////////////////////////////////////////

MacOSSocketOutputStream::MacOSSocketOutputStream
(
  p<MacOSSocket> pMacOSSocket
)
:  m_pMacOSSocket( pMacOSSocket )
{
}

////////////////////////////////////////////////////////////////////////////////

void MacOSSocketOutputStream::write
(
  const void*    pBuffer,
  size_t      nNoOfBytes

)  throw( IOException )
{
  m_pMacOSSocket -> write( pBuffer, nNoOfBytes );
}

////////////////////////////////////////////////////////////////////////////////

void MacOSSocketOutputStream::flush( ) throw( IOException )
{
  m_pMacOSSocket -> flush( );
}

////////////////////////////////////////////////////////////////////////////////