cASN.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cASN_H
#define _INC_cASN_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cMem.h"
#include "GrayCore/include/cHeap.h"
#include "GrayCore/include/StrT.h"
#include "GrayCore/include/StrBuilder.h"
 
namespace GrayLib
{
        enum ASN_TYPE
        {
 
                ASN_Unknown = 0x00,                     
                ASN_BOOLEAN = 0x01,
                ASN_INTEGER = 0x02,
                ASN_ArrayBits = 0x03,                   
                ASN_ArrayBytes = 0x04,                  
                ASN_NULL = 0x05,
                ASN_OID = 0x06,                                 
                // 7 = Object Descriptor.
                // 8 = InstanceOf, External.
                ASN_REAL = 0x09,                                
                ASN_ENUMERATED = 0x0a,                  
                // 11 = EMBEDDED PDV.
                ASN_StringUTF8 = 0x0C,                  
                // 13 = Relative-OID
                // 14 = Reserved?
                // 15 = Reserved?
                ASN_SEQUENCE = 0x10,                    // 16 = We have child blocks.
                ASN_SET = 0x11,                                 // 17 = An ASN_OID, value pair.
                // NumericString = 0x12,                // 18
                ASN_StringPrintable = 0x13,             // 19  PRINTABLE_STRING 
                ASN_StringT61 = 0x14,                   // 20 = TeletexString, T61String
                // 0x15 = 21 = VideotexString
                ASN_StringIA5 = 0x16,                   // 22 = IA5String
                ASN_TimeUTC = 0x17,                             // 23 = UTCTime
                ASN_TimeGeneral = 0x18,                 // 24 = GeneralizedTime, 32 bit year.
                // ASN_GraphicString // 25 = GraphicString
                // 26 = VisibleString, ISO646String
                // 27 = GeneralString
                ASN_StringUniversal = 0x1C,     // 28 = UniversalString
                // 29 = CharacterString
                ASN_Bitmap = 0x1E,                      // 30 = BMPString
 
                // Mask Bits.
                ASNF_MASK = 0x1F,
                ASNF_CONSTRUCTED = 0x20,                // bitmask. indicates known format of child blocks.
                ASNF_APPLICATION = 0x40,
                ASNF_CONTEXT_SPECIFIC = 0x80,
                // ASNF_PRIVATE = ASNF_CONSTRUCTED | ASNF_CONTEXT_SPECIFIC,
        };
 
        typedef BYTE ASN_t;     // ASN_TYPE fits in here.
 
        class GRAYLIB_LINK cASNBuf : public cMemBlock
        {
 
                typedef cMemBlock SUPER_t;
 
        public:
                ASN_TYPE m_eASNTag;     
 
                static const char* const k_szTypeName[ASNF_MASK];
 
        public:
                cASNBuf() noexcept
                        : m_eASNTag(ASN_Unknown)        // 0
                {
                }
 
                ASN_TYPE get_ASNType() const noexcept
                {
                        return (ASN_TYPE)(m_eASNTag&ASNF_MASK);
                }
 
                bool isEmptyBuf() const
                {
                        if (m_eASNTag != ASN_NULL && m_eASNTag != ASN_Unknown)
                                return false;
                        if (get_DataSize() != 0)
                                return false;
                        return true;
                }
 
                bool isSequence() const noexcept
                {
                        ASN_TYPE e = get_ASNType();
                        if (e == ASN_SEQUENCE || e == ASN_SET)
                                return true;
                        return false;
                }
 
                bool isPrintable() const noexcept
                {
                        return(m_eASNTag == ASN_StringUTF8 || m_eASNTag == ASN_StringPrintable);
                }
 
                bool IsEqualBuf(const cASNBuf& b) const
                {
                        return (m_eASNTag == b.m_eASNTag && IsEqualData(&b));
                }
 
                bool IsEqualStr(const void* pStr, size_t nSize) const
                {
                        if (this->get_DataSize() != nSize)
                        {
                                return false;
                        }
                        if (StrT::CmpIN<char>(this->get_DataA(), (const char*)pStr, (StrLen_t)nSize) == COMPARE_Equal)
                        {
                                return true;
                        }
                        return false;
                }
 
                bool IsEqualStr(const cASNBuf& b) const
                {
 
                        if (IsEqualBuf(b))      // exact same.
                                return true;
                        if (!this->isPrintable() || !b.isPrintable())
                                return false;
                        return IsEqualStr(b.get_DataBytes(), b.get_DataSize());
                }
 
                void SetEmptyBuf()
                {
                        m_eASNTag = ASN_Unknown;
                        SUPER_t::SetEmptyBlock();
                }
 
                bool get_Bool() const
                {
                        ASSERT(m_eASNTag == ASN_BOOLEAN);
                        ASSERT(get_DataSize() > 0);
                        const BYTE bVal = *get_DataBytes();
                        return (bVal == 0) ? false : true;
                }
 
                int get_Int() const;
 
                HRESULT GetDescriptionStr(StrBuilder& s) const;
 
                UNITTEST_FRIEND(cASN);
        };
 
        class GRAYLIB_LINK cASNBufAlloc : public cASNBuf
        {
 
                typedef cASNBuf SUPER_t;
 
        private:
                bool m_bAllocated;      
 
        private:
                void SetEmptyBlock() IS_DELETE; // prevent use of this.
                void SetBlock(void* pData, size_t nSize) IS_DELETE;
 
        public:
                cASNBufAlloc() noexcept
                        : m_bAllocated(false)
                {
                }
                ~cASNBufAlloc()
                {
                        SetEmptyBuf();
                }
 
                void SetEmptyBuf()
                {
                        if (m_bAllocated)
                        {
                                cHeap::FreePtr(get_DataBytes());
                                m_bAllocated = false;
                        }
                        SUPER_t::SetEmptyBuf(); // __super
                }
 
                bool SetAlloc(ASN_TYPE eASNTag, size_t nSize, const void* pData = nullptr)
                {
                        // I allocate space for the value. I must also free it.
                        if (!m_bAllocated)
                        {
                                SUPER_t::SetEmptyBuf(); // __super
                                m_bAllocated = true;
                        }
                        void* pDataNew = cHeap::ReAllocPtr(m_pData, nSize);
                        if (pDataNew == nullptr)
                                return false;
 
                        m_eASNTag = eASNTag;
 
                        if (pData != nullptr)
                        {
                                ::memcpy(pDataNew, pData, nSize);
                        }
                        SUPER_t::SetBlock(pDataNew, nSize);
                        return true;
                }
        };
}
#endif