DelegateRequestDistributor.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: DelegateRequestDistributor.cc,v 1.3 2004/05/19 15:56:52 mmarsh Exp $
//
// $Log: DelegateRequestDistributor.cc,v $
// Revision 1.3  2004/05/19 15:56:52  mmarsh
// *** empty log message ***
//
// Revision 1.2  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 "DelegateRequestDistributor.h"
#include "CODEX_Server/BroadcastRequestEvent.h"
#include "ClientResponseEvent.h"
#include "ClientActivity.h"
#include "LabeledReadKeyMsg.h"
#include "CODEX_Server/ServerState.h"
#include "StateInfo.h"

#include "ClientCreateCallback.h"
#include "ClientWriteCallback.h"
#include "ClientReadCallback.h"

#include "timing.h"

using namespace CODEX_KeyService;

DelegateRequestDistributor::DelegateRequestDistributor(
   CODEX_Events::DeadPileType& deadPile,
   CODEX_Events::QType& eventQueue,
   CODEX_Server::BroadcastRequestHandler* destination,
   CODEX_Server::SignRequestHandler* srHandler ) :
   CODEX_Events::Activity( deadPile, eventQueue ),
   m_destination( destination ),
   m_srHandler( srHandler )
{
}

bool
DelegateRequestDistributor::handler( CODEX_Events::CloseEvent& event )
{
   // We only consume close events.
   sendEvent( 0, event.source() );
   return true;
}

bool
DelegateRequestDistributor::handler(
   ClientMessageEvent< RequestKeyMsg >& event )
{
   // We should be able to handle this message here.
   CODEX_Server::ServerState* serverState =
      CODEX_Server::ServerState::instance();
   StateInfo* stateInfo = StateInfo::instance();
   if ( ( NULL != serverState ) &&
        ( NULL != stateInfo ) )
   {
      const CODEX_Server::SignedAugmentedEGPublicKey& pkMsg =
         serverState->signedEGKey();
      if ( pkMsg.initialized() )
      {
         ClientActivity* ca = stateInfo->getClient( event.source() );
         if ( NULL != ca )
         {
            typedef
               ClientResponseEvent< CODEX_Server::SignedAugmentedEGPublicKey >
               EvtType;
            EvtType* outEvt = new EvtType(this,ca,pkMsg);
            sendEvent( outEvt, event.source() );
            return true;
         }
      }
   }
   sendEvent( 0, event.source() );
   return true;
}

bool
DelegateRequestDistributor::handler(
   ClientMessageEvent< SignedCreateKeyMsg >& event )
{
#ifdef TIMING
   ActiveTimer.start();
#endif
   CODEX_Server::ServerState* serverState =
      CODEX_Server::ServerState::instance();
   if ( NULL == serverState )
   {
      sendEvent( 0, event.source(), true ); // NACK
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return true;
   }

   StateInfo* stateInfo = StateInfo::instance();
   if ( NULL == stateInfo )
   {
      sendEvent( 0, event.source(), true ); // NACK
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return true;
   }

   ClientActivity* ca = stateInfo->getClient( event.source() );
   if ( NULL == ca )
   {
      sendEvent( 0, event.source(), true ); // NACK
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return true;
   }
   const unsigned char* seqNum = serverState->newSequenceNumber();
   stateInfo->registerSequenceNumber( seqNum, ca );
   ClientCreateCallback* cb = new ClientCreateCallback( m_deadPile,
                                                        m_queue,
                                                        m_srHandler,
                                                        ca,
                                                        event.message(),
                                                        seqNum );
   CODEX_Quorum::Message message;

   // Set the server ID, with "outgoing" mask.
   unsigned char self = serverState->hostNum();
   message.fill( self | CODEX_Server::ServerState::OutgoingMask );

   // Set the unique request ID.
   message.fill( seqNum, CODEX_Server::ServerState::nMID );

   // Set the message domain.
   message.fill( stateInfo->messageDomain() );

   // Set the message type.
   message.fill( CODEX_Client::kCreateKeyMsg | CODEX_Client::SignatureMask );

   // Marshal the request.
   int length = event.message().marshal(0);
   unsigned char* buffer = new unsigned char[length];
   unsigned char* pBuffer = buffer;
   event.message().marshal(&pBuffer);
   message.fill( buffer, length );
   delete [] buffer;

   // Create the outgoing event.
   CODEX_Server::BroadcastRequestEvent* evt =
      new CODEX_Server::BroadcastRequestEvent( this,
                                               m_destination,
                                               message,
                                               cb );
   sendEvent( evt, event.source() );
#ifdef TIMING
   ActiveTimer.stop();
#endif
   return true;
}

