ASN1Helper.h

Go to the documentation of this file.

#ifndef __ASN1HELPER_H__
#define __ASN1HELPER_H__

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "PKIFdll.h"
#include "components.h"
#include "ASN1Errors.h"
#include "PKIFCommonErrors.h"
#include "PKIFException.h"
#include "ASN1HelperLib.h"

extern "C" 
{
    #include "ooasn1.h"
    #include "asn1ber.h"
}

//define a macro to simplify usage of Objective structures and functions
#define CACASNWRAPPER_CREATE(className, pduName) \
CPKIFASNWrapper<className> pduName( BEREnc##className, BERDec##className );

//void FreeASN1Context(OOCTXT* ctx);


template<class T>
class CPKIFASNWrapper
{
private:
    typedef CPKIFASNWrapper<T> this_type;
public:
    CPKIFASNWrapper(int (*pEncode)(OOCTXT*, T*, ASN1TagType),
                    int (*pDecode)(OOCTXT*, T*, ASN1TagType, int)) : mptrData( 0 ),
                    m_pEncode(pEncode), m_pDecode(pDecode), m_didDecode(false), m_didEncode(false)

    { 
        initContext (&m_context);
        // unnecessary with open source runtime
        // rtSetFastCopy(&m_context,true);
    }
    ~CPKIFASNWrapper( )
    {
        clear( );
    }

    T * data( ) const { return mptrData; }
    T * operator->( ) const { return mptrData; }
    typedef T* this_type::*unspecified_bool_type;
    operator unspecified_bool_type() const // never throws
    {
        return mptrData == 0 ? 0: &this_type::mptrData;
    }
    // some compilers need this too
    bool operator!() const //never throws
    {
        return mptrData == 0;
    }
    T * Decode( const unsigned char* buf, int bufLen )
    {
        if(!buf || 0 >= bufLen)
            throw CPKIFException(TOOLKIT_ASN, COMMON_INVALID_INPUT);

        ASN1OpenType temp;
        temp.data = buf;
        temp.numocts = bufLen;
        
        return Decode( temp );
    }
    ASN1OpenType* Encode( const T * ptrData )
    {
        setBEREncBufPtr(&m_context, NULL, 0);
        T* nonConstPData = const_cast<T*>(ptrData);
        int msgLen = m_pEncode(&m_context, nonConstPData, ASN1EXPL);
        if (msgLen > 0)
        {
            m_didEncode = true;

            ASN1OpenType* tmp = new ASN1OpenType();
            tmp->numocts = msgLen;
            tmp->data = getBEREncBufPtr(&m_context);

            return tmp;
        }
        else
        {
            throw CPKIFException(TOOLKIT_ASN, ASN1_ENCODE_ERROR);
        }
    }
    void clear( ) 
    { 
        //freeEncodeBuffer(&m_context);
        //memFreeAll(&m_context);
        FreeASN1Context(&m_context);

        if( mptrData )
        {
            delete mptrData;
            mptrData = 0;
        }
    }
    T * Decode( const ASN1OpenType & encoded_ )
    {
        setBERDecBufPtr(&m_context, encoded_.data, encoded_.numocts, NULL, NULL);

        //added 11/11/2003
        if( mptrData )
        {
            delete mptrData;
            mptrData = 0;
        }

        mptrData = new T;
        int nRc = m_pDecode(&m_context, mptrData, ASN1EXPL, 0);
        if( nRc )
        {
            //added cleanup 10/13/2003
            FreeASN1Context(&m_context);
            if(mptrData)
            {
                delete mptrData; mptrData = NULL;
            }
            throw CPKIFException(TOOLKIT_ASN, ASN1_DECODE_ERROR, "Failed to decode ASN1 object");
        }
        else
        {
            m_didDecode = true;
        }
        return mptrData;
    }
    void InitContext()
    {
        initContext (&m_context);
        // unnecessary with open source runtime
        // rtSetFastCopy(&m_context,true);
    }

private:
    // Deny copying and assignment
    CPKIFASNWrapper( const CPKIFASNWrapper<T> & );
    CPKIFASNWrapper<T> & operator=( const CPKIFASNWrapper<T> & );

private:
    OOCTXT m_context;
    T * mptrData;
    int (*m_pEncode)(OOCTXT*, T*, ASN1TagType);
    int (*m_pDecode)(OOCTXT*, T*, ASN1TagType, int);
    bool m_didEncode;
    bool m_didDecode;
};

#endif