ShareLabel.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: ShareLabel.h,v 1.4 2005/01/21 19:44:18 mmarsh Exp $
//
// $Log: ShareLabel.h,v $
// Revision 1.4  2005/01/21 19:44:18  mmarsh
// Updated for compatibility with Doxygen 1.4.1
//
// Revision 1.3  2004/05/19 15:57:01  mmarsh
// *** empty log message ***
//
// Revision 1.2  2003/11/04 22:23:08  mmarsh
// General code cleanup.
//
//

#ifndef __CODEX_VSS_SHARELABEL_H__
#define __CODEX_VSS_SHARELABEL_H__

#include <fstream>

#include "VRecon.h"
#include "ShareSet.h"
#include "CODEX_ASN1/Base.h"
#include "CODEX_ASN1/Integer.h"
#include "CODEX_Exceptions/FileExceptions.h"

namespace CODEX_VSS
{
   template< class _ShareType , class _OneWay >
   class ShareLabel : public CODEX_ASN1::Base
   {
      public :
         typedef _ShareType                    ShareType;
         typedef _OneWay                       OneWay;
         typedef VRecon< ShareType , OneWay >  VType;

         const static unsigned int  NumShares = ShareType::NumShares;

         ShareLabel() :
            CODEX_ASN1::Base( false )
         {
         }

         ShareLabel( int num,
                     int version,
                     int id,
                     const ShareSet< ShareType >& shareSet,
                     const OneWay& func ) :
            CODEX_ASN1::Base( true ),
            m_num( num ),
            m_version( version ),
            m_id( id )
         {
            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               func( shareSet(i), m_vc[i] );
            }
         }

//         /// Constructor taking a version number and ID
//         ShareLabel( int version, int id ) :
//            CODEX_ASN1::Base( true ),
//            m_version( version ),
//            m_id( id )
//         {
//         }

