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

#include "Message.h"

using namespace CODEX_Client;
using namespace CODEX_ASN1;
using namespace CODEX_Ciphers;

WriteKeyMsg::WriteKeyMsg() :
   Message( false )
{
}

WriteKeyMsg::WriteKeyMsg( const OctetString& name,
                          const RequestCipherTextType& encryption,
#ifndef ELGAMAL
                          const RSAPlaintextPK& proof,
#endif
                          const Credentials& credentials,
                          const SignedBoundNameMsg& binding ) :
   Message( true ),
   m_name( name ),
   m_encryption( encryption ),
#ifndef ELGAMAL
   m_proof( proof ),
#endif
   m_credentials( credentials ),
   m_binding( binding )
{
}

WriteKeyMsg::WriteKeyMsg( const WriteKeyMsg& aWKM ) :
   Message( aWKM.m_initialized ),
   m_name( aWKM.m_name ),
   m_encryption( aWKM.m_encryption ),
#ifndef ELGAMAL
   m_proof( aWKM.m_proof ),
#endif
   m_credentials( aWKM.m_credentials ),
   m_binding( aWKM.m_binding )
{
}

void
WriteKeyMsg::operator=( const WriteKeyMsg& aWKM )
{
   m_initialized = aWKM.m_initialized;
   m_name        = aWKM.m_name;
   m_encryption  = aWKM.m_encryption;
#ifndef ELGAMAL
   m_proof       = aWKM.m_proof;
#endif
   m_credentials = aWKM.m_credentials;
   m_binding     = aWKM.m_binding;
}

int
WriteKeyMsg::marshal( unsigned char ** pp ) const
{
   int r=0;
   int ret=0;
   unsigned char * p;

   ret += m_name.marshal(0);
   ret += m_encryption.marshal(0);
#ifndef ELGAMAL
   ret += m_proof.marshal(0);
#endif
   ret += m_credentials.marshal(0);
   ret += m_binding.marshal(0);
   M_ASN1_I2D_seq_total();
   m_name.marshal(&p);
   m_encryption.marshal(&p);
#ifndef ELGAMAL
   m_proof.marshal(&p);
#endif
   m_credentials.marshal(&p);
   m_binding.marshal(&p);
   M_ASN1_I2D_finish();
}

void*
WriteKeyMsg::unmarshal( void* bogus, unsigned char ** pp, long length )
{
   if ( m_initialized )
   {
      return NULL;
   }
   if ( (NULL == pp) || (NULL == *pp) )
   {
      return NULL;
   }
   ASN1_CTX c;
   c.pp = pp;
   c.q = *pp;
   c.error = ERR_R_NESTED_ASN1_ERROR;
   int i;

   M_ASN1_D2I_Init();
   M_ASN1_D2I_start_sequence();
   M_ASN1_D2I_get(i, m_name.unmarshal);
   M_ASN1_D2I_get(i, m_encryption.unmarshal);
#ifndef ELGAMAL
   M_ASN1_D2I_get(i, m_proof.unmarshal);
#endif
   M_ASN1_D2I_get(i, m_credentials.unmarshal);
   M_ASN1_D2I_get(i, m_binding.unmarshal);
   if ( !asn1_Finish(&c) )
   {
      return NULL;
   }
   *pp=c.p;
   m_initialized = true;
   return this;
  err: // needed by ASN.1 macros
   return NULL;
}

---