asn1CppTypes.h

Go to the documentation of this file.

/*
 * Copyright (c) 1997-2023 Objective Systems, Inc.
 *
 * This software is furnished under a license and may be used and copied
 * only in accordance with the terms of such license and with the
 * inclusion of the above copyright notice. This software or any other
 * copies thereof may not be provided or otherwise made available to any
 * other person. No title to and ownership of the software is hereby
 * transferred.
 *
 * The information in this software is subject to change without notice
 * and should not be construed as a commitment by Objective Systems, Inc.
 *
 * PROPRIETARY NOTICE
 *
 * This software is an unpublished work subject to a confidentiality agreement
 * and is protected by copyright and trade secret law.  Unauthorized copying,
 * redistribution or other use of this work is prohibited.
 *
 * The above notice of copyright on this source code product does not indicate
 * any actual or intended publication of such source code.
 *
 *****************************************************************************/
#ifndef _ASN1CPPTYPES_H_
#define _ASN1CPPTYPES_H_

/* Symbian and Telium systems don't have new */
#if !defined(__SYMBIAN32__) && !defined(TELIUM)
#include <new>
#endif

#include "rtxsrc/rtxMemory.h"
#include "rtxsrc/rtxDiag.h"
#include "rtxsrc/rtxError.h"
#include "rtxsrc/rtxMemBuf.h"
#include "rtsrc/asn1CppEvtHndlr64.h"
#include "rtsrc/asn1CppRawEvtHndlr.h"
#include "rtsrc/ASN1Context.h"
#include "rtxsrc/OSRTMsgBuf.h"

// for compatibilty only

#define ASN1TRY try

#define ASN1RTLTHROW(stat) exit (-1)

#define ASN1THROW(ex) exit (-1)

#define ASN1CATCH(exType,ex,body) if (0) { body; }

class EXTRTCLASS ASN1MessageBuffer : public OSRTMessageBuffer
{
 protected:

   EXTRTMETHOD ASN1MessageBuffer (Type bufferType);

   EXTRTMETHOD ASN1MessageBuffer (Type bufferType, OSRTContext* pContext);

   virtual int setStatus (int stat) {
      getContext()->setStatus (stat);
      return stat;
   }

 public:
   virtual ~ASN1MessageBuffer () {}

   virtual void addEventHandler (Asn1NamedEventHandler* pEventHandler) {
      Asn1NamedEventHandler::addEventHandler
         (getCtxtPtr(), pEventHandler);
   }

   void addRawEventHandler(Asn1RawEventHandler* pHandler) {
      pHandler->addEventHandler(getCtxtPtr());
   }

#if !defined(__SYMBIAN32__) && !defined(_V2X)

   ASN1BMPString* CStringToBMPString
      (const char* cstring, ASN1BMPString* pBMPString,
       Asn116BitCharSet* pCharSet = 0);
#endif

   virtual void* getAppInfo () { return 0; }

   virtual EXTRTMETHOD int initBuffer (OSRTMEMBUF& membuf);

   virtual EXTRTMETHOD int initBuffer (OSUNICHAR* unistr);

   using OSRTMessageBuffer::initBuffer;
   virtual int initBuffer (const OSUTF8CHAR* /*str*/) { return RTERR_NOTSUPP; }

   virtual OSBOOL isA (Type /*bufferType*/) { return FALSE; }

   virtual void removeEventHandler (Asn1NamedEventHandler* pEventHandler) {
      Asn1NamedEventHandler::removeEventHandler
         (getCtxtPtr(), pEventHandler);
   }

   void removeRawEventHandler()
      { Asn1RawEventHandler::removeEventHandler(getCtxtPtr()); }

   virtual void resetErrorInfo () {
      OSRTMessageBuffer::resetErrorInfo ();
   }

   virtual void setAppInfo (void* /*pAppInfo*/) { }

   virtual void setErrorHandler (Asn1ErrorHandler* pErrorHandler) {
      Asn1ErrorHandler::setErrorHandler
         (getCtxtPtr(), pErrorHandler);
   }

   EXTRTMETHOD int setRunTimeKey (const OSOCTET* key, OSSIZE keylen);

   inline size_t getBitOffset () {
      return rtxCtxtGetBitOffset (getCtxtPtr());
   }

   // The following are deprecated method definitions maintained for
   // backward compatibility only..

   inline OSOCTET* GetMsgCopy () { return getMsgCopy(); }
   inline const OSOCTET* GetMsgPtr() { return getMsgPtr(); }
   inline void PrintErrorInfo() { printErrorInfo(); }

} ;
class EXTRTCLASS ASN1CType {
 protected:
   OSRTCtxtPtr mpContext;

   OSRTMessageBufferIF* mpMsgBuf;

   EXTRTMETHOD ASN1CType ();

   EXTRTMETHOD ASN1CType (OSRTContext& ctxt);

   EXTRTMETHOD int setMsgBuf
      (OSRTMessageBufferIF& msgBuf, OSBOOL initBuf=FALSE);

   EXTRTMETHOD int setRunTimeKey (const OSOCTET* key, OSSIZE keylen);

 public:
   EXTRTMETHOD ASN1CType (OSRTMessageBufferIF& msgBuf);

   EXTRTMETHOD ASN1CType (const ASN1CType& orig);

   virtual ~ASN1CType () {}

   inline void append (OSRTDList& llist, void* pdata) {
      if (0 == rtxDListAppend (getCtxtPtr(), &llist, pdata))
         LOG_RTERR (getCtxtPtr(), RTERR_NOMEM);
   }

   inline OSRTCtxtPtr getContext () {
      return mpContext;
   }

