---

RecoverCallback.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: RecoverCallback.cc,v 1.3 2004/05/19 15:56:24 mmarsh Exp $
//
// $Log: RecoverCallback.cc,v $
// Revision 1.3  2004/05/19 15:56:24  mmarsh
// Added copyright and license statements.
//
// Revision 1.2  2003/11/04 22:31:45  mmarsh
// *** empty log message ***
//
//

#include "RecoverCallback.h"
#include "Message.h"
#include "Types.h"
#include "StateInfo.h"
#include "CODEX_Server/ServerState.h"

using namespace CODEX_APSS;

RecoverCallback::RecoverCallback( unsigned int version,
                                  const SublabelType& label ) :
   m_version( version ),
   m_label( label ),
   m_completed( false )
{
}

RecoverCallback::~RecoverCallback()
{
   // Whether recovery was successful or not, we need to clean up.
   StateInfo::instance()->markRecovered( m_label );
}

bool
RecoverCallback::operator()( unsigned int server, CODEX_Quorum::Message* msg )
{
   if ( m_completed )
   {
      if ( 0 != msg ) delete msg;
      return true;
   }

   if ( 0 == msg )
   {
      return false;
   }

   CODEX_Server::ServerState* serverState =
      CODEX_Server::ServerState::instance();
   if ( 0 == serverState )
   {
      delete msg;
      return false;
   }

   StateInfo* stateInfo = StateInfo::instance();
   if ( 0 == stateInfo )
   {
      delete msg;
      return false;
   }

   // Unmarshal the message.
   unsigned char* data = (unsigned char*)msg->buffer();
   int length = msg->length();

   if ( length < 2 )
   {
      delete msg;
      return false;
   }

   if ( stateInfo->domain() != data[0] )
   {
      delete msg;
      return false;
   }
   ++data;
   --length;

   if ( ( kRecoveredMsg | SignatureMask ) != data[0] )
   {
      delete msg;
      return false;
   }
   ++data;
   --length;

   SignedRecoveredMsg signedResponse;
   if ( 0 == signedResponse.unmarshal( 0, &data, length ) )
   {
      delete msg;
      return false;
   }
   delete msg;

   // Make sure the response is valid.  We ignore the "responder" field.
   const RecoveredMsg& response = signedResponse.message();
   unsigned int srVersion = response.version().value();
   if ( srVersion != m_version )
   {
      return false;
   }

   if ( response.requester().value() != serverState->hostNum() )
   {
      return false;
   }

   if ( response.sublabel() != m_label )
   {
      return false;
   }

   // Check the signature.
   BIGNUM * digest = 0;
   try
   {
      digest = response.digest( serverState->hashFunc() );
      if ( 0 == digest )
      {
         throw CODEX_Exceptions::BignumNullException( __FILE__ , __LINE__ );
      }
      if ( ! serverState->publicKey(server).verifySignature(
         signedResponse.signature(),
         digest ) )
      {
         throw CODEX_Server::SignatureVerificationFailedException( __FILE__ ,
                                                                   __LINE__ );
      }
      BN_free(digest);
   }
   catch ( ... )
   {
      if ( 0 != digest ) BN_free(digest);
      return false;
   }

   // Check the validity of the subshares returned.
   unsigned int num = m_label.label().num().value();
   OneWay oneWay( stateInfo->witness(num).args() );
   if ( ! m_label.check( response.shares(), oneWay ) )
   {
      return false;
   }

   // Store these subshares.
   stateInfo->addSubsharing( m_label, response.shares() );

   // Check whether all subshares are now present.
   unsigned int self = serverState->hostNum();
   bool haveAll = true;
   const ShareSetType& subsharing =
      stateInfo->subsharing( m_label, self );
   for ( unsigned int i = 0 ; i < ShareType::NumShares ; ++i )
   {
      if ( subsharing.shouldHave( i, self ) &&
           (!subsharing(i).initialized()) )
      {
         haveAll = false;
         break;
      }
   }
   if ( haveAll )
   {
      // That's all we need to do.
      stateInfo->markRecovered( m_label );
      m_completed = true;
   }
   return true;
}

---