asn1type.h

Go to the documentation of this file.

/*
 * Copyright (c) 1997-2018 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.
 *
 *****************************************************************************/
 /*The following is the text for the main C/C++ Runtime index page.*/
#ifndef _ASN1TYPE_H_
#define _ASN1TYPE_H_

#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <stddef.h>
#include <setjmp.h>
#include <stdlib.h> /*so that borland compilers don't choke on extern linkage*/
#ifndef _WIN32_WCE
#include <time.h>
#endif

#ifdef _NUCLEUS
#ifndef NUCLEUS
#include <nucleus.h>
#endif /* NUCLEUS */
#else

#if !defined(_MSC_VER) && !defined(__GNUC__) && !defined(_16BIT) && !defined(__SYMBIAN32__)
#include <wchar.h>
#endif

#endif /* _NUCLEUS */

#include "rtxsrc/rtxExternDefs.h"
#include "rtxsrc/rtxSList.h"
#include "rtxsrc/rtxStack.h"
#include "rtxsrc/rtxUTF8.h"


#include "rtsrc/asn1tag.h"
#include "rtsrc/asn1ErrCodes.h"
#include "rtsrc/rtExternDefs.h"

/*
 * Flags used to determine or change the behavior of encoding and
 * decoding.
 */
#define XM_SEEK         0x01

#define XM_ADVANCE      0x02

#define XM_DYNAMIC      0x04

#define XM_SKIP         0x08

#define XM_OPTIONAL     0x10

/* Sizing Constants */

#define ASN_K_MAXDEPTH  32

#define ASN_K_MAXENUM   100

#define ASN_K_MAXERRP   5

#define ASN_K_MAXERRSTK 8

#ifndef ASN_K_ENCBUFSIZ

#define ASN_K_ENCBUFSIZ 16*1024
#endif

#ifndef ASN_K_MEMBUFSEG

#define ASN_K_MEMBUFSEG 1024
#endif

#define OSRTINDENTSPACES        3

/* Constants for encoding/decoding real values */

#define ASN1_K_PLUS_INFINITY    0x40

#define ASN1_K_MINUS_INFINITY   0x41

#define ASN1_K_NOT_A_NUMBER     0x42

#define ASN1_K_MINUS_ZERO       0x43

#define REAL_BINARY             0x80
#define REAL_SIGN               0x40
#define REAL_EXPLEN_MASK        0x03
#define REAL_EXPLEN_1           0x00
#define REAL_EXPLEN_2           0x01
#define REAL_EXPLEN_3           0x02
#define REAL_EXPLEN_LONG        0x03
#define REAL_FACTOR_MASK        0x0c
#define REAL_BASE_MASK          0x30
#define REAL_BASE_2             0x00
#define REAL_BASE_8             0x10
#define REAL_BASE_16            0x20
#define REAL_ISO6093_MASK       0x3F

#ifndef __SYMBIAN32__
#include <float.h>
#define ASN1REALMAX    (OSREAL)DBL_MAX
#define ASN1REALMIN    (OSREAL)-DBL_MAX
#endif

typedef void*           ASN1ANY;

typedef enum { ASN1HEX, ASN1BIN, ASN1CHR } ASN1StrType;

typedef enum { ASN1ENCODE, ASN1DECODE } ASN1ActionType;

/*
 * OBJECT IDENTIFIER
 */
#define ASN_K_MAXSUBIDS 128     /* maximum sub-id's in an object ID     */

typedef struct {        /* object identifier */
   OSUINT32     numids;
   OSUINT32     subid[ASN_K_MAXSUBIDS];
} ASN1OBJID;

typedef struct {        /* object identifier with 64-bit arcs */
   OSUINT32     numids;
   OSUINT64     subid[ASN_K_MAXSUBIDS];
} ASN1OID64;

