QuorumBuilderAct.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: QuorumBuilderAct.cc,v 1.3 2004/05/19 15:56:58 mmarsh Exp $
//
// $Log: QuorumBuilderAct.cc,v $
// Revision 1.3  2004/05/19 15:56:58  mmarsh
// *** empty log message ***
//
// Revision 1.2  2003/11/04 22:31:51  mmarsh
// *** empty log message ***
//
//

#include "QuorumBuilderAct.h"
#include "QuorumBuilderEvent.h"
#include "QuorumBuilderExpectNonceEvent.h"

#include "CODEX_ASN1/Integer.h"
#include "CODEX_Exceptions/BignumExceptions.h"
#include "ServerExceptions.h"

using namespace CODEX_Server;

QuorumBuilderAct::QuorumBuilderAct( CODEX_Events::DeadPileType& deadPile,
                                    CODEX_Events::QType& eventQueue ) :
   CODEX_Events::Activity( deadPile, eventQueue )
{
   sendEvent( new QuorumBuilderEvent(this), 0 );
   for ( unsigned int i = 0 ; i < ServerState::nServers ; ++i )
   {
      m_pending[i] = NULL;
   }
}

QuorumBuilderAct::~QuorumBuilderAct()
{
   for ( unsigned int i = 0 ; i < ServerState::nServers ; ++i )
   {
      if ( NULL != m_pending[i] )
      {
         delete m_pending[i];
      }
   }
}

bool
QuorumBuilderAct::handler( QuorumBuilderEvent& event )
{
   ServerState* serverState = ServerState::instance();
   if ( NULL == serverState )
   {
      // something's seriously wrong
      return true;
   }

   // Only attempt to connect to one missing server, which will keep
   // this somewhat lighter-weight.  Attempts are only made to
   // higher-numbered servers.
   for ( unsigned int i = 0 ; i < ServerState::nServers ; ++i )
   {
      // We want to start one host *after* the last one we tried.  This
      // will place the last attempt at the end of the list, so it will
      // only be tried if none of the others is missing.
      unsigned int hostNum =
         ( i + event.lastAttempt() + 1 ) % ServerState::nServers;
      if ( ( hostNum > serverState->hostNum() ) &&
           ( ! serverState->haveQuorumServer( hostNum ) ) &&
           ( NULL == m_pending[ hostNum ] ) )
      {
         // try to connect
         RSType* ars = NULL;
         try
         {
            ars = new RSType( serverState->hostName(hostNum),
                              serverState->serverPort(hostNum),
                              serverState->serverOutSocketBuilder() );
//            fd_set bogus;
//            ars->set_fd( &bogus, CODEX_Quorum::SocketBase::kRead );
//            ars->socket();
            m_pending[ hostNum ] = ars;
            sendEvent( new QuorumBuilderExpectNonceEvent(this,hostNum),
                       0 );
         }
         catch ( ... )
         {
            if ( NULL != ars ) delete ars;
         }
         event.setLastAttempt( hostNum );
         return false;
      }
   }
   // No attempts were made this time through.
   return false;
}

bool
QuorumBuilderAct::handler( QuorumBuilderExpectNonceEvent& event )
{
   ServerState* serverState = ServerState::instance();
   if ( NULL == serverState )
   {
      // something's seriously wrong
      return true;
   }

   // Wait until there's a nonce to read.
   RSType* ars = m_pending[ event.hostNum() ];
   if ( NULL == ars )
   {
      return true;
   }
   try
   {
      fd_set read_set;
      FD_ZERO(&read_set);
      int s = ars->set_fd(&read_set,CODEX_Quorum::SocketBase::kRead);
      struct timeval tv;
      tv.tv_sec = 0;
      tv.tv_usec = 0;
      if ( ( 0 <= select( s+1, &read_set, NULL, NULL, &tv ) ) && 
           ( ars->isset_fd( &read_set, CODEX_Quorum::SocketBase::kRead ) ) )
      {
         if ( event.read( ars ) )
         {
            // Get the data
            unsigned char* buffer = (unsigned char*)event.buffer().buffer();
            unsigned char* pBuffer = buffer;
            int length = event.buffer().length();

            // Unmarshal the nonce
            CODEX_ASN1::BigNumber bn;
            if ( NULL == bn.unmarshal(NULL,&pBuffer,length) )
            {
               throw 0;
            }

            // Construct the response, which is the local host number and nonce
            CODEX_ASN1::Integer iHost( serverState->hostNum() );
            length = iHost.marshal(0);
            length += bn.marshal(0);
            buffer = new unsigned char[ length ];
            pBuffer = buffer;
            iHost.marshal(&pBuffer);
            bn.marshal(&pBuffer);
            CODEX_Quorum::Message msg(buffer,length);

            // Now prepare to sign the response
            CODEX_ASN1::ustring* str = NULL;
            try
            {
               str =
                  serverState->hashFunc()(CODEX_ASN1::ustring(buffer,length));
            }
            catch ( ... )
            {
               if ( NULL != str ) delete str;
               delete [] buffer;
               throw;
            }
            delete [] buffer;
            BIGNUM * digest = NULL;
            digest = BN_new();
            if ( NULL == digest )
            {
               delete str;
               throw CODEX_Exceptions::BignumNullException( __FILE__ ,
                                                            __LINE__ );
            }
            if ( ! BN_bin2bn( str->data(), str->length(), digest ) )
            {
               delete str;
               BN_free( digest );
               throw CODEX_Exceptions::BignumBin2BNException( __FILE__ ,
                                                              __LINE__ );
            }
            delete str;

            // Sign the message
            const CODEX_Ciphers::RSAPrivateKey& key =
               serverState->privateKey();
            if ( ! key.initialized() )
            {
               BN_free( digest );
               throw PublicKeyNotFoundException( __FILE__ , __LINE__ );
            }
            CODEX_Ciphers::RSASignature* signature = NULL;
            try
            {
               signature = key.sign(digest);
            }
            catch ( ... )
            {
               BN_free( digest );
               throw;
            }
            BN_free( digest );

            // Append the signature
            length = signature->marshal(0);
            buffer = new unsigned char[ length ];
            pBuffer = buffer;
            signature->marshal(&pBuffer);
            msg.fill(buffer,length);
            delete [] buffer;
            delete signature;

            // Now send and register the remote server with the quorum system
            CODEX_Quorum::RemoteServerReturn r;
            ars->sendTo(msg,r);
            m_pending[ event.hostNum() ] = NULL;
            serverState->addQuorumServer( event.hostNum(), ars );
            cout << "Connected to server " << event.hostNum() << endl;
            return true;
         }
      }
   }
   catch ( ... )
   {
      if ( NULL != ars ) delete ars;
      m_pending[ event.hostNum() ] = NULL;
      return true;
   }
   return false;
}

---