ClientReadCallback.h

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

#ifndef __CODEX_KEYSERVICE_CLIENTREADCALLBACK_H__
#define __CODEX_KEYSERVICE_CLIENTREADCALLBACK_H__

#include <map>

#include "ResponseCallback.h"
#include "CODEX_Events/Activity.h"
#include "CODEX_ASN1/Array.h"
#include "CODEX_ASN1/BigNumber.h"
#include "CODEX_Client/Message.h"
#include "LabeledReadKeyMsg.h"
#include "CODEX_Server/ServerSignature.h"
#include "CODEX_Server/SignRequestHandler.h"
#include "ClientResponseHandler.h"
#include "StateInfo.h"
#include "CODEX_Server/BroadcastRequestHandler.h"

#ifdef ELGAMAL
#include "CODEX_ThresholdCrypto/DLProof.h"
#endif

namespace CODEX_KeyService
{
   class ClientReadCallback : public ResponseCallback,
                              public CODEX_Events::Activity
   {
      private :
         typedef CODEX_ASN1::BigNumber BigNumber;

         struct BN_less :
            public binary_function<const BigNumber&, const BigNumber&, bool>
         {
               bool operator()( const BigNumber& __x,
                                const BigNumber& __y ) const
               {
                  return BN_cmp( __x.value() , __y.value() ) < 0;
               }
         };

      public :
         typedef CODEX_ASN1::Array< CODEX_Server::ServerSignature >
         ServerArray;

         typedef CODEX_Server::ServerState::ShareType  ShareType;

         typedef CODEX_Server::ServerState::ShareSetType  ShareSetType;

         typedef CODEX_Client::CipherTextType  CipherTextType;

         typedef CODEX_Client::BlindCipherTextType  BlindCipherTextType;

         typedef CODEX_Client::BlindPlainTextType  BlindPlainTextType;

         static const unsigned int NumShares = ShareType::NumShares;

#ifndef ELGAMAL

         typedef vector< ShareType* > PartialArray;
#else

         typedef ShareSetType  PartialArray;

         typedef vector< CODEX_ThresholdCrypto::DLProof > ProofArray;

         typedef map< CipherTextType , ProofArray > ProofMap;

         typedef map< CipherTextType , unsigned int > RespMap;
#endif

         typedef map< BlindCipherTextType , PartialArray > PartialMap;

         typedef map< BlindCipherTextType , BIGNUM* > DigestMap;

         typedef map< BlindCipherTextType , ServerArray > EvidenceMap;

         typedef CODEX_Server::ServerState::ChallengeVector  ChallengeVector;

         ClientReadCallback(
            CODEX_Events::DeadPileType& deadPile,
            CODEX_Events::QType& eventQueue,
            CODEX_Server::SignRequestHandler* destination,
            ClientResponseHandler* clientAct,
            const LabeledReadKeyMsg& req,
            const unsigned char* seqNum,
            CODEX_Server::BroadcastRequestHandler* reqHandler );

         virtual ~ClientReadCallback();

         bool operator()( unsigned int server, CODEX_Quorum::Message* msg );

      private :
         void constructBlindedKey( BlindPlainTextType& blindedKey,
                                   const BlindCipherTextType& blinding,
                                   const PartialArray& partials );

      private :
         CODEX_Server::SignRequestHandler*       m_destination;
         ClientResponseHandler*                  m_clientAct;
         LabeledReadKeyMsg                       m_request;
         EvidenceMap                             m_evidence;
         DigestMap                               m_digests;
         PartialMap                              m_partials;
#ifdef ELGAMAL
         ProofMap                                m_proofs;
         RespMap                                 m_nResp;
#endif
         bool                                    m_complete;
         ChallengeVector                         m_challenges;
         CODEX_Server::BroadcastRequestHandler*  m_reqHandler;
   };

}

#endif /* __CODEX_KEYSERVICE_CLIENTREADCALLBACK_H__ */

---