RemoteServer.cc

/*
 * Copyright 2003 Michael A. Marsh, Cornell University. All rights reserved.
 * This software is released under the modified BSD license.
 * See the file LICENSE in the top-level directory for details.
 */
//
// $Id: RemoteServer.cc,v 1.3 2004/05/19 15:56:56 mmarsh Exp $
//
// $Log: RemoteServer.cc,v $
// Revision 1.3  2004/05/19 15:56:56  mmarsh
// *** empty log message ***
//
// Revision 1.2  2003/11/04 22:17:23  mmarsh
// General code cleanup.
//
//

#include "RemoteServer.h"
#include "SocketBuilder.h"
#include "Socket.h"

#include <iostream>
#include <netdb.h>
#include <arpa/inet.h>

using namespace CODEX_Quorum;

RemoteServer::RemoteServer( struct timeval* timeout,
                            string address,
                            int port,
                            const SocketBuilder& socketBuilder,
                            SocketBase* socket ) :
   m_timeout(timeout),
   m_socketBuilder(socketBuilder),
   m_socket(socket),
   m_sockaddr(0)
{
   m_address = address;
   m_port = port;
}

RemoteServer::~RemoteServer()
{
   if ( 0 != m_sockaddr )
      delete m_sockaddr;
   if ( 0 != m_socket )
      delete m_socket;
}

const struct sockaddr_in*
RemoteServer::sockaddr_in() const
{
   if ( 0 == m_sockaddr )
   {
      struct hostent* p_host = gethostbyname( name().c_str() );
      if ( 0 == p_host )
         throw QSERemoteServerGethostbynameFailed( __FILE__ ,
                                                   __LINE__ ,
                                                   this );
      struct in_addr* p_in_addr = (struct in_addr*) (p_host->h_addr_list[0]);
      m_sockaddr = new struct sockaddr_in;
      m_sockaddr->sin_family = AF_INET;
      m_sockaddr->sin_port = htons( m_port );
      //inet_aton(inet_ntoa(*p_in_addr),m_sockaddr->sin_addr.s_addr);
      m_sockaddr->sin_addr.s_addr = p_in_addr->s_addr;
      //m_sockaddr->sin_addr.s_addr = inet_addr(inet_ntoa(*p_in_addr));
   }
   return m_sockaddr;
}

const struct sockaddr*
RemoteServer::sockaddr() const
{
   return (const struct sockaddr*)sockaddr_in();
}

socklen_t
RemoteServer::addrlen() const
{
   return (sizeof(*sockaddr_in()));
}

string
RemoteServer::name() const
{
   return m_address;
}

int
RemoteServer::port() const
{
   return m_port;
}

int
RemoteServer::set_fd( fd_set* fd_bitmap, SocketBase::StateType s ) const
{
   SocketBase*  pSocket = socket();
   return pSocket->set_fd( fd_bitmap, s );
}

bool
RemoteServer::isset_fd( const fd_set* fd_bitmap, SocketBase::StateType s )
   const
{
   SocketBase*  pSocket = socket();
   return pSocket->isset_fd( fd_bitmap, s );
}

void
RemoteServer::flushSocket() const
{
   socket()->flush();
}

void
RemoteServer::contact( const Message& msg ,
                       Response& response ,
                       RemoteServerReturn& retval )
{
   sendTo(msg,retval);
   if ( RemoteServerReturn::kTimeout == retval.errorCode() ) return;
   retval.reset();
   // This is a blocking read until the connection terminates.
   // In general, this is NOT what is desired.
   while ( retval.returnCode() != RemoteServerReturn::kSuccess )
   {
      receiveFrom(response,retval);
      if ( RemoteServerReturn::kTimeout == retval.errorCode() ) return;
   }
}

void
RemoteServer::sendTo( const Message& msg ,
                      RemoteServerReturn& retval ) const
{
   SocketBase*  pSocket = socket();
   pSocket->writeTo( msg );
   retval.setReturnCode( RemoteServerReturn::kSuccess );
}

size_t
RemoteServer::receiveFrom( Response& response ,
                           RemoteServerReturn& retval ,
                           size_t length )
{
   const SocketBase*  pSocket = socket();
   size_t to_read = 0;
   try
   {
      to_read = pSocket->readAll( response, length );
   }
   catch ( QSESocketBaseSocketClosed& e )
   {
      retval.setReturnCode( RemoteServerReturn::kSuccess );
      closeSocket();
   }
   updateTime(retval);
   if ( ! checkTimeout(retval) )
   {
      retval.setErrorCode(RemoteServerReturn::kTimeout);
   }
   return to_read;
}

bool
RemoteServer::checkTimeout( const RemoteServerReturn& retval ) const
{
   if ( 0 == m_timeout )
   {
      return true;
   }

   struct timeval elapsed = retval.elapsed();
   if ( elapsed.tv_sec > m_timeout->tv_sec ) return false;
   if ( elapsed.tv_sec < m_timeout->tv_sec ) return true;
   if ( elapsed.tv_usec >= m_timeout->tv_usec ) return false;
   return true;
}

void
RemoteServer::updateTime( RemoteServerReturn& retval ) const
{
   struct timeval currentTime;
   gettimeofday( &currentTime, 0 );
   retval.updateTime(currentTime);
}

SocketBase*
RemoteServer::socket() const
{
   if ( 0 == m_socket )
   {
      m_socket = m_socketBuilder();
      m_socket->connect( *this );
   }
   return m_socket;
}

void
RemoteServer::closeSocket()
{
   if ( 0 != m_socket )
   {
      delete m_socket;
      m_socket = 0;
   }
}


bool
AsynchronousRemoteServer::checkTimeout(
   const RemoteServerReturn& retval ) const
{
   return true;
}

void
AsynchronousRemoteServer::updateTime( RemoteServerReturn& retval ) const
{
   return;
}


//--------- Exceptions ---------//

void
QSERemoteServer::derivedMsg() const
{
   cerr << "RemoteServer -- ";
   errMsg();
}

void
QSERemoteServerGethostbynameFailed::errMsg() const
{
   cerr << "gethostbyname( " << server()->name() << " ) failed";
}

---