         ShareLabel( int num,
                     int version,
                     int id,
                     const typename VType::ValueType vc[NumShares] ) :
            CODEX_ASN1::Base( true ),
            m_num( num ),
            m_version( version ),
            m_id( id )
         {
            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               m_vc[i] = vc[i];
            }
         }

         ShareLabel( const ShareLabel< _ShareType, _OneWay >& aOther ) :
            CODEX_ASN1::Base( aOther.m_initialized ),
            m_num( aOther.m_num ),
            m_version( aOther.m_version ),
            m_id( aOther.m_id )
         {
            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               m_vc[i] = aOther.m_vc[i];
            }
         }

         virtual ~ShareLabel()
         {
         }

         void operator=( const ShareLabel< _ShareType, _OneWay >& aOther )
         {
            m_initialized = aOther.m_initialized;
            m_num = aOther.m_num;
            m_version = aOther.m_version;
            m_id = aOther.m_id;
            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               m_vc[i] = aOther.m_vc[i];
            }
         }

         int cmp( const ShareLabel< _ShareType, _OneWay >& aOther ) const
         {
            int n1 = m_num.value();
            int n2 = aOther.m_num.value();
            if ( n1 < n2 ) return -1;
            if ( n1 > n2 ) return 1;

            int v1 = m_version.value();
            int v2 = aOther.m_version.value();
            if ( v1 < v2 ) return -1;
            if ( v1 > v2 ) return 1;

            int i1 = m_id.value();
            int i2 = aOther.m_id.value();
            if ( i1 < i2 ) return -1;
            if ( i1 > i2 ) return 1;

            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               if ( m_vc[i] < aOther.m_vc[i] ) return -1;
               if ( m_vc[i] > aOther.m_vc[i] ) return 1;
            }

            // At this point they're equal.
            return 0;
         }
         
         bool operator<( const ShareLabel< _ShareType, _OneWay >& aOther )
            const
         {
            return ( cmp(aOther) < 0 );
         }

         bool operator>( const ShareLabel< _ShareType, _OneWay >& aOther )
            const
         {
            return ( cmp(aOther) > 0 );
         }

         bool operator==( const ShareLabel< _ShareType, _OneWay >& aOther )
            const
         {
            return ( cmp(aOther) == 0 );
         }

         bool operator!=( const ShareLabel< _ShareType, _OneWay >& aOther )
            const
         {
            return ( cmp(aOther) != 0 );
         }

         bool operator<=( const ShareLabel< _ShareType, _OneWay >& aOther )
            const
         {
            return ( cmp(aOther) <= 0 );
         }

         bool operator>=( const ShareLabel< _ShareType, _OneWay >& aOther )
            const
         {
            return ( cmp(aOther) >= 0 );
         }

         const CODEX_ASN1::Integer& num() const { return m_num; }

         const CODEX_ASN1::Integer& version() const { return m_version; }

         const CODEX_ASN1::Integer& id() const { return m_id; }

         const typename VType::ValueType* vc() const { return m_vc; }

         const typename VType::ValueType& vc( unsigned int i ) const
         {
            if ( i >= NumShares )
            {
               throw CODEX_Exceptions::IllegalIndexException( __FILE__ ,
                                                              __LINE__ );
            }
            return m_vc[i];
         }

         bool verify( const typename VType::ValueType& vcs,
                      const OneWay& func ) const
         {
            VType vr( func );
            typename VType::ValueType res;
            vr( m_vc, res );
            if ( res != vcs ) return false;
            return true;
         }

         bool check( const ShareType& share, const OneWay& func ) const
         {
            VType vr( func );
            return vr.checkShare( m_vc, share, func );
         }

         int marshal( unsigned char ** pp ) const
         {
            // For starters, we will not agree to marshal an incomplete label.
            if ( ! m_num.initialized() ) return 0;
            if ( ! m_version.initialized() ) return 0;
            if ( ! m_id.initialized() ) return 0;
            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               if ( ! m_vc[i].initialized() ) return 0;
            }
            int r=0;
            int ret=0;
            unsigned char * p;

            ret += m_num.marshal(0);
            ret += m_version.marshal(0);
            ret += m_id.marshal(0);
            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               ret += m_vc[i].marshal(0);
            }
            M_ASN1_I2D_seq_total();
            m_num.marshal(&p);
            m_version.marshal(&p);
            m_id.marshal(&p);
            for ( unsigned int i = 0 ; i < NumShares ; ++i )
            {
               m_vc[i].marshal(&p);
            }
            M_ASN1_I2D_finish();
         }

         void* unmarshal( void* bogus, unsigned char** pp, long length )
         {
            if ( m_initialized )
            {
               return 0;
            }
            if ( (0 == pp) || (0 == *pp) )
            {
               return 0;
            }

            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_num.unmarshal);
            M_ASN1_D2I_get(i, m_version.unmarshal);
            M_ASN1_D2I_get(i, m_id.unmarshal);
            for ( unsigned int count = 0 ; count < NumShares ; ++count )
            {
               M_ASN1_D2I_get(i, m_vc[count].unmarshal);
            }
            if ( !asn1_Finish(&c) )
            {
               return 0;
            }
            *pp=c.p;
            m_initialized = true;
            return this;
           err: // needed by ASN.1 macros
            return 0;
         }

      private :
         CODEX_ASN1::Integer        m_num;
         CODEX_ASN1::Integer        m_version;
         CODEX_ASN1::Integer        m_id;
         typename VType::ValueType  m_vc[ NumShares ];
   };

   template< class _ShareType , class _OneWay >
   class LabeledShare : public CODEX_ASN1::Base
   {
      public :
         typedef _ShareType                          ShareType;

         typedef _OneWay                             OneWay;

         typedef ShareLabel< _ShareType , _OneWay >  LabelType;

         typedef CODEX_ASN1::Base                    BaseType;

         LabeledShare() : BaseType( false ) {}

         LabeledShare( const ShareType& share, const LabelType& label ) :
            BaseType( true ),
            m_share( share ),
            m_label( label )
         {}

         LabeledShare( const LabeledShare< ShareType , OneWay >& aOther ) :
            BaseType( aOther.m_initialized ),
            m_share( aOther.m_share ),
            m_label( aOther.m_label )
         {}

         ~LabeledShare() {}

         void operator=( const LabeledShare< ShareType , OneWay >& aOther )
         {
            m_initialized = aOther.m_initialized;
            m_share = aOther.m_share;
            m_label = aOther.m_label;
         }

         const ShareType& share() const { return m_share; }

         const LabelType& label() const { return m_label; }

         int marshal( unsigned char ** pp ) const
         {
            if ( ! m_share.initialized() ) return 0;
            if ( ! m_label.initialized() ) return 0;
            int r=0;
            int ret=0;
            unsigned char * p;

            ret += m_share.marshal(0);
            ret += m_label.marshal(0);
            M_ASN1_I2D_seq_total();
            m_share.marshal(&p);
            m_label.marshal(&p);
            M_ASN1_I2D_finish();
         }

         void* unmarshal( void* bogus, unsigned char** pp, long length )
         {
            if ( m_initialized )
            {
               return 0;
            }
            if ( (0 == pp) || (0 == *pp) )
            {
               return 0;
            }

            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_share.unmarshal);
            M_ASN1_D2I_get(i, m_label.unmarshal);
            if ( !asn1_Finish(&c) )
            {
               return 0;
            }
            *pp=c.p;
            m_initialized = true;
            return this;
           err: // needed by ASN.1 macros
            return 0;
         }

         void toFile( const char* fname ) const
         {
            int length = marshal(0);
            if ( 0 == length ) return;
            unsigned char* buff = new unsigned char[length];
            unsigned char* p = buff;
            marshal(&p);
            ofstream os(fname);
            if ( ! os.is_open() )
            {
               delete [] buff;
               throw CODEX_Exceptions::FileCannotCreateException( __FILE__ ,
                                                                  __LINE__ ,
                                                                  fname );
            }
            for ( int i = 0 ; i < length ; ++i )
            {
               os << buff[i];
            }
            os.close();
            delete [] buff;
         }

         void* fromFile( const char* fname )
         {
            ifstream is(fname);
            if ( ! is.is_open() )
            {
               throw CODEX_Exceptions::FileCannotOpenException( __FILE__ ,
                                                                __LINE__ ,
                                                                fname );
            }
            string s;
            char ch;
            while ( is.get(ch) )
            {
               s.push_back(ch);
            }
            //basic_string<unsigned char> s;
            //is >> s;
            unsigned int length = s.length();
            unsigned char* p = new unsigned char[length];
            unsigned char* pOrig = p;
            //unsigned char* p = (unsigned char*)s.data();
            for ( unsigned int i = 0 ; i < length ; ++i )
            {
               p[i] = s.data()[i];
            }
            void* retVal = unmarshal(0,&p,length);
            delete [] pOrig;
            return retVal;
         }

      private :
         ShareType  m_share;
         LabelType  m_label;
   };


   template< class _ShareType , class _OneWay >
   class SecretWitness : public CODEX_ASN1::Base
   {
      public :
         typedef CODEX_ASN1::Base                         BaseType;

         typedef _ShareType                               ShareType;

         typedef _OneWay                                  OneWay;

         typedef typename VRecon< ShareType , OneWay >::ValueType  WitnessType;

         typedef typename ShareType::ValueType            ValueType;

         typedef typename OneWay::CtorArgs                ArgsType;

         SecretWitness() : BaseType( false ) {}

         SecretWitness( const WitnessType& witness , const ArgsType& args ) :
            BaseType( true ),
            m_witness( witness ),
            m_args( args )
         {
         }

         SecretWitness( const SecretWitness< ShareType , OneWay >& aOther ) :
            BaseType( aOther.m_initialized ),
            m_witness( aOther.m_witness ),
            m_args( aOther.m_args )
         {
         }

         ~SecretWitness() {}

         void operator=( const SecretWitness< ShareType , OneWay >& aOther )
         {
            m_initialized = aOther.m_initialized;
            m_witness = aOther.m_witness;
            m_args = aOther.m_args;
         }

         const WitnessType& witness() const { return m_witness; }

         const ArgsType& args() const { return m_args; }

         int marshal( unsigned char ** pp ) const
         {
            if ( ! m_witness.initialized() ) return 0;
            if ( ! m_args.initialized() ) return 0;
            int r=0;
            int ret=0;
            unsigned char * p;

            ret += m_witness.marshal(0);
            ret += m_args.marshal(0);
            M_ASN1_I2D_seq_total();
            m_witness.marshal(&p);
            m_args.marshal(&p);
            M_ASN1_I2D_finish();
         }

         void* unmarshal( void* bogus, unsigned char** pp, long length )
         {
            if ( m_initialized )
            {
               return 0;
            }
            if ( (0 == pp) || (0 == *pp) )
            {
               return 0;
            }

            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_witness.unmarshal);
            M_ASN1_D2I_get(i, m_args.unmarshal);
            if ( !asn1_Finish(&c) )
            {
               return 0;
            }
            *pp=c.p;
            m_initialized = true;
            return this;
           err: // needed by ASN.1 macros
            return 0;
         }

         void toFile( const char* fname ) const
         {
            int length = marshal(0);
            if ( 0 == length ) return;
            unsigned char* buff = new unsigned char[length];
            unsigned char* p = buff;
            marshal(&p);
            ofstream os(fname);
            if ( ! os.is_open() )
            {
               delete [] buff;
               throw CODEX_Exceptions::FileCannotCreateException( __FILE__ ,
                                                                  __LINE__ ,
                                                                  fname );
            }
            for ( int i = 0 ; i < length ; ++i )
            {
               os << buff[i];
            }
            os.close();
            delete [] buff;
         }

         void* fromFile( const char* fname )
         {
            ifstream is(fname);
            if ( ! is.is_open() )
            {
               throw CODEX_Exceptions::FileCannotOpenException( __FILE__ ,
                                                                __LINE__ ,
                                                                fname );
            }
            string s;
            char ch;
            while ( is.get(ch) )
            {
               s.push_back(ch);
            }
            //basic_string<unsigned char> s;
            //is >> s;
            unsigned int length = s.length();
            //unsigned char* p = (unsigned char*)s.data();
            unsigned char* p = new unsigned char[length];
            unsigned char* pOrig = p;
            for ( unsigned int i = 0 ; i < length ; ++i )
            {
               p[i] = s.data()[i];
            }
            void* retVal = unmarshal(0,&p,length);
            delete [] pOrig;
            return retVal;
         }

      private :
         WitnessType  m_witness;
         ArgsType     m_args;
   };

}

#endif /* __CODEX_VSS_SHARELABEL_H__ */

---