   inline OSCTXT* getCtxtPtr () {
      return (!mpContext.isNull ()) ? mpContext->getPtr() : 0;
   }

   char* getErrorText (char* textbuf = (char*)0, OSSIZE bufsize = 0);

   inline int getStatus () const {
      return (!mpContext.isNull()) ? mpContext->getStatus() : 0;
   }

   inline void* memAlloc (OSSIZE numocts) {
      if (mpContext.isNull ()) return 0;
      return mpContext->memAlloc (numocts);
   }

   inline void* memAllocZ (OSSIZE numocts) {
      if (mpContext.isNull ()) return 0;
      return mpContext->memAllocZ (numocts);
   }

   inline void memFreeAll () {
      if (!mpContext.isNull ())
         mpContext->memFreeAll ();
   }

   inline void* memRealloc (void* ptr, OSSIZE numocts) {
      if (mpContext.isNull ()) return 0;
      return mpContext->memRealloc (ptr, numocts);
   }

   inline void memReset () {
      if (!mpContext.isNull ())
         mpContext->memReset ();
   }

   inline void memFreePtr (void* ptr) {
      if (!mpContext.isNull ())
         mpContext->memFreePtr (ptr);
   }

   inline void printErrorInfo () {
      if (!mpContext.isNull ())
         mpContext->printErrorInfo ();
   }

   inline void resetError () {
      if (!mpContext.isNull ())
         mpContext->resetErrorInfo ();
   }

   inline OSBOOL setDiag (OSBOOL value) {
      return getContext()->setDiag (value);
   }

   virtual EXTRTMETHOD int Encode ();

   virtual EXTRTMETHOD int Decode (OSBOOL free = FALSE);

   virtual int EncodeTo (OSRTMessageBufferIF& /*msgBuf*/)
      { return ASN_E_NOTPDU; }

   virtual int DecodeFrom (OSRTMessageBufferIF& /*msgBuf*/, OSBOOL free = TRUE)
      { OS_UNUSED_ARG(free); return ASN_E_NOTPDU; }


   virtual void MemFree() {}
} ;
struct EXTRTCLASS ASN1TDynBitStr : public ASN1DynBitStr {
   ASN1TDynBitStr () { data = 0; numbits = 0; }

   ASN1TDynBitStr (OSUINT32 _numbits, const OSOCTET* _data) {
      numbits = _numbits;
      data = _data;
   }

   ASN1TDynBitStr (ASN1DynBitStr& _bs) {
      numbits = _bs.numbits;
      data = _bs.data;
   }
} ;

struct EXTRTCLASS ASN1TDynBitStr64 : public ASN1DynBitStr64 {
   ASN1TDynBitStr64 () { data = 0; numbits = 0; }

   ASN1TDynBitStr64 (OSSIZE _numbits, const OSOCTET* _data) {
      numbits = _numbits;
      data = _data;
   }

   ASN1TDynBitStr64 (ASN1DynBitStr64& _bs) {
      numbits = _bs.numbits;
      data = _bs.data;
   }
} ;

struct EXTRTCLASS ASN1TBitStr32 : public ASN1BitStr32 {
   ASN1TBitStr32 () { numbits = 0; }

   ASN1TBitStr32 (OSUINT32 _numbits, const OSOCTET* _data) {
      numbits = _numbits;
      size_t sz = _numbits / 8;
      if ( _numbits % 8 > 0 ) sz += 1;
      OSCRTLSAFEMEMCPY (data, sizeof(data), _data, sz);
   }

   ASN1TBitStr32 (ASN1BitStr32& _bs) {
      numbits = _bs.numbits;
      OSCRTLSAFEMEMCPY (data, sizeof(data), _bs.data, sizeof(_bs.data));
   }
} ;

/* Dynamic octet string */
#include "rtsrc/ASN1TOctStr.h"
#include "rtsrc/ASN1TOctStr64.h"

struct EXTRTCLASS ASN1TBMPString : public ASN1BMPString {
   inline ASN1TBMPString () {
      nchars = 0;
      data = 0;
   }
} ;

struct EXTRTCLASS ASN1TUniversalString : public ASN1UniversalString {
   inline ASN1TUniversalString () {
      nchars = 0;
      data = 0;
   }
} ;

struct EXTRTCLASS ASN1TOpenType : public ASN1OpenType {
   inline ASN1TOpenType () {
      numocts = 0;
      data = 0;
   }
} ;

struct EXTRTCLASS Asn1TObject : public Asn1Object {
   inline Asn1TObject () {
      encoded.numocts = 0;
      encoded.data = 0;
      decoded = 0;
      index =0;
   }
} ;

typedef Asn1TObject ASN1TObject;

/* Object identifier */
#include "rtsrc/ASN1TObjId.h"

struct EXTRTCLASS ASN1TSeqExt : public OSRTDList {
   inline ASN1TSeqExt () {
      rtxDListInit (this);
   }
} ;

struct EXTRTCLASS ASN1TPDU {
 protected:
   OSRTCtxtPtr mpContext;

 public:
   inline void setContext (OSRTContext* ctxt) {
      if (mpContext.isNull()) mpContext = ctxt;
      else if (ctxt == 0) mpContext = 0;
   }

   virtual ~ASN1TPDU() {}
} ;

struct EXTRTCLASS ASN1TSeqOfList : public OSRTDList {
   inline ASN1TSeqOfList () {
      rtxDListInit (this);
   }
} ;

struct EXTRTCLASS ASN1TPDUSeqOfList : public ASN1TSeqOfList, public ASN1TPDU {
   ASN1TPDUSeqOfList () {}
} ;

#endif