ClientActivity.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: ClientActivity.cc,v 1.4 2004/05/19 15:56:50 mmarsh Exp $
//
// $Log: ClientActivity.cc,v $
// Revision 1.4  2004/05/19 15:56:50  mmarsh
// *** empty log message ***
//
// Revision 1.3  2003/11/04 22:15:00  mmarsh
// General code cleanup and reorganization.  The signed ElGamal public key
// was moved to CODEX_Server, decoupling that package from CODEX_Client.
// Since CODEX_Server no longer knows about the cryptosystem used by
// the client, switching between cryptosystems is handled locally by
// CODEX_KeyService.
//
//

#include "ClientActivity.h"
#include "ClientMessageEvent.h"
#include "ClientMessageHandler.h"
#include "StateInfo.h"
#include "CODEX_Quorum/Socket.h"
#include "CODEX_Quorum/Message.h"

#include "CODEX_Quorum/QSExceptions.h"
#include "CODEX_Ciphers/CipherExceptions.h"

using namespace CODEX_KeyService;
using CODEX_Quorum::SocketBuilder;

ClientActivity::ClientActivity( int port,
                                const SocketBuilder& socketBuilder,
                                DeadPileType& deadPile,
                                QType& eventQueue,
                                ClientMessageHandler* destination,
                                CODEX_Quorum::SocketBase* socket ) :
   Activity( deadPile, eventQueue ),
   LocalServer( port, socketBuilder ),
#ifdef TIMING
   m_timer( 0 ),
#endif
   m_destination( destination ),
   m_bufferToRead( 0 ),
   m_buffer( 0 )
{
   setSocket( socket );
   StateInfo::instance()->addClient( this );
   CODEX_Server::ServerState::instance()->addServer( this );
}

ClientActivity::~ClientActivity()
{
   StateInfo::instance()->removeClient( this );
   CODEX_Server::ServerState::instance()->removeServer( this );
   if ( 0 != m_buffer ) delete m_buffer;
#ifdef TIMING
   if ( 0 != m_timer ) delete m_timer;
   ActiveTimer.clear();
   OneWayTimer.clear();
   SSLTimer.clear();
   SignTimer.clear();
   SignVerifyTimer.clear();
   PartialSigTimer.clear();
   PartialDecTimer.clear();
   PartialRSADecTimer.clear();
   ThresholdSigTimer.clear();
   ThresholdDecTimer.clear();
   LookupTimer.clear();
   SchnorrTimer.clear();
   DLProofTimer.clear();
   DLProofVerifyTimer.clear();
   RSAPPKTimer.clear();
#endif
}

void
ClientActivity::processRequest( CODEX_Quorum::SocketBase::StateType s )
{
   try
   {
      switch( s )
      {
         case CODEX_Quorum::SocketBase::kRead :
            if ( 0 == m_buffer )
            {
               m_bufferToRead = 0;
               m_buffer = new CODEX_Quorum::Message;
            }
            m_bufferToRead = socket()->readAll( *m_buffer, m_bufferToRead );
            if ( 0 == m_bufferToRead )
            {
               // Determine the message type, unmarshal it, and dispatch it
               // to the appropriate handler.
               const unsigned char* buff = m_buffer->buffer();
               long buffLength = m_buffer->length();
               unsigned char* pBuff = (unsigned char*) (buff+1);
               ClientMessageEventBase* evt = 0;
               switch( buff[0] )
               {
                  using namespace CODEX_Client;
                  case kRequestKeyMsg :
                     evt = new ClientMessageEvent< RequestKeyMsg >(
                        this, m_destination );
                     break;
                  case (CODEX_Client::kCreateKeyMsg |
                        CODEX_Client::SignatureMask) :
                     evt = new ClientMessageEvent< SignedCreateKeyMsg >(
                        this, m_destination );
#ifdef TIMING
                     m_timer = new Timer("codex_create");
                     m_timer->start();
#endif
                     break;
                  case (CODEX_Client::kWriteKeyMsg |
                        CODEX_Client::SignatureMask) :
                     evt = new ClientMessageEvent< SignedWriteKeyMsg >(
                        this, m_destination );
#ifdef TIMING
                     m_timer = new Timer("codex_write");
                     m_timer->start();
#endif
                     break;
                  case (CODEX_Client::kReadKeyMsg |
                        CODEX_Client::SignatureMask) :
                     evt = new ClientMessageEvent< SignedReadKeyMsg >(
                        this, m_destination );
#ifdef TIMING
                     m_timer = new Timer("codex_read");
                     m_timer->start();
#endif
                     break;
                  default :
                     // Bad message type for a client request -- drop it.
                     cerr << "Bad message type: "
                          << (unsigned int)buff[0]
                          << endl;
                     break;
               }
               if ( 0 != evt )
               {
                  if ( evt->unmarshal( &pBuff, buffLength ) )
                  {
                     // Enqueue the event.
                     sendEvent( evt, 0 );
                  }
                  else
                  {
                     // Bad message format -- drop it.
                     delete evt;
                  }
               }

               // Finally, clean up the buffer.
               delete m_buffer;
               m_buffer = 0;
            }
            break;
         case CODEX_Quorum::SocketBase::kWrite :
            break;
      }
   }
   catch ( ... )
   {
      // For any exception our action is the same -- close the Activity
      sendEvent( new CODEX_Events::CloseEvent(this,m_destination), 0 );
      enableTerminate();
      // re-throw the exception so that we can detect the error
      throw;
   }
}