#ifdef __cplusplus
#define EXTERN_C extern "C"
extern "C" {
#else
#define EXTERN_C extern
#endif

EXTERNRT void  rtSetOID (ASN1OBJID* ptarget, ASN1OBJID* psource);

EXTERNRT void  rtAddOID (ASN1OBJID* ptarget, ASN1OBJID* psource);

EXTERNRT OSBOOL rtOIDsEqual (const ASN1OBJID* pOID1, const ASN1OBJID* pOID2);

EXTERNRT int rtOIDParseString
(const char* oidstr, OSSIZE oidstrlen, ASN1OBJID* pvalue);


EXTERNRT int rtRelOIDParseString
(const char* oidstr, OSSIZE oidstrlen, ASN1OBJID* pvalue);

EXTERNRT int rtOIDParseDottedNumberString
(const char* oidstr, OSSIZE oidstrlen, ASN1OBJID* pvalue);

EXTERNRT OSBOOL rtOIDIsValid (const ASN1OBJID* pvalue);

/*
 * OCTET STRING
 */
typedef struct {
   OSUINT32     numocts;
   OSOCTET      data[1];
} ASN1OctStr;

#define ASN1DynOctStr OSDynOctStr
#define ASN1DynOctStr64 OSDynOctStr64

/*
 * BIT STRING
 */
typedef struct {
   OSUINT32     numbits;
   const OSOCTET* data;
} ASN1DynBitStr;

typedef struct {
   OSSIZE numbits;
   const OSOCTET* data;
} ASN1DynBitStr64;

typedef struct {
   OSUINT32     numbits;
   OSOCTET      data[4];
} ASN1BitStr32;

#include "rtxsrc/rtxBitString.h"

#define OSSETBIT(bitStr,bitIndex) \
rtxSetBit (bitStr.data, bitStr.numbits, bitIndex)

#define OSSETBITP(pBitStr,bitIndex) \
rtxSetBit ((pBitStr)->data, (pBitStr)->numbits, bitIndex)

#define OSCLEARBIT(bitStr,bitIndex) \
rtxClearBit (bitStr.data, bitStr.numbits, bitIndex)

#define OSCLEARBITP(pBitStr,bitIndex) \
rtxClearBit ((pBitStr)->data, (pBitStr)->numbits, bitIndex)

#define OSTESTBIT(bitStr,bitIndex) \
rtxTestBit (bitStr.data, bitStr.numbits, bitIndex)

#define OSTESTBITP(pBitStr,bitIndex) \
rtxTestBit ((pBitStr)->data, (pBitStr)->numbits, bitIndex)

EXTERNRT int rtMakeGeneralizedTime (OSCTXT* pctxt,
                                    const OSNumDateTime* dateTime,
                                    char** outdata,
                                    size_t outdataSize);

EXTERNRT int rtMakeUTCTime (OSCTXT* pctxt,
                            const OSNumDateTime* dateTime,
                            char** outdata,
                            size_t outdataSize);
EXTERNRT int rtParseGeneralizedTime (OSCTXT *pctxt,
                                     const char* value,
                                     OSNumDateTime* dateTime);

EXTERNRT int rtParseUTCTime (OSCTXT *pctxt,
                             const char* value,
                             OSNumDateTime* dateTime);

EXTERNRT void normalizeTimeZone(OSNumDateTime* pvalue);

/*
 * SEQUENCE OF
 */
typedef struct {                /* generic sequence of structure        */
   OSUINT32     n;

   void*        elem;
} ASN1SeqOf;

typedef struct {                /* sequence of OCTET STRING             */
   OSUINT32     n;

   OSDynOctStr* elem;
} ASN1SeqOfOctStr;

typedef struct {                /* generic open type data structure     */
   OSSIZE       numocts;
   const OSOCTET* data;
} ASN1OpenType;

typedef struct {                /* generic table constraint value holder */
   ASN1OpenType encoded;
   void*        decoded;
   OSINT32      index;          /* table index */
} Asn1Object;

typedef Asn1Object ASN1Object;

typedef enum { OSXSDAny_binary, OSXSDAny_xmlText } OSXSDAnyAlt;
typedef struct OSXSDAny {
   OSXSDAnyAlt t;
   union {
      ASN1OpenType* binary;
      const OSUTF8CHAR* xmlText;
   } u;
} OSXSDAny;

/* ASN.1 useful type definitions */

typedef struct {
   OSSIZE       nchars;
   OSUNICHAR*   data;
} Asn116BitCharString;

typedef OSUNICHAR ASN116BITCHAR;

typedef struct {
   OSSIZE       nchars;
   OS32BITCHAR* data;
} Asn132BitCharString;

typedef const char*   ASN1GeneralizedTime;
typedef const char*   ASN1GeneralString;
typedef const char*   ASN1GraphicString;
typedef const char*   ASN1IA5String;
typedef const char*   ASN1ISO646String;
typedef const char*   ASN1NumericString;
typedef const char*   ASN1ObjectDescriptor;
typedef const char*   ASN1PrintableString;
typedef const char*   ASN1TeletexString;
typedef const char*   ASN1T61String;
typedef const char*   ASN1UTCTime;
typedef const char*   ASN1VideotexString;
typedef const char*   ASN1VisibleString;

typedef const OSUTF8CHAR*   ASN1UTF8String;
typedef Asn116BitCharString ASN1BMPString;
typedef Asn132BitCharString ASN1UniversalString;

/* ASN.1 constrained string structures */

typedef struct {
   int          nchars;
   char         data[255];
} Asn1CharArray;

typedef struct {
   Asn1CharArray charSet;

   const char*  canonicalSet;

   int          canonicalSetSize;

   unsigned     canonicalSetBits;

   unsigned     charSetUnalignedBits;

   unsigned     charSetAlignedBits;
} Asn1CharSet;

typedef struct {
   Asn116BitCharString charSet;

   OSUINT16     firstChar, lastChar;

   unsigned     unalignedBits;

   unsigned     alignedBits;
} Asn116BitCharSet;

typedef struct {
   Asn132BitCharString charSet;

   OSUINT32     firstChar, lastChar;

   unsigned     unalignedBits;

   unsigned     alignedBits;
} Asn132BitCharSet;

/* Helper functions. */

EXTERNRT int rtValidateStr (ASN1TAG tag, const char *pdata);

EXTERNRT int rtValidateChars (ASN1TAG tag, const char* pdata, size_t nchars);

/* 16-bit character functions */

EXTERNRT const char* rtBMPToCString (ASN1BMPString* pBMPString,
                                     char* cstring, OSSIZE cstrsize);

EXTERNRT const char* rtBMPToNewCString (ASN1BMPString* pBMPString);

EXTERNRT const char* rtBMPToNewCStringEx
   (OSCTXT *pctxt, ASN1BMPString* pBMPString);

EXTERNRT ASN1BMPString* rtCToBMPString (OSCTXT* pctxt,
                                         const char* cstring,
                                         ASN1BMPString* pBMPString,
                                         Asn116BitCharSet* pCharSet);

EXTERNRT OSBOOL rtIsIn16BitCharSet (OSUNICHAR ch,
                                     Asn116BitCharSet* pCharSet);

/* 32-bit character (UCS-4) functions */


EXTERNRT const char* rtUCSToCString (ASN1UniversalString* pUCSString,
                                     char* cstring, OSSIZE cstrsize);

EXTERNRT const char* rtUCSToNewCString (ASN1UniversalString* pUCSString);

EXTERNRT const char* rtUCSToNewCStringEx
(OSCTXT* pctxt, ASN1UniversalString* pUCSString);

EXTERNRT ASN1UniversalString* rtCToUCSString
(OSCTXT* pctxt, const char* cstring, ASN1UniversalString* pUCSString,
 Asn132BitCharSet* pCharSet);


EXTERNRT OSBOOL rtIsIn32BitCharSet (OS32BITCHAR ch,
                                     Asn132BitCharSet* pCharSet);

EXTERNRT wchar_t* rtUCSToWCSString (ASN1UniversalString* pUCSString,
                                    wchar_t* wcstring, OSUINT32 wcstrsize);


EXTERNRT ASN1UniversalString* rtWCSToUCSString
(OSCTXT* pctxt, wchar_t* wcstring,
 ASN1UniversalString* pUCSString, Asn132BitCharSet* pCharSet);

EXTERNRT int rtUnivStrToUTF8
(OSCTXT* pctxt, const ASN1UniversalString* pUnivStr, OSOCTET* outbuf,
 size_t outbufsiz);

EXTERNRT int rtUTF8StrToASN1DynBitStr
   (OSCTXT* pctxt, const OSUTF8CHAR* utf8str, ASN1DynBitStr* pvalue);

EXTERNRT int rtUTF8StrnToASN1DynBitStr
   (OSCTXT* pctxt, const OSUTF8CHAR* utf8str, size_t nbytes,
   ASN1DynBitStr* pvalue);

typedef struct ASN1BigInt {
   size_t    numocts;

   OSOCTET*  mag;

   int       sign;

   size_t    allocated;

   OSBOOL    dynamic;
} ASN1BigInt;

#define ASN1_K_CCBMaskSize      32

#define ASN1_K_NumBitsPerMask   16

#define ASN1_K_MaxSetElements   (ASN1_K_CCBMaskSize*ASN1_K_NumBitsPerMask)

typedef struct {
   OSOCTET*     ptr;

   long         len;

   int          seqx;

   OSUINT16     mask[ASN1_K_CCBMaskSize];

   OSSIZE       bytes;

   int          stat;
} ASN1CCB;

typedef int (*ASN1DumpCbFunc) (const char* text_p, void* cbArg_p);


#define ALLOC_ASN1ARRAY(pctxt,pseqof,type) do {\
if (sizeof(type)*(pseqof)->n < (pseqof)->n) return RTERR_NOMEM; \
if (((pseqof)->elem = (type*) rtxMemHeapAllocZ \
(&(pctxt)->pMemHeap, sizeof(type)*(pseqof)->n)) == 0) return RTERR_NOMEM; \
} while (0)

#define ALLOC_ASN1ARRAY1(pctxt,pseqof,type) do {\
if (sizeof(type)*(pseqof)->n < (pseqof)->n) (pseqof)->elem = 0; \
else (pseqof)->elem = (type*) rtxMemHeapAllocZ \
(&(pctxt)->pMemHeap, sizeof(type)*(pseqof)->n); \
} while (0)

#define ASN1NUMOCTS(nbits)      ((nbits>0)?(((nbits-1)/8)+1):0)

#ifdef __cplusplus
}
#endif

#include "rtsrc/rtContext.h"
#include "rtxsrc/rtxCommonDefs.h"
#include "rtxsrc/rtxError.h"
#include "rtxsrc/rtxMemory.h"

#endif