asn1type.h

Go to the documentation of this file.

/*
 * Copyright (c) 1997-2020 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)

#define ASN1TIMEFIELD_CENTURY 0x01
#define ASN1TIMEFIELD_YEAR 0x02
#define ASN1TIMEFIELD_MONTH 0x04
#define ASN1TIMEFIELD_DAY 0x08
#define ASN1TIMEFIELD_WEEK 0x10
#define ASN1TIMEFIELD_HOUR 0x20
#define ASN1TIMEFIELD_MIN 0x40
#define ASN1TIMEFIELD_SEC 0x80
#define ASN1TIMEFIELD_Z 0x0100
#define ASN1TIMEFIELD_DIFF 0x0200
#define ASN1TIMEFIELD_INTERVAL_SE 0x0400
#define ASN1TIMEFIELD_DURATION 0x0800
#define ASN1TIMEFIELD_INTERVAL_SD 0x1000
#define ASN1TIMEFIELD_INTERVAL_DE 0x2000
#define ASN1TIMEFIELD_RECUR_INF 0x4000

/* ASN1TIMEFIELD_POINT includes all the settings that would be set for a
   point in time (date, time-of-day or both) except for timezone diff. */
#define ASN1TIMEFIELD_POINT (ASN1TIMEFIELD_CENTURY | ASN1TIMEFIELD_YEAR | \
      ASN1TIMEFIELD_MONTH | ASN1TIMEFIELD_DAY | ASN1TIMEFIELD_WEEK | \
      ASN1TIMEFIELD_HOUR | ASN1TIMEFIELD_MIN | ASN1TIMEFIELD_SEC | \
      ASN1TIMEFIELD_Z)

typedef struct ASN1DateTime
{
   OSINT32 century;
   OSINT32 year;
   OSUINT8 month;
   OSUINT8 week;
   OSUINT8 day;
   OSUINT8 hour;
   OSUINT8 min;
   OSUINT8 sec;
   OSUINT8 fracDigits;
   OSUINT32 fracValue;
   OSINT8 timezoneDifffHours;
   OSUINT8 timezoneDiffMins;
} ASN1DateTime;

typedef struct ASN1Duration
{
   OSUINT32 years;
   OSUINT32 months;
   OSUINT32 weeks;
   OSUINT32 days;
   OSUINT32 hours;
   OSUINT32 mins;
   OSUINT32 secs;
   OSUINT8 fracDigits;
   OSUINT32 fracValue;
   OSUINT8 precision;   /* 1 = years, 2 = months etc., in the order in which
                     the componentas appear above.  This indicates which
                     is the last component present. If fracDigits != 0,
                     this tells you what component the fraction belongs to.
                     Fields which are more precise than indicated by precision
                     MUST be set to zero. */
} ASN1Duration;

typedef struct ASN1IntervalDE
{
   ASN1Duration duration;
   ASN1DateTime end;
} ASN1IntervalDE;

typedef struct ASN1IntervalSE
{
   ASN1DateTime start;
   ASN1DateTime end;
} ASN1IntervalSE;

typedef struct ASN1IntervalSD
{
   ASN1DateTime start;
   ASN1Duration duration;
} ASN1IntervalSD;

typedef struct ASN1Interval
{
   union {
      ASN1Duration duration;
      ASN1IntervalDE de;
      ASN1IntervalSE se;
      ASN1IntervalSD sd;
   } spec;
   OSUINT32 recurrences;
} ASN1Interval;


typedef struct ASN1Time
{
   OSUINT16 settings;

   union {
      /* dateTime is use for abstract values that are only a date, a
      time-of-day or a date and a time-of-day.*/
      ASN1DateTime dateTime;

      /* interval is used for abstract values that are an interval.
      If the interval has two points (start and end), they must use the same
      settings.
      The interval may be infinitely recurring (ASN1TIMEFIELD_RECUR_INF is
      set in settings), finitely recurring (recurrences != 0), or
      non-recurring (recurrences == 0).
      The bit fields ASN1TIMEFIELD_DURATION, ASN1TIMEFIELD_INTERVAL_SD,
      ASN1TIMEFIELD_INTERVAL_SE, and ASN1TIMEFIELD_INTERVAL_DE in settings are
      used to distinguish the four possible cases.
      */
      ASN1Interval interval;
   } val;
} ASN1Time;


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

EXTERNRT int rtMakeTime(OSCTXT* pctxt,
   const ASN1Time* timeVal,
   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 rtParseGeneralizedTime2(OSCTXT *pctxt,
   const char* value,
   OSNumDateTime* dateTime,
   OSBOOL logCanon);

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

EXTERNRT int rtParseUTCTime2(OSCTXT *pctxt,
   const char* value,
   OSNumDateTime* dateTime, OSBOOL logCanon);


EXTERNRT int rtParseTime(OSCTXT* pctxt, const char* value, ASN1Time* timeVal,
                           OSBOOL logCanon);


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);
 // close the cruntime group.  We reopen it later.

/*
I don't know why the following memory allocation macros are defined here.  They
seem to belong to the rtmem group, so I've designated that here.
If we don't close the cruntime group first, the rtmem group will become a
subgroup of the cruntime group.
*/

#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)
      //Reopen the cruntime group.
#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