---

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

#include <vector>

#include "ShareLabelChallengeHandler.h"
#include "ShareLabelChallengeEvent.h"
#include "ServerState.h"
#include "ShareLabelChallenge.h"

using namespace CODEX_Server;

ShareLabelChallengeHandler::ShareLabelChallengeHandler(
   CODEX_Events::DeadPileType& deadPile,
   CODEX_Events::QType& eventQueue ) :
   CODEX_Events::Activity( deadPile, eventQueue )
{
   sendEvent( new ShareLabelChallengeEvent( this, this ), 0 );
}

bool
ShareLabelChallengeHandler::handler( ShareLabelChallengeEvent& event )
{
   ServerState* serverState = ServerState::instance();
   if ( 0 == serverState )
   {
      return false;
   }

   typedef vector< const unsigned char* >  SVec;

   SVec completed;

   // Loop over all challenged requests.
   ServerState::ChallengeMap::const_iterator cItr =
      serverState->challengeMap().begin();
   ServerState::ChallengeMap::const_iterator cEnd =
      serverState->challengeMap().end();
   for ( ; cItr != cEnd ; ++cItr )
   {

      // Loop over the challenges to this request.  This is done in
      // reverse order, since later challenges are more likely to contain
      // a currently valid label.
      ServerState::ChallengeVector::const_reverse_iterator vItr =
         cItr->second.rbegin();
      ServerState::ChallengeVector::const_reverse_iterator vEnd =
         cItr->second.rend();
      for ( ; vItr != vEnd ; ++vItr )
      {
         // Get the challenge object.
         ShareLabelChallenge* slc = *vItr;
         try
         {
            // If the shares are available for this label, we must have
            // received valid shares for the label.  An exception will be
            // thrown if the label is not yet known.
            //
            // From an efficiency standpoint this is not ideal, since we
            // have to invoke the exception mechanism for what will likely
            // be a somewhat common occurrence, especially in a well-exercised
            // system.
            bool haveLabel = false;

            try
            {
               serverState->rsaShares( slc->label(), slc->challenger() );
               haveLabel = true;
            }
            catch ( InvalidLabelException& )
            {
            }
            catch ( ... )
            {
               haveLabel = true;
            }

            try
            {
               serverState->elgamalShares( slc->label(), slc->challenger() );
               haveLabel = true;
            }
            catch ( InvalidLabelException& )
            {
            }
            catch ( ... )
            {
               haveLabel = true;
            }

            if ( ! haveLabel )
            {
               continue;
            }

            // An exception was not thrown, so it must be OK to send the
            // event re-issuing the request with the new label.
            sendEvent( slc->event(), event.source() );

            // Now clear the current entry, which prevents freeing memory
            // in use.
            slc->zeroData();

            // Mark this request challenge as having been completed so that
            // the challenge can be cleaned up.
            completed.push_back( cItr->first );

            // Finally, break out of the inner loop and look at the next
            // challenged request, if any.
            break;
         }
         catch ( ... )
         {
            // Exceptions are not error here -- just keep going.
         }
      }

   }

   // Loop over the completed challenges, cleaning them up.
   SVec::iterator sItr = completed.begin();
   SVec::iterator sEnd = completed.end();
   for ( ; sItr != sEnd ; ++sItr )
   {
      serverState->removeChallenge( *sItr );
   }

   return false;
}

---