BigNumber.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: BigNumber.cc,v 1.4 2004/05/19 15:56:37 mmarsh Exp $
//
// $Log: BigNumber.cc,v $
// Revision 1.4  2004/05/19 15:56:37  mmarsh
// Added copyright and license statements.
//
// Revision 1.3  2003/11/06 16:57:33  mmarsh
// m_value was not being tested before trying to convert it to m_asn1.
//
// Revision 1.2  2003/11/04 22:31:46  mmarsh
// *** empty log message ***
//
//

#include "BigNumber.h"

using namespace CODEX_ASN1;

BigNumber::BigNumber() :
   Base( false ),
   m_value( 0 ),
   m_asn1( 0 )
{
}

BigNumber::BigNumber( BIGNUM * pBN ) :
   Base( true ),
   m_value( pBN ),
   m_asn1( 0 )
{
//   if ( 0 != m_value )
//   {
//      m_asn1 = BN_to_ASN1_INTEGER( m_value, m_asn1 );
//   }
}

BigNumber::BigNumber( const ASN1_INTEGER* asn1 ) :
   Base( true ),
   m_value( 0 ),
   m_asn1( 0 )
{
   m_asn1 = M_ASN1_INTEGER_dup( asn1 );
   if ( 0 != m_asn1 )
   {
      m_value = ASN1_INTEGER_to_BN( m_asn1, m_value );
   }
}

BigNumber::BigNumber( const BigNumber& aBN ) :
   Base( aBN.m_initialized ),
   m_value( 0 ),
   m_asn1( 0 )
{
   m_value = BN_dup( aBN.m_value );
//   m_asn1 = M_ASN1_INTEGER_dup( aBN.m_asn1 );
}

BigNumber::~BigNumber()
{
   if ( m_initialized )
   {
      if ( 0 != m_value ) BN_free( m_value );
      if ( 0 != m_asn1  ) ASN1_INTEGER_free( m_asn1 );
   }
}

void
BigNumber::operator=( const BigNumber& aBN )
{
   m_initialized = aBN.m_initialized;
   if ( 0 != m_value )
   {
      BN_clear_free( m_value );
      m_value = 0;
   }
   if ( 0 != aBN.m_value )
   {
      m_value = BN_dup( aBN.m_value );
   }
   if ( 0 != m_asn1 )
   {
      ASN1_INTEGER_free( m_asn1 );
      m_asn1 = 0;
   }
//   if ( 0 != aBN.m_asn1 )
//   {
//      m_asn1 = M_ASN1_INTEGER_dup( aBN.m_asn1 );
//   }
}

void
BigNumber::operator=( BIGNUM * pBN )
{
   if ( 0 != m_value ) BN_clear_free( m_value );
   if ( 0 != m_asn1  ) ASN1_INTEGER_free( m_asn1 );
   m_value = pBN;
   m_asn1 = 0;
   m_initialized = true;
}

bool
BigNumber::operator==( const BigNumber& aBN ) const
{
   return ( 0 == BN_cmp( m_value , aBN.m_value ) );
}

bool
BigNumber::operator!=( const BigNumber& aBN ) const
{
   return ( 0 != BN_cmp( m_value , aBN.m_value ) );
}

bool
BigNumber::operator<( const BigNumber& aBN ) const
{
   return ( 0 > BN_cmp( m_value , aBN.m_value ) );
}

bool
BigNumber::operator>( const BigNumber& aBN ) const
{
   return ( 0 < BN_cmp( m_value , aBN.m_value ) );
}

const ASN1_INTEGER *
BigNumber::asn1() const
{
   if ( 0 == m_asn1 )
   {
      if ( 0 != m_value )
      {
         m_asn1 = BN_to_ASN1_INTEGER( m_value, m_asn1 );
      }
   }
   return m_asn1;
}

int
BigNumber::marshal( unsigned char ** pp ) const
{
   asn1();
   return i2d_ASN1_INTEGER( m_asn1, pp );
}

void*
BigNumber::unmarshal( void* bogus, unsigned char** pp, long length )
{
   if ( m_initialized )
   {
      return 0;
   }
   if ( 0 == d2i_ASN1_INTEGER( &m_asn1, (unsigned char**)pp, length ) )
   {
      return 0;
   }
   m_value = ASN1_INTEGER_to_BN( m_asn1, m_value );
   m_initialized = true;
   return this;
}

---