bool
ClientActivity::handler( CODEX_Events::EventAck& event )
{
   if ( event.failure() )
   {
      sendEvent( new CODEX_Events::CloseEvent(this,m_destination), 0 );
      enableTerminate();
   }
   return this->CODEX_Events::Activity::handler( event );
}

bool
ClientActivity::handler( CODEX_Events::CloseEvent& event )
{
   sendEvent( new CODEX_Events::CloseEvent(this,m_destination),
              event.source() );
   enableTerminate();
   return true;
}

bool
ClientActivity::handler( ClientResponseEvent< SignedPublicKeyMsg >& event )
{
   try
   {
      respond( event.message(),
               ( CODEX_Client::kPublicKeyMsg | CODEX_Client::SignatureMask ) );
      if ( event.acknowledge() )
      {
         sendEvent( 0, event.source() );
      }
      return true;
   }
   catch ( ... )
   {
      // For any exception our action is the same -- close the Activity
      sendEvent( new CODEX_Events::CloseEvent(this,m_destination), 0 );
      enableTerminate();
      // re-throw the exception so that we can detect the error
      throw;
   }
}

bool
ClientActivity::handler( ClientResponseEvent< SignedBoundNameMsg >& event )
{
   try
   {
      respond( event.message(),
               ( CODEX_Client::kBoundNameMsg | CODEX_Client::SignatureMask ) );
      if ( event.acknowledge() )
      {
         sendEvent( 0, event.source() );
      }
      return true;
   }
   catch ( ... )
   {
      // For any exception our action is the same -- close the Activity
      sendEvent( new CODEX_Events::CloseEvent(this,m_destination), 0 );
      enableTerminate();
      // re-throw the exception so that we can detect the error
      throw;
   }
}

bool
ClientActivity::handler( ClientResponseEvent< SignedKeyStoredMsg >& event )
{
   try
   {
      respond( event.message(),
               ( CODEX_Client::kKeyStoredMsg | CODEX_Client::SignatureMask ) );
      if ( event.acknowledge() )
      {
         sendEvent( 0, event.source() );
      }
      return true;
   }
   catch ( ... )
   {
      // For any exception our action is the same -- close the Activity
      sendEvent( new CODEX_Events::CloseEvent(this,m_destination), 0 );
      enableTerminate();
      // re-throw the exception so that we can detect the error
      throw;
   }
}

bool
ClientActivity::handler( ClientResponseEvent< SignedBlindKeyMsg >& event )
{
   try
   {
      respond( event.message(),
               ( CODEX_Client::kBlindKeyMsg | CODEX_Client::SignatureMask ) );
      if ( event.acknowledge() )
      {
         sendEvent( 0, event.source() );
      }
      return true;
   }
   catch ( ... )
   {
      // For any exception our action is the same -- close the Activity
      sendEvent( new CODEX_Events::CloseEvent(this,m_destination), 0 );
      enableTerminate();
      // re-throw the exception so that we can detect the error
      throw;
   }
   return true;
}

void
ClientActivity::close()
{
   sendEvent( new CODEX_Events::CloseEvent( this, this ), 0 );
}

void
ClientActivity::respond( const CODEX_ASN1::Base& message, unsigned char mtype )
{
#ifdef TIMING
   ActiveTimer.start();
#endif
   int length = message.marshal(0) + 1;
   unsigned char* buff = new unsigned char[length];
   buff[0] = mtype;
   unsigned char* pBuff = buff+1;
   message.marshal(&pBuff);
   socket()->writeTo( CODEX_Quorum::Message( buff, length ) );
   delete [] buff;
#ifdef TIMING
   ActiveTimer.stop();
   if ( 0 != m_timer )
   {
      m_timer->stop();
      m_timer->print(cout);
      ActiveTimer.print(cout);
      OneWayTimer.print(cout);
      SSLTimer.print(cout);
      SignTimer.print(cout);
      SignVerifyTimer.print(cout);
      PartialSigTimer.print(cout);
      PartialDecTimer.print(cout);
      PartialRSADecTimer.print(cout);
      ThresholdSigTimer.print(cout);
      ThresholdDecTimer.print(cout);
      LookupTimer.print(cout);
      SchnorrTimer.print(cout);
      DLProofTimer.print(cout);
      DLProofVerifyTimer.print(cout);
      RSAPPKTimer.print(cout);
   }

   if ( 0 != m_timer )
   {
      delete m_timer;
      m_timer = 0;
   }
   ActiveTimer.clear();
   OneWayTimer.clear();
   SSLTimer.clear();
   SignTimer.clear();
   SignVerifyTimer.clear();
   PartialSigTimer.clear();
   PartialDecTimer.clear();
   PartialRSADecTimer.clear();
   ThresholdSigTimer.clear();
   ThresholdDecTimer.clear();
   LookupTimer.clear();
   SchnorrTimer.clear();
   DLProofTimer.clear();
   DLProofVerifyTimer.clear();
   RSAPPKTimer.clear();
#endif
}

---