windows-nt/Source/XPSP1/NT/enduser/msasn1/berdecod.c
2020-09-26 16:20:57 +08:00

1961 lines
61 KiB
C

/* Copyright (C) Boris Nikolaus, Germany, 1996-1997. All rights reserved. */
/* Copyright (C) Microsoft Corporation, 1997-1998. All rights reserved. */
#include "precomp.h"
#ifdef ENABLE_BER
#include <math.h>
static const char bitmsk2[] =
{
(const char) 0x00,
(const char) 0x80,
(const char) 0xc0,
(const char) 0xe0,
(const char) 0xf0,
(const char) 0xf8,
(const char) 0xfc,
(const char) 0xfe
};
/* decode bit string value */
int _BERDecBitString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1bitstring_t *val, ASN1uint32_t fNoCopy)
{
ASN1uint32_t constructed, len, infinite;
ASN1bitstring_t b;
ASN1decoding_t dd;
ASN1octet_t *di;
/* skip tag */
if (ASN1BERDecTag(dec, tag, &constructed))
{
/* get length */
if (ASN1BERDecLength(dec, &len, &infinite))
{
if (constructed)
{
/* constructed? then start decoding of constructed value */
val->length = 0;
if (_BERDecConstructed(dec, len, infinite, &dd, &di))
{
while (ASN1BERDecNotEndOfContents(dd, di))
{
if (_BERDecBitString(dd, 0x3, &b, fNoCopy))
{
if (b.length)
{
if (fNoCopy)
{
*val = b;
break; // break out the loop because nocopy cannot have multiple constructed streams
}
/* resize value */
val->value = (ASN1octet_t *)DecMemReAlloc(dd, val->value,
(val->length + b.length + 7) / 8);
if (val->value)
{
/* concat bit strings */
ASN1bitcpy(val->value, val->length, b.value, 0, b.length);
val->length += b.length;
if (val->length & 7)
val->value[val->length / 8] &= bitmsk2[val->length & 7];
/* free unused bit string */
DecMemFree(dec, b.value);
}
else
{
return 0;
}
}
}
} // while
return ASN1BERDecEndOfContents(dec, dd, di);
}
}
else
{
/* primitive? then copy value */
if (!len)
{
val->length = 0;
val->value = NULL;
return 1;
}
else
{
if (*dec->pos < 8)
{
len--; // skip over the initial octet; len is now the actual length of octets
val->length = len * 8 - *dec->pos++;
if (fNoCopy)
{
val->value = dec->pos;
dec->pos += len;
return 1;
}
else
{
if (val->length)
{
val->value = (ASN1octet_t *)DecMemAlloc(dec, (val->length + 7) / 8);
if (val->value)
{
CopyMemory(val->value, dec->pos, len);
if (val->length & 7)
val->value[len - 1] &= bitmsk2[val->length & 7];
dec->pos += len;
return 1;
}
}
else
{
val->value = NULL;
return 1;
}
}
}
else
{
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
}
}
}
}
}
return 0;
}
/* decode bit string value, making copy */
int ASN1BERDecBitString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1bitstring_t *val)
{
return _BERDecBitString(dec, tag, val, FALSE);
}
/* decode bit string value, no copy */
int ASN1BERDecBitString2(ASN1decoding_t dec, ASN1uint32_t tag, ASN1bitstring_t *val)
{
return _BERDecBitString(dec, tag, val, TRUE);
}
/* decode string value */
int ASN1BERDecCharString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1charstring_t *val)
{
ASN1uint32_t constructed, len, infinite;
ASN1charstring_t c;
ASN1decoding_t dd;
ASN1octet_t *di;
/* skip tag */
if (ASN1BERDecTag(dec, tag, &constructed))
{
/* get length */
if (ASN1BERDecLength(dec, &len, &infinite))
{
if (constructed)
{
/* constructed? then start decoding of constructed value */
val->length = 0;
if (_BERDecConstructed(dec, len, infinite, &dd, &di))
{
while (ASN1BERDecNotEndOfContents(dd, di))
{
if (ASN1BERDecCharString(dd, 0x4, &c))
{
if (c.length)
{
/* resize value */
val->value = (char *)DecMemReAlloc(dd, val->value,
val->length + c.length);
if (val->value)
{
/* concat strings */
CopyMemory(val->value + val->length, c.value, c.length);
val->length += c.length;
/* free unused string */
DecMemFree(dec, c.value);
}
else
{
return 0;
}
}
}
else
{
return 0;
}
} // while
return ASN1BERDecEndOfContents(dec, dd, di);
}
}
else
{
/* primitive? then copy value */
val->length = len;
if (len)
{
val->value = (char *)DecMemAlloc(dec, len+1);
if (val->value)
{
CopyMemory(val->value, dec->pos, len);
dec->pos += len;
val->value[len] = 0;
return 1;
}
}
else
{
val->value = NULL;
return 1;
}
}
}
}
return 0;
}
/* decode 16 bit string value */
int ASN1BERDecChar16String(ASN1decoding_t dec, ASN1uint32_t tag, ASN1char16string_t *val)
{
ASN1uint32_t constructed, len, infinite;
ASN1char16string_t c;
ASN1decoding_t dd;
ASN1octet_t *di;
ASN1uint32_t i;
/* skip tag */
if (ASN1BERDecTag(dec, tag, &constructed))
{
/* get length */
if (ASN1BERDecLength(dec, &len, &infinite))
{
if (constructed)
{
/* constructed? then start decoding of constructed value */
val->length = 0;
if (_BERDecConstructed(dec, len, infinite, &dd, &di))
{
while (ASN1BERDecNotEndOfContents(dd, di))
{
if (ASN1BERDecChar16String(dd, 0x4, &c))
{
if (c.length)
{
/* resize value */
val->value = (ASN1char16_t *)DecMemReAlloc(dd, val->value,
(val->length + c.length) * sizeof(ASN1char16_t));
if (val->value)
{
/* concat strings */
CopyMemory(val->value + val->length, c.value,
c.length * sizeof(ASN1char16_t));
val->length += c.length;
/* free unused string */
DecMemFree(dec, c.value);
}
else
{
return 0;
}
}
}
else
{
return 0;
}
}
return ASN1BERDecEndOfContents(dec, dd, di);
}
}
else
{
/* primitive? then copy value */
DecAssert(dec, 2 * sizeof(ASN1octet_t) == sizeof(ASN1char16_t));
len = len >> 1; // divided by 2
val->length = len;
if (len)
{
val->value = (ASN1char16_t *)DecMemAlloc(dec, (len+1) * sizeof(ASN1char16_t));
if (val->value)
{
for (i = 0; i < len; i++)
{
val->value[i] = (*dec->pos << 8) | dec->pos[1];
dec->pos += 2;
}
val->value[len] = 0;
return 1;
}
}
else
{
val->value = NULL;
return 1;
}
}
}
}
return 0;
}
/* decode 32 bit string value */
int ASN1BERDecChar32String(ASN1decoding_t dec, ASN1uint32_t tag, ASN1char32string_t *val)
{
ASN1uint32_t constructed, len, infinite;
ASN1char32string_t c;
ASN1decoding_t dd;
ASN1octet_t *di;
ASN1uint32_t i;
/* skip tag */
if (ASN1BERDecTag(dec, tag, &constructed))
{
/* get length */
if (ASN1BERDecLength(dec, &len, &infinite))
{
if (constructed)
{
/* constructed? then start decoding of constructed value */
val->length = 0;
if (_BERDecConstructed(dec, len, infinite, &dd, &di))
{
while (ASN1BERDecNotEndOfContents(dd, di))
{
if (ASN1BERDecChar32String(dd, 0x4, &c))
{
if (c.length)
{
/* resize value */
val->value = (ASN1char32_t *)DecMemReAlloc(dd, val->value,
(val->length + c.length) * sizeof(ASN1char32_t));
if (val->value)
{
/* concat strings */
CopyMemory(val->value + val->length, c.value,
c.length * sizeof(ASN1char32_t));
val->length += c.length;
/* free unused string */
DecMemFree(dec, c.value);
}
else
{
return 0;
}
}
}
else
{
return 0;
}
}
return ASN1BERDecEndOfContents(dec, dd, di);
}
}
else
{
/* primitive? then copy value */
DecAssert(dec, 4 * sizeof(ASN1octet_t) == sizeof(ASN1char32_t));
len = len >> 2; // divided by 4
val->length = len;
if (len)
{
val->value = (ASN1char32_t *)DecMemAlloc(dec, (len+1) * sizeof(ASN1char32_t));
if (val->value)
{
for (i = 0; i < len; i++)
{
val->value[i] = (*dec->pos << 24) | (dec->pos[1] << 16) |
(dec->pos[2] << 8) | dec->pos[3];;
dec->pos += 4;
}
val->value[len] = 0;
return 1;
}
}
else
{
val->value = NULL;
return 1;
}
}
}
}
return 0;
}
#ifdef ENABLE_GENERALIZED_CHAR_STR
/* decode character string value */
int ASN1BERDecCharacterString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1characterstring_t *val)
{
ASN1INTERNdecoding_t d = (ASN1INTERNdecoding_t) dec;
ASN1uint32_t constructed, len, infinite;
ASN1uint32_t index;
ASN1characterstring_identification_t *identification;
ASN1decoding_t dd, dd2, dd3;
ASN1octet_t *di, *di2, *di3;
/* skip tag */
if (!ASN1BERDecTag(dec, tag, &constructed))
return 0;
if (constructed)
{
/* constructed? CS-A encoded: */
/* get length */
if (!ASN1BERDecLength(dec, &len, &infinite))
return 0;
/* start decoding of constructed value */
if (! _BERDecConstructed(dec, len, infinite, &dd, &di))
return 0;
if (!ASN1BERDecU32Val(dd, 0x80000000, &index))
return 0;
if (index != d->parent->csilength)
{
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
return 0;
}
if (!ASN1BERDecExplicitTag(dd, 0x80000001, &dd2, &di2))
return 0;
if (!ASN1BERDecPeekTag(dd2, &tag))
return 0;
switch (tag)
{
case 0x80000000:
val->identification.o =
ASN1characterstring_identification_syntaxes_o;
if (!ASN1BERDecExplicitTag(dd2, 0x80000000, &dd3, &di3))
return 0;
if (!ASN1BERDecObjectIdentifier(dd3, 0x80000000,
&val->identification.u.syntaxes.abstract))
return 0;
if (!ASN1BERDecObjectIdentifier(dd3, 0x80000001,
&val->identification.u.syntaxes.transfer))
return 0;
if (!ASN1BERDecEndOfContents(dd2, dd3, di3))
return 0;
break;
case 0x80000001:
val->identification.o = ASN1characterstring_identification_syntax_o;
if (!ASN1BERDecObjectIdentifier(dd2, 0x80000001,
&val->identification.u.syntax))
return 0;
break;
case 0x80000002:
val->identification.o =
ASN1characterstring_identification_presentation_context_id_o;
if (!ASN1BERDecU32Val(dd2, 0x80000002,
&val->identification.u.presentation_context_id))
return 0;
break;
case 0x80000003:
val->identification.o =
ASN1characterstring_identification_context_negotiation_o;
if (!ASN1BERDecExplicitTag(dd2, 0x80000003, &dd3, &di3))
return 0;
if (!ASN1BERDecU32Val(dd3, 0x80000000, &val->
identification.u.context_negotiation.presentation_context_id))
return 0;
if (!ASN1BERDecObjectIdentifier(dd3, 0x80000001,
&val->identification.u.context_negotiation.transfer_syntax))
return 0;
if (!ASN1BERDecEndOfContents(dd2, dd3, di3))
return 0;
break;
case 0x80000004:
val->identification.o =
ASN1characterstring_identification_transfer_syntax_o;
if (!ASN1BERDecObjectIdentifier(dd2, 0x80000004,
&val->identification.u.transfer_syntax))
return 0;
break;
case 0x80000005:
val->identification.o = ASN1characterstring_identification_fixed_o;
if (!ASN1BERDecNull(dd2, 0x80000005))
return 0;
break;
default:
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
return 0;
}
if (!ASN1BERDecEndOfContents(dd, dd2, di2))
return 0;
if (!ASN1DecAddCharacterStringIdentification(d->parent,
&val->identification))
return 0;
val->data_value.o = ASN1characterstring_data_value_encoded_o;
if (!ASN1BERDecOctetString(dd, 0x80000003,
&val->data_value.u.encoded))
return 0;
if (!ASN1BERDecEndOfContents(dec, dd, di))
return 0;
}
else
{
/* primitive? CS-B encoded */
/* get length */
if (!ASN1BERDecLength(dec, &len, NULL))
return 0;
/* then copy value */
if (!len)
{
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
return 0;
}
val->data_value.o = ASN1characterstring_data_value_encoded_o;
val->data_value.u.encoded.length = len - 1;
val->data_value.u.encoded.value = (ASN1octet_t *)DecMemAlloc(dec, len - 1);
if (!val->data_value.u.encoded.value)
{
return 0;
}
index = *dec->pos++;
CopyMemory(val->data_value.u.encoded.value, dec->pos, len - 1);
identification = ASN1DecGetCharacterStringIdentification(d->parent,
index);
if (!identification)
return 0;
val->identification.o = identification->o;
switch (identification->o)
{
case ASN1characterstring_identification_syntaxes_o:
if (!ASN1DecDupObjectIdentifier(dec,
&val->identification.u.syntaxes.abstract,
&identification->u.syntaxes.abstract))
return 0;
if (!ASN1DecDupObjectIdentifier(dec,
&val->identification.u.syntaxes.transfer,
&identification->u.syntaxes.transfer))
return 0;
break;
case ASN1characterstring_identification_syntax_o:
if (!ASN1DecDupObjectIdentifier(dec,
&val->identification.u.syntax,
&identification->u.syntax))
return 0;
break;
case ASN1characterstring_identification_presentation_context_id_o:
val->identification.u.presentation_context_id =
identification->u.presentation_context_id;
break;
case ASN1characterstring_identification_context_negotiation_o:
val->identification.u.context_negotiation.presentation_context_id =
identification->u.context_negotiation.presentation_context_id;
if (!ASN1DecDupObjectIdentifier(dec,
&val->identification.u.context_negotiation.transfer_syntax,
&identification->u.context_negotiation.transfer_syntax))
return 0;
break;
case ASN1characterstring_identification_transfer_syntax_o:
if (!ASN1DecDupObjectIdentifier(dec,
&val->identification.u.transfer_syntax,
&identification->u.transfer_syntax))
return 0;
break;
case ASN1characterstring_identification_fixed_o:
break;
}
}
return 1;
}
#endif // ENABLE_GENERALIZED_CHAR_STR
#ifdef ENABLE_DOUBLE
/* decode real value */
int ASN1BERDecDouble(ASN1decoding_t dec, ASN1uint32_t tag, double *val)
{
ASN1uint32_t head;
ASN1int32_t exponent;
ASN1uint32_t baselog2;
ASN1uint32_t len;
ASN1uint32_t i;
ASN1octet_t *p, *q;
double v;
char buf[256], *b;
/* skip tag */
if (!ASN1BERDecTag(dec, tag, NULL))
return 0;
/* get length */
if (!ASN1BERDecLength(dec, &len, NULL))
return 0;
/* null length is 0.0 */
if (!len)
{
*val = 0.0;
}
else
{
p = q = dec->pos;
dec->pos += len;
head = *p++;
/* binary encoding? */
if (head & 0x80)
{
/* get base */
switch (head & 0x30)
{
case 0:
/* base 2 */
baselog2 = 1;
break;
case 0x10:
/* base 8 */
baselog2 = 3;
break;
case 0x20:
/* base 16 */
baselog2 = 4;
break;
default:
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
return 0;
}
/* get exponent */
switch (head & 0x03)
{
case 0:
/* 8 bit exponent */
exponent = (ASN1int8_t)*p++;
break;
case 1:
/* 16 bit exponent */
exponent = (ASN1int16_t)((*p << 8) | p[1]);
p += 2;
break;
case 2:
/* 24 bit exponent */
exponent = ((*p << 16) | (p[1] << 8) | p[2]);
if (exponent & 0x800000)
exponent -= 0x1000000;
break;
default:
/* variable length exponent */
exponent = (p[1] & 0x80) ? -1 : 0;
for (i = 1; i <= *p; i++)
exponent = (exponent << 8) | p[i];
p += *p + 1;
break;
}
/* calculate remaining length */
len -= (ASN1uint32_t) (p - q);
/* get mantissa */
v = 0.0;
for (i = 0; i < len; i++)
v = v * 256.0 + *p++;
/* scale mantissa */
switch (head & 0x0c)
{
case 0x04:
/* scaling factor 1 */
v *= 2.0;
break;
case 0x08:
/* scaling factor 2 */
v *= 4.0;
break;
case 0x0c:
/* scaling factor 3 */
v *= 8.0;
break;
}
/* check sign */
if (head & 0x40)
v = -v;
/* calculate value */
*val = ldexp(v, exponent * baselog2);
}
else
/* special real values? */
if (head & 0x40)
{
switch (head)
{
case 0x40:
/* PLUS-INFINITY */
*val = ASN1double_pinf();
break;
case 0x41:
/* MINUS-INFINITY */
*val = ASN1double_minf();
break;
default:
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
return 0;
}
}
/* decimal encoding */
else
{
CopyMemory(buf, p, len - 1);
buf[len - 1] = 0;
b = strchr(buf, ',');
if (b)
*b = '.';
*val = strtod((char *)buf, &b);
if (*b)
{
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
return 0;
}
}
}
return 1;
}
#endif // ENABLE_DOUBLE
#ifdef ENABLE_REAL
int ASN1BERDecReal(ASN1decoding_t dec, ASN1uint32_t tag, ASN1real_t *val)
{
ASN1uint32_t head;
ASN1int32_t ex;
// ASN1intx_t exponent;
ASN1uint32_t baselog2;
ASN1uint32_t len;
ASN1uint32_t i;
ASN1octet_t *p, *q;
double v;
ASN1intx_t help;
if (!ASN1BERDecTag(dec, tag, NULL))
return 0;
if (!ASN1BERDecLength(dec, &len, NULL))
return 0;
// *val = 0.0;
DecAssert(dec, 0 == (int) eReal_Normal);
ZeroMemory(val, sizeof(*val));
if (len)
{
p = q = dec->pos;
dec->pos += len;
head = *p++;
/* binary encoding? */
if (head & 0x80)
{
val->type = eReal_Normal;
/* get base */
switch (head & 0x30)
{
case 0:
/* base 2 */
baselog2 = 1;
break;
case 0x10:
/* base 8 */
baselog2 = 3;
break;
case 0x20:
/* base 16 */
baselog2 = 4;
break;
default:
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
return 0;
}
/* get exponent */
switch (head & 0x03)
{
case 0:
/* 8 bit exponent */
ex = (ASN1int8_t)*p++;
ASN1intx_setint32(&val->exponent, ex);
break;
case 1:
/* 16 bit exponent */
ex = (ASN1int16_t)((*p << 8) | p[1]);
p += 2;
// ASN1intx_setint32_t(&exponent, ex);
ASN1intx_setint32(&val->exponent, ex);
break;
case 2:
/* 24 bit exponent */
ex = ((*p << 16) | (p[1] << 8) | p[2]);
if (ex & 0x800000)
ex -= 0x1000000;
// ASN1intx_setint32_t(&exponent, ex);
ASN1intx_setint32(&val->exponent, ex);
break;
default:
/* variable length exponent */
val->exponent.length = *p;
val->exponent.value = (ASN1octet_t *)DecMemAlloc(dec, *p);
if (!val->exponent.value)
{
return 0;
}
CopyMemory(val->exponent.value, p + 1, *p);
p += *p + 1;
break;
}
/* calculate remaining length */
len -= (p - q);
if (!len)
{
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
return 0;
}
/* get mantissa */
val->mantissa.length = (*p & 0x80) ? len + 1 : len;
val->mantissa.value = (ASN1octet_t *)DecMemAlloc(dec, val->mantissa.length);
if (!val->mantissa.value)
{
return 0;
}
val->mantissa.value[0] = 0;
CopyMemory(val->mantissa.value + val->mantissa.length - len, p, len);
/* scale mantissa */
switch (head & 0x0c)
{
case 0x04:
/* scaling factor 1 */
ASN1intx_muloctet(&help, &val->mantissa, 2);
ASN1intx_free(&val->mantissa);
val->mantissa = help;
break;
case 0x08:
/* scaling factor 2 */
ASN1intx_muloctet(&help, &val->mantissa, 4);
ASN1intx_free(&val->mantissa);
val->mantissa = help;
break;
case 0x0c:
/* scaling factor 3 */
ASN1intx_muloctet(&help, &val->mantissa, 8);
ASN1intx_free(&val->mantissa);
val->mantissa = help;
break;
}
/* check sign */
if (head & 0x40)
{
ASN1intx_neg(&help, &val->mantissa);
ASN1intx_free(&val->mantissa);
val->mantissa = help;
}
}
else
/* special real values? */
if (head & 0x40)
{
switch (head)
{
case 0x40:
/* PLUS-INFINITY */
val->type = eReal_PlusInfinity;
break;
case 0x41:
/* MINUS-INFINITY */
val->type = eReal_MinusInfinity;
break;
default:
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
return 0;
}
}
/* decimal encoding */
else
{
char *b;
char buf[256];
DecAssert(dec, (head & 0xc0) == 0xc0);
CopyMemory(buf, p, len - 1);
buf[len - 1] = 0;
ex = 0;
b = strchr(buf, ',');
if (b)
{
// move the decimal point to the right
ex -= lstrlenA(b+1);
lstrcpyA(b, b+1);
}
// skip leading zeros
for (b = &buf[0]; '0' == *b; b++)
;
val->type = eReal_Normal;
val->base = 10;
ASN1intx_setint32(&val->exponent, ex);
/*XXX*/
// missing code here!!!
// need to set val->mantissa through the decimal digits string
DecAssert(dec, 0);
return 0;
}
}
return 1;
}
#endif // ENABLE_REAL
#ifdef ENABLE_EMBEDDED_PDV
/* decode embedded pdv value */
int ASN1BERDecEmbeddedPdv(ASN1decoding_t dec, ASN1uint32_t tag, ASN1embeddedpdv_t *val)
{
ASN1INTERNdecoding_t d = (ASN1INTERNdecoding_t) dec;
ASN1uint32_t constructed, len, infinite;
ASN1uint32_t index;
ASN1embeddedpdv_identification_t *identification;
ASN1decoding_t dd, dd2, dd3;
ASN1octet_t *di, *di2, *di3;
/* skip tag */
if (!ASN1BERDecTag(dec, tag, &constructed))
return 0;
if (constructed)
{
/* constructed? EP-A encoded: */
/* get length */
if (!ASN1BERDecLength(dec, &len, &infinite))
return 0;
/* then start decoding of constructed value */
if (! _BERDecConstructed(dec, len, infinite, &dd, &di))
return 0;
if (!ASN1BERDecU32Val(dd, 0x80000000, &index))
return 0;
if (index != d->parent->epilength)
{
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
return 0;
}
if (!ASN1BERDecExplicitTag(dd, 0x80000001, &dd2, &di2))
return 0;
if (!ASN1BERDecPeekTag(dd2, &tag))
return 0;
switch (tag)
{
case 0x80000000:
val->identification.o = ASN1embeddedpdv_identification_syntaxes_o;
if (!ASN1BERDecExplicitTag(dd2, 0x80000000, &dd3, &di3))
return 0;
if (!ASN1BERDecObjectIdentifier(dd3, 0x80000000,
&val->identification.u.syntaxes.abstract))
return 0;
if (!ASN1BERDecObjectIdentifier(dd3, 0x80000001,
&val->identification.u.syntaxes.transfer))
return 0;
if (!ASN1BERDecEndOfContents(dd2, dd3, di3))
return 0;
break;
case 0x80000001:
val->identification.o = ASN1embeddedpdv_identification_syntax_o;
if (!ASN1BERDecObjectIdentifier(dd2, 0x80000001,
&val->identification.u.syntax))
return 0;
break;
case 0x80000002:
val->identification.o =
ASN1embeddedpdv_identification_presentation_context_id_o;
if (!ASN1BERDecU32Val(dd2, 0x80000002,
&val->identification.u.presentation_context_id))
return 0;
break;
case 0x80000003:
val->identification.o =
ASN1embeddedpdv_identification_context_negotiation_o;
if (!ASN1BERDecExplicitTag(dd2, 0x80000003, &dd3, &di3))
return 0;
if (!ASN1BERDecU32Val(dd3, 0x80000000, &val->
identification.u.context_negotiation.presentation_context_id))
return 0;
if (!ASN1BERDecObjectIdentifier(dd3, 0x80000001,
&val->identification.u.context_negotiation.transfer_syntax))
return 0;
if (!ASN1BERDecEndOfContents(dd2, dd3, di3))
return 0;
break;
case 0x80000004:
val->identification.o =
ASN1embeddedpdv_identification_transfer_syntax_o;
if (!ASN1BERDecObjectIdentifier(dd2, 0x80000004,
&val->identification.u.transfer_syntax))
return 0;
break;
case 0x80000005:
val->identification.o = ASN1embeddedpdv_identification_fixed_o;
if (!ASN1BERDecNull(dd2, 0x80000005))
return 0;
break;
default:
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
return 0;
}
if (!ASN1BERDecEndOfContents(dd, dd2, di2))
return 0;
if (!ASN1DecAddEmbeddedPdvIdentification(d->parent,
&val->identification))
return 0;
val->data_value.o = ASN1embeddedpdv_data_value_encoded_o;
if (!ASN1BERDecBitString(dd, 0x80000003,
&val->data_value.u.encoded))
return 0;
if (!ASN1BERDecEndOfContents(dec, dd, di))
return 0;
}
else
{
/* primitive? EP-B encoded: */
if (!ASN1BERDecLength(dec, &len, NULL))
return 0;
/* then copy value */
if (!len)
{
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
return 0;
}
val->data_value.o = ASN1embeddedpdv_data_value_encoded_o;
val->data_value.u.encoded.length = 8 * (len - 1);
val->data_value.u.encoded.value = (ASN1octet_t *)DecMemAlloc(dec, len - 1);
if (!val->data_value.u.encoded.value)
{
return 0;
}
index = *dec->pos++;
CopyMemory(val->data_value.u.encoded.value, dec->pos, len - 1);
identification = ASN1DecGetEmbeddedPdvIdentification(d->parent, index);
if (!identification)
return 0;
val->identification.o = identification->o;
switch (identification->o)
{
case ASN1embeddedpdv_identification_syntaxes_o:
if (!ASN1DecDupObjectIdentifier(dec,
&val->identification.u.syntaxes.abstract,
&identification->u.syntaxes.abstract))
return 0;
if (!ASN1DecDupObjectIdentifier(dec,
&val->identification.u.syntaxes.transfer,
&identification->u.syntaxes.transfer))
return 0;
break;
case ASN1embeddedpdv_identification_syntax_o:
if (!ASN1DecDupObjectIdentifier(dec,
&val->identification.u.syntax,
&identification->u.syntax))
return 0;
break;
case ASN1embeddedpdv_identification_presentation_context_id_o:
val->identification.u.presentation_context_id =
identification->u.presentation_context_id;
break;
case ASN1embeddedpdv_identification_context_negotiation_o:
val->identification.u.context_negotiation.presentation_context_id =
identification->u.context_negotiation.presentation_context_id;
if (!ASN1DecDupObjectIdentifier(dec,
&val->identification.u.context_negotiation.transfer_syntax,
&identification->u.context_negotiation.transfer_syntax))
return 0;
break;
case ASN1embeddedpdv_identification_transfer_syntax_o:
if (!ASN1DecDupObjectIdentifier(dec,
&val->identification.u.transfer_syntax,
&identification->u.transfer_syntax))
return 0;
break;
case ASN1embeddedpdv_identification_fixed_o:
break;
}
}
return 1;
}
#endif // ENABLE_EMBEDDED_PDV
#ifdef ENABLE_EXTERNAL
/* decode external value */
int ASN1BERDecExternal(ASN1decoding_t dec, ASN1uint32_t tag, ASN1external_t *val)
{
ASN1decoding_t dd;
ASN1octet_t *di;
ASN1objectidentifier_t id;
ASN1octetstring_t os;
/* decode explicit tag */
if (!ASN1BERDecExplicitTag(dec, tag | 0x20000000, &dd, &di))
return 0;
/* peek tag of choice alternative */
if (!ASN1BERDecPeekTag(dd, &tag))
return 0;
/* decode alternative */
if (tag == 0x6)
{
if (!ASN1BERDecObjectIdentifier(dd, 0x6, &id))
return 0;
if (!ASN1BERDecPeekTag(dd, &tag))
return 0;
if (tag == 0x2)
{
val->identification.o =
ASN1external_identification_context_negotiation_o;
val->identification.u.context_negotiation.transfer_syntax = id;
if (!ASN1BERDecU32Val(dd, 0x2, &val->
identification.u.context_negotiation.presentation_context_id))
return 0;
if (!ASN1BERDecPeekTag(dd, &tag))
return 0;
}
else
{
val->identification.o = ASN1external_identification_syntax_o;
val->identification.u.syntax = id;
}
}
else
if (tag == 0x2)
{
val->identification.o =
ASN1external_identification_presentation_context_id_o;
if (!ASN1BERDecU32Val(dd, 0x2,
&val->identification.u.presentation_context_id))
return 0;
if (!ASN1BERDecPeekTag(dd, &tag))
return 0;
}
else
{
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
return 0;
}
/* decode optional data value descriptor if present */
if (tag == 0x7)
{
if (!ASN1BERDecZeroCharString(dd, 0x7, &val->data_value_descriptor))
return 0;
if (!ASN1BERDecPeekTag(dd, &tag))
return 0;
}
else
{
val->data_value_descriptor = NULL;
}
/* decode data value alternative */
switch (tag)
{
case 0:
val->data_value.o = ASN1external_data_value_notation_o;
if (!ASN1BERDecOpenType(dd, &val->data_value.u.notation))
return 0;
break;
case 1:
val->data_value.o = ASN1external_data_value_encoded_o;
if (!ASN1BERDecOctetString(dd, 0x4, &os))
return 0;
val->data_value.u.encoded.value = os.value;
val->data_value.u.encoded.length = os.length * 8;
break;
case 2:
val->data_value.o = ASN1external_data_value_encoded_o;
if (!ASN1BERDecBitString(dd, 0x3, &val->data_value.u.encoded))
return 0;
break;
default:
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
return 0;
}
/* end of constructed (explicit tagged) value */
if (!ASN1BERDecEndOfContents(dec, dd, di))
return 0;
return 1;
}
#endif // ENABLE_EXTERNAL
/* decode generalized time value */
int ASN1BERDecGeneralizedTime(ASN1decoding_t dec, ASN1uint32_t tag, ASN1generalizedtime_t *val)
{
ASN1ztcharstring_t time;
if (ASN1BERDecZeroCharString(dec, tag, &time))
{
int rc = ASN1string2generalizedtime(val, time);
DecMemFree(dec, time);
if (rc)
{
return 1;
}
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
}
return 0;
}
/* decode multibyte string value */
int ASN1BERDecZeroMultibyteString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1ztcharstring_t *val)
{
return ASN1BERDecZeroCharString(dec, tag, val);
}
int ASN1BERDecMultibyteString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1charstring_t *val)
{
return ASN1BERDecCharString(dec, tag, val);
}
/* decode null value */
int ASN1BERDecNull(ASN1decoding_t dec, ASN1uint32_t tag)
{
ASN1uint32_t len;
if (ASN1BERDecTag(dec, tag, NULL))
{
if (ASN1BERDecLength(dec, &len, NULL))
{
if (! len)
{
return 1;
}
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
}
}
return 0;
}
/* decode object identifier value */
int ASN1BERDecObjectIdentifier(ASN1decoding_t dec, ASN1uint32_t tag, ASN1objectidentifier_t *val)
{
if (ASN1BERDecTag(dec, tag, NULL))
{
ASN1uint32_t len, i, v;
ASN1octet_t *data, *p;
ASN1uint32_t nelem;
ASN1objectidentifier_t q;
if (ASN1BERDecLength(dec, &len, NULL))
{
data = dec->pos;
dec->pos += len;
nelem = 1;
for (i = 0, p = data; i < len; i++, p++)
{
if (!(*p & 0x80))
nelem++;
}
*val = q = DecAllocObjectIdentifier(dec, nelem);
if (q)
{
v = 0;
for (i = 0, p = data; i < len; i++, p++)
{
v = (v << 7) | (*p & 0x7f);
if (!(*p & 0x80))
{
if (q == *val)
{ // first id
q->value = v / 40;
if (q->value > 2)
q->value = 2;
q->next->value = v - 40 * q->value;
q = q->next->next;
}
else
{
q->value = v;
q = q->next;
}
v = 0;
}
}
return 1;
}
}
}
return 0;
}
/* decode object identifier value */
int ASN1BERDecObjectIdentifier2(ASN1decoding_t dec, ASN1uint32_t tag, ASN1objectidentifier2_t *val)
{
if (ASN1BERDecTag(dec, tag, NULL))
{
ASN1uint32_t len, i, v;
ASN1octet_t *data, *p;
ASN1objectidentifier_t q;
if (ASN1BERDecLength(dec, &len, NULL))
{
if (len <= 16) // lonchanc: hard-coded value 16 to be consistent with ASN1objectidentifier2_t
{
data = dec->pos;
dec->pos += len;
val->count = 0;
v = 0;
for (i = 0, p = data; i < len; i++, p++)
{
v = (v << 7) | (*p & 0x7f);
if (!(*p & 0x80))
{
if (! val->count)
{ // first id
val->value[0] = v / 40;
if (val->value[0] > 2)
val->value[0] = 2;
val->value[1] = v - 40 * val->value[0];
val->count = 2;
}
else
{
val->value[val->count++] = v;
}
v = 0;
}
}
return 1;
}
else
{
ASN1DecSetError(dec, ASN1_ERR_LARGE);
}
}
}
return 0;
}
/* decode integer into signed 8 bit value */
int ASN1BERDecS8Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1int8_t *val)
{
/* skip tag */
if (ASN1BERDecTag(dec, tag, NULL))
{
ASN1uint32_t len;
/* get length */
if (ASN1BERDecLength(dec, &len, NULL))
{
/* get value */
if (1 == len)
{
*val = *dec->pos++;
return 1;
}
ASN1DecSetError(dec, (len < 1) ? ASN1_ERR_CORRUPT : ASN1_ERR_LARGE);
}
}
return 0;
}
/* decode integer into signed 16 bit value */
int ASN1BERDecS16Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1int16_t *val)
{
/* skip tag */
if (ASN1BERDecTag(dec, tag, NULL))
{
ASN1uint32_t len;
/* get length */
if (ASN1BERDecLength(dec, &len, NULL))
{
/* get value */
switch (len)
{
case 1:
*val = *dec->pos++;
break;
case 2:
*val = (*dec->pos << 8) | dec->pos[1];
dec->pos += 2;
break;
default:
ASN1DecSetError(dec, (len < 1) ? ASN1_ERR_CORRUPT : ASN1_ERR_LARGE);
return 0;
}
return 1;
}
}
return 0;
}
const ASN1int32_t c_nSignMask[] = { 0xFFFFFF00, 0xFFFF0000, 0xFF000000, 0 };
/* decode integer into signed 32 bit value */
int ASN1BERDecS32Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1int32_t *val)
{
/* skip tag */
if (ASN1BERDecTag(dec, tag, NULL))
{
ASN1uint32_t len;
/* get length */
if (ASN1BERDecLength(dec, &len, NULL))
{
int fSigned = 0x80 & *dec->pos;
/* get value */
switch (len)
{
case 1:
*val = *dec->pos++;
break;
case 2:
*val = (*dec->pos << 8) | dec->pos[1];
dec->pos += 2;
break;
case 3:
*val = (*dec->pos << 16) | (dec->pos[1] << 8) | dec->pos[2];
dec->pos += 3;
break;
case 4:
*val = (*dec->pos << 24) | (dec->pos[1] << 16) |
(dec->pos[2] << 8) | dec->pos[3];
dec->pos += 4;
break;
default:
ASN1DecSetError(dec, (len < 1) ? ASN1_ERR_CORRUPT : ASN1_ERR_LARGE);
return 0;
}
if (fSigned)
{
*val |= c_nSignMask[len-1];
}
return 1;
}
}
return 0;
}
/* decode integer into intx value */
int ASN1BERDecSXVal(ASN1decoding_t dec, ASN1uint32_t tag, ASN1intx_t *val)
{
/* skip tag */
if (ASN1BERDecTag(dec, tag, NULL))
{
ASN1uint32_t len;
/* get length */
if (ASN1BERDecLength(dec, &len, NULL))
{
/* get value */
if (len >= 1)
{
val->length = len;
val->value = (ASN1octet_t *)DecMemAlloc(dec, len);
if (val->value)
{
CopyMemory(val->value, dec->pos, len);
dec->pos += len;
return 1;
}
}
else
{
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
}
}
}
return 0;
}
/* decode integer into unsigned 8 bit value */
int ASN1BERDecU8Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1uint8_t *val)
{
/* skip tag */
if (ASN1BERDecTag(dec, tag, NULL))
{
ASN1uint32_t len;
/* get length */
if (ASN1BERDecLength(dec, &len, NULL))
{
/* get value */
switch (len)
{
case 1:
*val = *dec->pos++;
return 1;
case 2:
if (0 == *dec->pos)
{
*val = dec->pos[1];
dec->pos += 2;
return 1;
}
// intentionally fall through
default:
ASN1DecSetError(dec, (len < 1) ? ASN1_ERR_CORRUPT : ASN1_ERR_LARGE);
break;
}
}
}
return 0;
}
/* decode integer into unsigned 16 bit value */
int ASN1BERDecU16Val(ASN1decoding_t dec, ASN1uint32_t tag, ASN1uint16_t *val)
{
/* skip tag */
if (ASN1BERDecTag(dec, tag, NULL))
{
ASN1uint32_t len;
/* get length */
if (ASN1BERDecLength(dec, &len, NULL))
{
/* get value */
switch (len)
{
case 1:
*val = *dec->pos++;
return 1;
case 2:
*val = (*dec->pos << 8) | dec->pos[1];
dec->pos += 2;
return 1;
case 3:
if (0 == *dec->pos)
{
*val = (dec->pos[1] << 8) | dec->pos[2];
dec->pos += 3;
return 1;
}
// intentionally fall through
default:
ASN1DecSetError(dec, (len < 1) ? ASN1_ERR_CORRUPT : ASN1_ERR_LARGE);
break;
}
}
}
return 0;
}
/* decode utc time value */
int ASN1BERDecUTCTime(ASN1decoding_t dec, ASN1uint32_t tag, ASN1utctime_t *val)
{
ASN1ztcharstring_t time;
if (ASN1BERDecZeroCharString(dec, tag, &time))
{
int rc = ASN1string2utctime(val, time);
DecMemFree(dec, time);
if (rc)
{
return 1;
}
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
}
return 0;
}
/* decode zero terminated string value */
int ASN1BERDecZeroCharString(ASN1decoding_t dec, ASN1uint32_t tag, ASN1ztcharstring_t *val)
{
ASN1uint32_t constructed, len, infinite;
ASN1ztcharstring_t c;
ASN1decoding_t dd;
ASN1octet_t *di;
ASN1uint32_t lv, lc;
/* skip tag */
if (ASN1BERDecTag(dec, tag, &constructed))
{
/* get length */
if (ASN1BERDecLength(dec, &len, &infinite))
{
if (constructed)
{
/* constructed? then start decoding of constructed value */
*val = NULL;
if (_BERDecConstructed(dec, len, infinite, &dd, &di))
{
while (ASN1BERDecNotEndOfContents(dd, di))
{
if (ASN1BERDecZeroCharString(dd, 0x4, &c))
{
lv = My_lstrlenA(*val);
lc = My_lstrlenA(c);
if (lc)
{
/* resize value */
*val = (char *)DecMemReAlloc(dd, *val, lv + lc + 1);
if (*val)
{
/* concat strings */
CopyMemory(*val + lv, c, lc + 1);
/* free unused string */
DecMemFree(dec, c);
}
else
{
return 0;
}
}
}
else
{
return 0;
}
} // while
return ASN1BERDecEndOfContents(dec, dd, di);
}
}
else
{
/* primitive? then copy value */
*val = (char *)DecMemAlloc(dec, len + 1);
if (*val)
{
CopyMemory(*val, dec->pos, len);
(*val)[len] = 0;
dec->pos += len;
return 1;
}
}
}
}
return 0;
}
/* decode zero terminated 16 bit string value */
int ASN1BERDecZeroChar16String(ASN1decoding_t dec, ASN1uint32_t tag, ASN1ztchar16string_t *val)
{
ASN1uint32_t constructed, len, infinite;
ASN1ztchar16string_t c;
ASN1decoding_t dd;
ASN1octet_t *di;
ASN1uint32_t i;
ASN1uint32_t lv, lc;
/* skip tag */
if (ASN1BERDecTag(dec, tag, &constructed))
{
/* get length */
if (ASN1BERDecLength(dec, &len, &infinite))
{
if (constructed)
{
/* constructed? then start decoding of constructed value */
*val = NULL;
if (_BERDecConstructed(dec, len, infinite, &dd, &di))
{
while (ASN1BERDecNotEndOfContents(dd, di))
{
if (ASN1BERDecZeroChar16String(dd, 0x4, &c))
{
lv = ASN1str16len(*val);
lc = ASN1str16len(c);
if (lc)
{
/* resize value */
*val = (ASN1char16_t *)DecMemReAlloc(dd, *val, (lv + lc + 1) * sizeof(ASN1char16_t));
if (*val)
{
/* concat strings */
CopyMemory(*val + lv, c, (lc + 1) * sizeof(ASN1char16_t));
/* free unused string */
DecMemFree(dec, c);
}
else
{
return 0;
}
}
}
else
{
return 0;
}
} // while
return ASN1BERDecEndOfContents(dec, dd, di);
}
}
else
{
/* primitive? then copy value */
*val = (ASN1char16_t *)DecMemAlloc(dec, (len + 1) * sizeof(ASN1char16_t));
if (*val)
{
for (i = 0; i < len; i++)
{
(*val)[i] = (*dec->pos << 8) | dec->pos[1];
dec->pos += 2;
}
(*val)[len] = 0;
return 1;
}
}
}
}
return 0;
}
/* decode zero terminated 32 bit string value */
int ASN1BERDecZeroChar32String(ASN1decoding_t dec, ASN1uint32_t tag, ASN1ztchar32string_t *val)
{
ASN1uint32_t constructed, len, infinite;
ASN1ztchar32string_t c;
ASN1decoding_t dd;
ASN1octet_t *di;
ASN1uint32_t i;
ASN1uint32_t lv, lc;
/* skip tag */
if (ASN1BERDecTag(dec, tag, &constructed))
{
/* get length */
if (ASN1BERDecLength(dec, &len, &infinite))
{
if (constructed)
{
/* constructed? then start decoding of constructed value */
*val = (ASN1char32_t *)DecMemAlloc(dec, sizeof(ASN1char32_t));
if (*val)
{
**val = 0;
if (_BERDecConstructed(dec, len, infinite, &dd, &di))
{
while (ASN1BERDecNotEndOfContents(dd, di))
{
if (ASN1BERDecZeroChar32String(dd, 0x4, &c))
{
lv = ASN1str32len(*val);
lc = ASN1str32len(c);
if (lc)
{
/* resize value */
*val = (ASN1char32_t *)DecMemReAlloc(dd, *val, (lv + lc + 1) * sizeof(ASN1char32_t));
if (*val)
{
/* concat strings */
CopyMemory(*val + lv, c, (lc + 1) * sizeof(ASN1char32_t));
/* free unused string */
DecMemFree(dec, c);
}
}
}
else
{
return 0;
}
}
return ASN1BERDecEndOfContents(dec, dd, di);
}
}
}
else
{
/* primitive? then copy value */
*val = (ASN1char32_t *)DecMemAlloc(dec, (len + 1) * sizeof(ASN1char32_t));
if (*val)
{
for (i = 0; i < len; i++)
{
(*val)[i] = (*dec->pos << 24) | (dec->pos[1] << 16) |
(dec->pos[2] << 8) | dec->pos[3];;
dec->pos += 4;
}
(*val)[len] = 0;
return 1;
}
}
}
}
return 0;
}
/* skip a value */
int ASN1BERDecSkip(ASN1decoding_t dec)
{
ASN1uint32_t tag;
ASN1uint32_t constructed, len, infinite;
ASN1decoding_t dd;
ASN1octet_t *di;
/* set warning flag */
ASN1DecSetError(dec, ASN1_WRN_EXTENDED);
/* read tag */
if (ASN1BERDecPeekTag(dec, &tag))
{
if (ASN1BERDecTag(dec, tag, &constructed))
{
if (constructed)
{
/* constructed? then get length */
if (ASN1BERDecLength(dec, &len, &infinite))
{
if (!infinite)
{
/* skip value */
dec->pos += len;
// remove the above warning set previously
ASN1DecSetError(dec, ASN1_SUCCESS);
return 1;
}
/* start skipping of constructed value */
if (_BERDecConstructed(dec, len, infinite, &dd, &di))
{
while (ASN1BERDecNotEndOfContents(dd, di))
{
if (ASN1BERDecSkip(dd))
{
continue;
}
return 0;
}
if (ASN1BERDecEndOfContents(dec, dd, di))
{
// remove the above warning set previously
ASN1DecSetError(dec, ASN1_SUCCESS);
return 1;
}
return 0;
}
}
}
else
{
/* primitive? then get length */
if (ASN1BERDecLength(dec, &len, NULL))
{
/* skip value */
dec->pos += len;
// remove the above warning set previously
ASN1DecSetError(dec, ASN1_SUCCESS);
return 1;
}
}
}
}
return 0;
}
/* decode an open type value */
int _BERDecOpenType(ASN1decoding_t dec, ASN1open_t *val, ASN1uint32_t fNoCopy)
{
ASN1uint32_t tag;
ASN1uint32_t constructed, len, infinite;
ASN1decoding_t dd;
ASN1octet_t *di;
ASN1octet_t *p;
p = dec->pos;
/* skip tag */
if (ASN1BERDecPeekTag(dec, &tag))
{
if (ASN1BERDecTag(dec, tag, &constructed))
{
if (constructed)
{
/* constructed? then get length */
if (ASN1BERDecLength(dec, &len, &infinite))
{
if (!infinite)
{
/* skip value */
dec->pos += len;
goto MakeCopy;
}
/* start decoding of constructed value */
if (_BERDecConstructed(dec, len, infinite, &dd, &di))
{
while (ASN1BERDecNotEndOfContents(dd, di))
{
if (ASN1BERDecSkip(dd))
{
continue;
}
return 0;
}
if (ASN1BERDecEndOfContents(dec, dd, di))
{
goto MakeCopy;
}
}
}
return 0;
}
else
{
/* primitive? then get length */
if (ASN1BERDecLength(dec, &len, NULL))
{
/* skip value */
dec->pos += len;
}
else
{
return 0;
}
}
MakeCopy:
// clean up unused fields
// val->decoded = NULL;
// val->userdata = NULL;
/* copy skipped value */
val->length = (ASN1uint32_t) (dec->pos - p);
if (fNoCopy)
{
val->encoded = p;
return 1;
}
else
{
val->encoded = (ASN1octet_t *)DecMemAlloc(dec, val->length);
if (val->encoded)
{
CopyMemory(val->encoded, p, val->length);
return 1;
}
}
}
}
return 0;
}
/* decode an open type value, making a copy */
int ASN1BERDecOpenType(ASN1decoding_t dec, ASN1open_t *val)
{
return _BERDecOpenType(dec, val, FALSE);
}
/* decode an open type value, no copy */
int ASN1BERDecOpenType2(ASN1decoding_t dec, ASN1open_t *val)
{
return _BERDecOpenType(dec, val, TRUE);
}
/* finish decoding */
int ASN1BERDecFlush(ASN1decoding_t dec)
{
/* calculate length */
dec->len = (ASN1uint32_t) (dec->pos - dec->buf);
/* set WRN_NOEOD if data left */
if (dec->len >= dec->size)
{
DecAssert(dec, dec->len == dec->size);
return 1;
}
ASN1DecSetError(dec, ASN1_WRN_NOEOD);
return 1;
}
#endif // ENABLE_BER