bool
DelegateRequestDistributor::handler(
   ClientMessageEvent< SignedWriteKeyMsg >& event )
{
#ifdef TIMING
   ActiveTimer.start();
#endif
   CODEX_Server::ServerState* serverState =
      CODEX_Server::ServerState::instance();
   if ( NULL == serverState )
   {
      sendEvent( 0, event.source(), true ); // NACK
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return true;
   }

   StateInfo* stateInfo = StateInfo::instance();
   if ( NULL == stateInfo )
   {
      sendEvent( 0, event.source(), true ); // NACK
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return true;
   }

   ClientActivity* ca = stateInfo->getClient( event.source() );
   if ( NULL == ca )
   {
      sendEvent( 0, event.source(), true ); // NACK
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return true;
   }
   const unsigned char* seqNum = serverState->newSequenceNumber();
   stateInfo->registerSequenceNumber( seqNum, ca );
   ClientWriteCallback* cb = new ClientWriteCallback( m_deadPile,
                                                      m_queue,
                                                      m_srHandler,
                                                      ca,
                                                      event.message(),
                                                      seqNum );
   CODEX_Quorum::Message message;

   // Set the server ID, with "outgoing" mask.
   unsigned char self = serverState->hostNum();
   message.fill( self | CODEX_Server::ServerState::OutgoingMask );

   // Set the unique request ID.
   message.fill( seqNum, CODEX_Server::ServerState::nMID );

   // Set the message domain.
   message.fill( stateInfo->messageDomain() );

   // Set the message type.
   message.fill( CODEX_Client::kWriteKeyMsg | CODEX_Client::SignatureMask );

   // Marshal the request.
   int length = event.message().marshal(0);
   unsigned char* buffer = new unsigned char[length];
   unsigned char* pBuffer = buffer;
   event.message().marshal(&pBuffer);
   message.fill( buffer, length );
   delete [] buffer;

   // Create the outgoing event.
   CODEX_Server::BroadcastRequestEvent* evt =
      new CODEX_Server::BroadcastRequestEvent( this,
                                               m_destination,
                                               message,
                                               cb );
   sendEvent( evt, event.source() );
#ifdef TIMING
   ActiveTimer.stop();
#endif
   return true;
}

bool
DelegateRequestDistributor::handler(
   ClientMessageEvent< SignedReadKeyMsg >& event )
{
#ifdef TIMING
   ActiveTimer.start();
#endif
   CODEX_Server::ServerState* serverState =
      CODEX_Server::ServerState::instance();
   if ( NULL == serverState )
   {
      sendEvent( 0, event.source(), true ); // NACK
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return true;
   }

   StateInfo* stateInfo = StateInfo::instance();
   if ( NULL == stateInfo )
   {
      sendEvent( 0, event.source(), true ); // NACK
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return true;
   }

   ClientActivity* ca = stateInfo->getClient( event.source() );
   if ( NULL == ca )
   {
      sendEvent( 0, event.source(), true ); // NACK
#ifdef TIMING
      ActiveTimer.stop();
#endif
      return true;
   }
   const unsigned char* seqNum = serverState->newSequenceNumber();
   stateInfo->registerSequenceNumber( seqNum, ca );
   const StateInfo::LSType::LabelType& label =
      stateInfo->defaultDecryptionLabel();
   LabeledReadKeyMsg rkm( event.message(), label );
   ClientReadCallback* cb = new ClientReadCallback( m_deadPile,
                                                    m_queue,
                                                    m_srHandler,
                                                    ca,
                                                    rkm,
                                                    seqNum,
                                                    m_destination );
   CODEX_Quorum::Message message;

   // Set the server ID, with "outgoing" mask.
   unsigned char self = serverState->hostNum();
   message.fill( self | CODEX_Server::ServerState::OutgoingMask );

   // Set the unique request ID.
   message.fill( seqNum, CODEX_Server::ServerState::nMID );

   // Set the message domain.
   message.fill( stateInfo->messageDomain() );

   // Set the message type.
   message.fill( CODEX_Client::kReadKeyMsg | CODEX_Client::SignatureMask );

   // Marshal the request.
   int length = rkm.marshal(0);
   unsigned char* buffer = new unsigned char[length];
   unsigned char* pBuffer = buffer;
   rkm.marshal(&pBuffer);
   message.fill( buffer, length );
   delete [] buffer;

   // Create the outgoing event.
   CODEX_Server::BroadcastRequestEvent* evt =
      new CODEX_Server::BroadcastRequestEvent( this,
                                               m_destination,
                                               message,
                                               cb );
   sendEvent( evt, event.source() );
#ifdef TIMING
   ActiveTimer.stop();
#endif
   return true;
}

---