You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1310 lines
37 KiB
1310 lines
37 KiB
/* Copyright (C) Boris Nikolaus, Germany, 1996-1997. All rights reserved. */
|
|
/* Copyright (C) Microsoft Corporation, 1997-1998. All rights reserved. */
|
|
|
|
#include "precomp.h"
|
|
#include "cintern.h"
|
|
|
|
#ifdef TEST_CODER
|
|
typedef struct ASN1testcoder_s
|
|
{
|
|
struct ASN1INTERNencoding_s e;
|
|
struct ASN1INTERNdecoding_s d;
|
|
} *ASN1testcoder_t;
|
|
#define ASN1_TEST_CODER_SIZE (sizeof(struct ASN1testcoder_s))
|
|
int TestEnc_InitCoder(ASN1INTERNencoding_t e, ASN1module_t mod);
|
|
int TestDec_InitCoder(ASN1INTERNdecoding_t d, ASN1module_t mod);
|
|
int TestEnc_Compare(ASN1INTERNencoding_t e, ASN1uint32_t id, ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize);
|
|
int TestDec_Compare(ASN1INTERNdecoding_t d, ASN1uint32_t id, void *valref, ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize);
|
|
#else
|
|
#define ASN1_TEST_CODER_SIZE 0
|
|
#endif
|
|
|
|
|
|
/* init an ASN1encoding_t */
|
|
ASN1error_e ASN1_CreateEncoder
|
|
(
|
|
ASN1module_t mod,
|
|
ASN1encoding_t *enc,
|
|
ASN1octet_t *pbBuf,
|
|
ASN1uint32_t cbBufSize,
|
|
ASN1encoding_t pParent
|
|
)
|
|
{
|
|
if (NULL != mod && NULL != enc)
|
|
{
|
|
ASN1INTERNencoding_t e;
|
|
|
|
*enc = NULL;
|
|
|
|
/* construct ASN1encoding_t */
|
|
e = (ASN1INTERNencoding_t)MemAlloc(sizeof(*e) + ASN1_TEST_CODER_SIZE, mod->nModuleName);
|
|
if (NULL != e)
|
|
{
|
|
ZeroMemory(e, sizeof(*e) + ASN1_TEST_CODER_SIZE);
|
|
e->info.magic = MAGIC_ENCODER;
|
|
e->info.err = ASN1_SUCCESS;
|
|
// e->info.pos = e->info.buf = NULL;
|
|
// e->info.size = e->info.len = e->info.bit = 0;
|
|
e->info.dwFlags = mod->dwFlags;
|
|
e->info.module = mod;
|
|
// e->child = NULL;
|
|
|
|
/* set buffer if given */
|
|
if (NULL != pbBuf && cbBufSize)
|
|
{
|
|
e->info.dwFlags |= ASN1ENCODE_SETBUFFER;
|
|
e->info.pos = e->info.buf = pbBuf;
|
|
e->info.size = cbBufSize;
|
|
}
|
|
|
|
/* set parent if parented, otherwise, initialized to itself */
|
|
if (NULL != pParent)
|
|
{
|
|
e->parent = (ASN1INTERNencoding_t) pParent;
|
|
e->info.eRule = pParent->eRule;
|
|
}
|
|
else
|
|
{
|
|
e->parent = e;
|
|
e->info.eRule = mod->eRule;
|
|
}
|
|
|
|
// e->mem = NULL;
|
|
// e->memlength = 0;
|
|
// e->memsize = 0;
|
|
// e->epi = NULL;
|
|
// e->epilength = 0;
|
|
// e->episize = 0;
|
|
// e->csi = NULL;
|
|
// e->csilength = 0;
|
|
// e->csisize = 0;
|
|
|
|
if (! (e->info.dwFlags & ASN1ENCODE_SETBUFFER) && (NULL != pParent))
|
|
{
|
|
// lonchanc: make sure we have a minimum 256 bytes available.
|
|
BOOL fRet = FALSE;
|
|
if (ASN1_PER_RULE & e->info.eRule)
|
|
{
|
|
// this is required for h245.
|
|
fRet = ASN1PEREncCheck((ASN1encoding_t) e, 1);
|
|
}
|
|
#ifdef ENABLE_BER
|
|
else
|
|
if (ASN1_BER_RULE & e->info.eRule)
|
|
{
|
|
// this is required for h245.
|
|
fRet = ASN1BEREncCheck((ASN1encoding_t) e, 1);
|
|
}
|
|
#endif // ENABLE_BER
|
|
else
|
|
{
|
|
EncAssert((ASN1encoding_t) e, 0);
|
|
MemFree(e);
|
|
return ASN1_ERR_RULE;
|
|
}
|
|
if (fRet)
|
|
{
|
|
// lonchanc: make sure the first byte is zeroed out, which
|
|
// is required for h245.
|
|
e->info.buf[0] = '\0';
|
|
}
|
|
else
|
|
{
|
|
MemFree(e);
|
|
return ASN1_ERR_MEMORY;
|
|
}
|
|
}
|
|
|
|
#if defined(TEST_CODER) && defined(_DEBUG)
|
|
TestEnc_InitCoder(e, mod);
|
|
#endif // defined(TEST_CODER) && defined(_DEBUG)
|
|
|
|
if (NULL != pParent)
|
|
{
|
|
EncAssert((ASN1encoding_t) e, NULL == ((ASN1INTERNencoding_t) pParent)->child);
|
|
((ASN1INTERNencoding_t) pParent)->child = e;
|
|
}
|
|
|
|
*enc = (ASN1encoding_t) e;
|
|
return ASN1_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
return ASN1_ERR_MEMORY;
|
|
}
|
|
}
|
|
|
|
return ASN1_ERR_BADARGS;
|
|
}
|
|
|
|
/* encode a value */
|
|
ASN1error_e ASN1_Encode
|
|
(
|
|
ASN1encoding_t enc,
|
|
void *value,
|
|
ASN1uint32_t id,
|
|
ASN1uint32_t flags,
|
|
ASN1octet_t *pbBuf,
|
|
ASN1uint32_t cbBufSize
|
|
)
|
|
{
|
|
if (NULL != enc)
|
|
{
|
|
ASN1INTERNencoding_t e = (ASN1INTERNencoding_t)enc;
|
|
|
|
/* check magic numbers */
|
|
EncAssert(enc, MAGIC_ENCODER == enc->magic);
|
|
|
|
/* clear error */
|
|
ASN1EncSetError(enc, ASN1_SUCCESS);
|
|
|
|
/* new buffer given? */
|
|
if (flags & ASN1ENCODE_SETBUFFER)
|
|
{
|
|
e->info.dwFlags |= ASN1ENCODE_SETBUFFER;
|
|
enc->pos = enc->buf = pbBuf;
|
|
enc->size = cbBufSize;
|
|
enc->len = enc->bit = 0;
|
|
}
|
|
/* use a new buffer? */
|
|
else if ((e->info.dwFlags | flags) & ASN1ENCODE_ALLOCATEBUFFER)
|
|
{
|
|
e->info.dwFlags &= ~ASN1ENCODE_SETBUFFER;
|
|
enc->pos = enc->buf = NULL;
|
|
enc->size = enc->len = enc->bit = 0;
|
|
}
|
|
/* reuse buffer? */
|
|
else if ((flags & ASN1ENCODE_REUSEBUFFER) || !((e->info.dwFlags | flags) & ASN1ENCODE_APPEND))
|
|
{
|
|
EncAssert(enc, NULL != enc->buf);
|
|
enc->pos = enc->buf;
|
|
enc->bit = enc->len = 0;
|
|
}
|
|
/* otherwise append to buffer */
|
|
|
|
/* check id number */
|
|
if (id < enc->module->cPDUs)
|
|
{
|
|
if (ASN1_PER_RULE & enc->eRule)
|
|
{
|
|
/* encode value */
|
|
ASN1PerEncFun_t pfnPER;
|
|
if (NULL != (pfnPER = enc->module->PER.apfnEncoder[id]))
|
|
{
|
|
if ((*pfnPER)(enc, value))
|
|
{
|
|
ASN1PEREncFlush(enc);
|
|
}
|
|
else
|
|
{
|
|
// the error code must be an error
|
|
if (ASN1_SUCCEEDED(e->parent->info.err))
|
|
{
|
|
// cannot return here immediately because we need to do cleanup
|
|
ASN1EncSetError(enc, ASN1_ERR_CORRUPT);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return ASN1EncSetError(enc, ASN1_ERR_BADPDU);
|
|
}
|
|
}
|
|
#ifdef ENABLE_BER
|
|
else
|
|
if (ASN1_BER_RULE & enc->eRule)
|
|
{
|
|
/* encode value */
|
|
ASN1BerEncFun_t pfnBER;
|
|
if (NULL != (pfnBER = enc->module->BER.apfnEncoder[id]))
|
|
{
|
|
if ((*pfnBER)(enc, 0, value)) // lonchanc: tag is 0 to make it compiled
|
|
{
|
|
ASN1BEREncFlush(enc);
|
|
}
|
|
else
|
|
{
|
|
// the error code must be an error
|
|
if (ASN1_SUCCEEDED(e->parent->info.err))
|
|
{
|
|
// cannot return here immediately because we need to do cleanup
|
|
ASN1EncSetError(enc, ASN1_ERR_CORRUPT);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return ASN1EncSetError(enc, ASN1_ERR_BADPDU);
|
|
}
|
|
}
|
|
#endif // ENABLE_BER
|
|
else
|
|
{
|
|
return ASN1EncSetError(enc, ASN1_ERR_RULE);
|
|
}
|
|
|
|
/* call abort/done function for non-parented encoding stream */
|
|
if (ASN1_SUCCEEDED(e->parent->info.err))
|
|
{
|
|
// not parented
|
|
if (e == e->parent)
|
|
{
|
|
#if defined(TEST_CODER) && defined(_DEBUG)
|
|
if (ASN1_PER_RULE & enc->eRule)
|
|
{
|
|
if (! TestEnc_Compare(e, id, enc->buf + enc->cbExtraHeader, enc->len - enc->cbExtraHeader))
|
|
{
|
|
MyDebugBreak();
|
|
}
|
|
}
|
|
#ifdef ENABLE_BER
|
|
else
|
|
if (ASN1_BER_RULE & enc->eRule)
|
|
{
|
|
if (! TestEnc_Compare(e, id, enc->buf + enc->cbExtraHeader, enc->len - enc->cbExtraHeader))
|
|
{
|
|
MyDebugBreak();
|
|
}
|
|
}
|
|
#endif // ENABLE_BER
|
|
#endif
|
|
ASN1EncDone(enc);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASN1INTERNencoding_t child, child2;
|
|
|
|
// not parented
|
|
if (e == e->parent)
|
|
{
|
|
ASN1EncAbort(enc);
|
|
}
|
|
|
|
// clean up...
|
|
if ((e->info.dwFlags | flags) & ASN1ENCODE_ALLOCATEBUFFER)
|
|
{
|
|
ASN1_FreeEncoded(enc, enc->buf);
|
|
enc->pos = enc->buf = NULL;
|
|
enc->size = enc->len = enc->bit = 0;
|
|
}
|
|
for (child = e->child; child; child = child2)
|
|
{
|
|
child2 = child->child;
|
|
// make sure it does not touch its parent which may already be freed
|
|
child->parent = child;
|
|
ASN1_CloseEncoder2((ASN1encoding_t) child);
|
|
}
|
|
e->child = NULL;
|
|
}
|
|
|
|
/* return error code */
|
|
return e->parent->info.err;
|
|
}
|
|
else
|
|
{
|
|
return ASN1EncSetError(enc, ASN1_ERR_BADPDU);
|
|
}
|
|
}
|
|
|
|
return ASN1_ERR_BADARGS;
|
|
}
|
|
|
|
/* control function for encoding */
|
|
ASN1error_e ASN1_SetEncoderOption
|
|
(
|
|
ASN1encoding_t enc,
|
|
ASN1optionparam_t *pOptParam
|
|
)
|
|
{
|
|
if (NULL != enc && NULL != pOptParam)
|
|
{
|
|
ASN1INTERNencoding_t e = (ASN1INTERNencoding_t)enc;
|
|
ASN1error_e rc = ASN1_SUCCESS;
|
|
|
|
/* check magic number */
|
|
EncAssert(enc, MAGIC_ENCODER == enc->magic);
|
|
|
|
switch (pOptParam->eOption)
|
|
{
|
|
case ASN1OPT_CHANGE_RULE:
|
|
enc->eRule = pOptParam->eRule;
|
|
break;
|
|
|
|
case ASN1OPT_NOT_REUSE_BUFFER:
|
|
e->info.dwFlags &= ~ASN1ENCODE_SETBUFFER;
|
|
enc->buf = enc->pos = NULL;
|
|
enc->size = enc->bit = enc->len = 0;
|
|
break;
|
|
|
|
case ASN1OPT_REWIND_BUFFER:
|
|
enc->pos = enc->buf;
|
|
enc->bit = enc->len = 0;
|
|
break;
|
|
|
|
default:
|
|
rc = ASN1_ERR_BADARGS;
|
|
break;
|
|
}
|
|
|
|
return ASN1EncSetError(enc, rc);
|
|
}
|
|
|
|
return ASN1_ERR_BADARGS;
|
|
}
|
|
|
|
ASN1error_e ASN1_GetEncoderOption
|
|
(
|
|
ASN1encoding_t enc,
|
|
ASN1optionparam_t *pOptParam
|
|
)
|
|
{
|
|
if (NULL != enc && NULL != pOptParam)
|
|
{
|
|
ASN1INTERNencoding_t e = (ASN1INTERNencoding_t)enc;
|
|
ASN1error_e rc = ASN1_SUCCESS;
|
|
|
|
/* check magic number */
|
|
EncAssert(enc, MAGIC_ENCODER == enc->magic);
|
|
|
|
switch (pOptParam->eOption)
|
|
{
|
|
case ASN1OPT_GET_RULE:
|
|
pOptParam->eRule = enc->eRule;
|
|
break;
|
|
|
|
default:
|
|
rc = ASN1_ERR_BADARGS;
|
|
break;
|
|
}
|
|
|
|
return ASN1EncSetError(enc, rc);
|
|
}
|
|
|
|
return ASN1_ERR_BADARGS;
|
|
}
|
|
|
|
|
|
/* destroy encoding stream */
|
|
void ASN1_CloseEncoder
|
|
(
|
|
ASN1encoding_t enc
|
|
)
|
|
{
|
|
if (NULL != enc)
|
|
{
|
|
ASN1INTERNencoding_t e = (ASN1INTERNencoding_t)enc;
|
|
|
|
/* check magic number */
|
|
EncAssert(enc, MAGIC_ENCODER == enc->magic);
|
|
|
|
if (e != e->parent)
|
|
{
|
|
EncAssert(enc, e == e->parent->child);
|
|
e->parent->child = NULL;
|
|
}
|
|
|
|
/* free encoding stream */
|
|
MemFree(e);
|
|
}
|
|
}
|
|
|
|
/* destroy encoding stream */
|
|
void ASN1_CloseEncoder2
|
|
(
|
|
ASN1encoding_t enc
|
|
)
|
|
{
|
|
if (NULL != enc)
|
|
{
|
|
/* check magic number */
|
|
EncAssert(enc, MAGIC_ENCODER == enc->magic);
|
|
|
|
EncMemFree(enc, enc->buf);
|
|
|
|
ASN1_CloseEncoder(enc);
|
|
}
|
|
}
|
|
|
|
/* init an ASN1decoding_t */
|
|
ASN1error_e ASN1_CreateDecoder
|
|
(
|
|
ASN1module_t mod,
|
|
ASN1decoding_t *dec,
|
|
ASN1octet_t *pbBuf,
|
|
ASN1uint32_t cbBufSize,
|
|
ASN1decoding_t pParent
|
|
)
|
|
{
|
|
return ASN1_CreateDecoderEx(mod, dec, pbBuf, cbBufSize, pParent, ASN1FLAGS_NONE);
|
|
}
|
|
|
|
ASN1error_e ASN1_CreateDecoderEx
|
|
(
|
|
ASN1module_t mod,
|
|
ASN1decoding_t *dec,
|
|
ASN1octet_t *pbBuf,
|
|
ASN1uint32_t cbBufSize,
|
|
ASN1decoding_t pParent,
|
|
ASN1uint32_t dwFlags
|
|
)
|
|
{
|
|
if (NULL != mod && NULL != dec)
|
|
{
|
|
ASN1INTERNdecoding_t d;
|
|
|
|
*dec = NULL;
|
|
|
|
/* construct ASN1decoding_t */
|
|
d = (ASN1INTERNdecoding_t)MemAlloc(sizeof(*d) + ASN1_TEST_CODER_SIZE, mod->nModuleName);
|
|
if (NULL != d)
|
|
{
|
|
ZeroMemory(d, sizeof(*d) + ASN1_TEST_CODER_SIZE);
|
|
d->info.magic = MAGIC_DECODER;
|
|
d->info.err = ASN1_SUCCESS;
|
|
d->info.dwFlags = mod->dwFlags;
|
|
d->info.module = mod;
|
|
// d->child = NULL;
|
|
|
|
/* set parent if parented */
|
|
if (NULL != pParent)
|
|
{
|
|
DecAssert((ASN1decoding_t) d, NULL == ((ASN1INTERNdecoding_t) pParent)->child);
|
|
((ASN1INTERNdecoding_t) pParent)->child = d;
|
|
d->parent = (ASN1INTERNdecoding_t) pParent;
|
|
d->info.eRule = pParent->eRule;
|
|
}
|
|
else
|
|
/* initialize otherwise */
|
|
{
|
|
d->parent = d;
|
|
d->info.eRule = mod->eRule;
|
|
}
|
|
|
|
/* set buffer if given */
|
|
// lonchanc: it is ok to have a zero buffer size here
|
|
if (NULL != pbBuf)
|
|
{
|
|
d->info.dwFlags |= ASN1DECODE_SETBUFFER;
|
|
d->info.buf = d->info.pos = pbBuf;
|
|
d->info.size = cbBufSize;
|
|
// d->info.len = d->info.bit = 0;
|
|
if ((dwFlags & ASN1DECODE_AUTOFREEBUFFER)
|
|
&& !d->parent->fExtBuf)
|
|
{
|
|
// dbarlow: It's possible the buffer isn't really
|
|
// allocated, but instead came from the
|
|
// parent's Extension buffer.
|
|
d->info.dwFlags |= ASN1DECODE_AUTOFREEBUFFER;
|
|
}
|
|
}
|
|
// else
|
|
// {
|
|
// d->info.buf = d->info.pos = NULL;
|
|
// d->info.size = d->info.len = d->info.bit = 0;
|
|
// }
|
|
|
|
// d->mem = NULL;
|
|
// d->memlength = 0;
|
|
// d->memsize = 0;
|
|
// d->epi = NULL;
|
|
// d->epilength = 0;
|
|
// d->episize = 0;
|
|
// d->csi = NULL;
|
|
// d->csilength = 0;
|
|
// d->csisize = 0;
|
|
|
|
#if defined(TEST_CODER) && defined(_DEBUG)
|
|
TestDec_InitCoder(d, mod);
|
|
#endif // defined(TEST_CODER) && defined(_DEBUG)
|
|
|
|
*dec = (ASN1decoding_t) d;
|
|
return ASN1_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
if (dwFlags & ASN1DECODE_AUTOFREEBUFFER)
|
|
{
|
|
// dbarlow: It's possible the buffer isn't really
|
|
// allocated, but instead came from the
|
|
// parent's Extension buffer.
|
|
d = (ASN1INTERNdecoding_t)pParent;
|
|
if ((NULL == d) || !d->fExtBuf)
|
|
{
|
|
MemFree(pbBuf);
|
|
}
|
|
}
|
|
return ASN1_ERR_MEMORY;
|
|
}
|
|
}
|
|
|
|
return ASN1_ERR_BADARGS;
|
|
}
|
|
|
|
/* decode a value */
|
|
ASN1error_e ASN1_Decode
|
|
(
|
|
ASN1decoding_t dec,
|
|
void **valref,
|
|
ASN1uint32_t id,
|
|
ASN1uint32_t flags,
|
|
ASN1octet_t *pbBuf,
|
|
ASN1uint32_t cbBufSize
|
|
)
|
|
{
|
|
ASN1error_e ReturnCode = ASN1_SUCCESS;
|
|
|
|
if (NULL != dec && NULL != valref)
|
|
{
|
|
ASN1INTERNdecoding_t d = (ASN1INTERNdecoding_t)dec;
|
|
|
|
/* check magic numbers */
|
|
DecAssert(dec, MAGIC_DECODER == dec->magic);
|
|
|
|
/* clear error */
|
|
ASN1DecSetError(dec, ASN1_SUCCESS);
|
|
|
|
/* new buffer given? */
|
|
*valref = NULL;
|
|
if (flags & ASN1DECODE_SETBUFFER)
|
|
{
|
|
if (NULL != pbBuf && 0 != cbBufSize)
|
|
{
|
|
dec->pos = dec->buf = pbBuf;
|
|
dec->size = cbBufSize;
|
|
dec->bit = dec->len = 0;
|
|
}
|
|
else
|
|
{
|
|
ReturnCode = ASN1DecSetError(dec, ASN1_ERR_BADARGS);
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
/* rewind buffer? */
|
|
else if ((flags & ASN1DECODE_REWINDBUFFER) ||
|
|
!((d->info.dwFlags | flags ) & ASN1DECODE_APPENDED))
|
|
{
|
|
dec->pos = dec->buf;
|
|
dec->bit = dec->len = 0;
|
|
}
|
|
/* otherwise continue reading from last buffer */
|
|
|
|
/* check id number */
|
|
if (id < dec->module->cPDUs)
|
|
{
|
|
ASN1uint32_t cbTopLevelStruct;
|
|
|
|
/* clear length of linear buffer required */
|
|
d->cbLinearBufSize = 0;
|
|
|
|
/* double check for the availability of destination buffer */
|
|
if (d->lpOrigExtBuf == NULL || d->cbOrigExtBufSize == 0)
|
|
{
|
|
d->fExtBuf = FALSE;
|
|
}
|
|
|
|
cbTopLevelStruct = dec->module->acbStructSize[id];
|
|
if (NULL != (*valref = DecMemAlloc(dec, cbTopLevelStruct)))
|
|
{
|
|
if (ASN1_PER_RULE & dec->eRule)
|
|
{
|
|
ASN1PerDecFun_t pfnPER;
|
|
/* decode value */
|
|
if (NULL != (pfnPER = dec->module->PER.apfnDecoder[id]))
|
|
{
|
|
if ((*pfnPER)(dec, *valref))
|
|
{
|
|
ASN1PERDecFlush(dec);
|
|
}
|
|
else
|
|
{
|
|
// the error code must be an error
|
|
if (ASN1_SUCCEEDED(d->parent->info.err))
|
|
{
|
|
// cannot return here immediately because we need to do cleanup
|
|
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ReturnCode = ASN1DecSetError(dec, ASN1_ERR_BADPDU);
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
#ifdef ENABLE_BER
|
|
else
|
|
if (ASN1_BER_RULE & dec->eRule)
|
|
{
|
|
ASN1BerDecFun_t pfnBER;
|
|
/* decode value */
|
|
if (NULL != (pfnBER = dec->module->BER.apfnDecoder[id]))
|
|
{
|
|
if ((*pfnBER)(dec, 0, *valref)) // lonchanc: tag is 0 to make it compiled
|
|
{
|
|
ASN1BERDecFlush(dec);
|
|
}
|
|
else
|
|
{
|
|
// the error code must be an error
|
|
if (ASN1_SUCCEEDED(d->parent->info.err))
|
|
{
|
|
// cannot return here immediately because we need to do cleanup
|
|
ASN1DecSetError(dec, ASN1_ERR_CORRUPT);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ReturnCode = ASN1DecSetError(dec, ASN1_ERR_BADPDU);
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
#endif // ENABLE_BER
|
|
else
|
|
{
|
|
ReturnCode = ASN1DecSetError(dec, ASN1_ERR_RULE);
|
|
goto ErrorExit;
|
|
}
|
|
|
|
/* call abort/done function for non-parented decoding stream */
|
|
if (ASN1_SUCCEEDED(d->parent->info.err))
|
|
{
|
|
// not parented
|
|
if (d == d->parent)
|
|
{
|
|
#if defined(TEST_CODER) && defined(_DEBUG)
|
|
if (ASN1_PER_RULE & dec->eRule)
|
|
{
|
|
if (! TestDec_Compare(d, id, *valref, dec->buf, dec->len))
|
|
{
|
|
MyDebugBreak();
|
|
}
|
|
}
|
|
#ifdef ENABLE_BER
|
|
else
|
|
if (ASN1_BER_RULE & dec->eRule)
|
|
{
|
|
if (! TestDec_Compare(d, id, *valref, dec->buf, dec->len))
|
|
{
|
|
MyDebugBreak();
|
|
}
|
|
}
|
|
#endif // ENABLE_BER
|
|
#endif
|
|
ASN1DecDone(dec);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASN1INTERNdecoding_t child, child2;
|
|
|
|
// not parented
|
|
if (d == d->parent)
|
|
{
|
|
ASN1DecAbort(dec);
|
|
}
|
|
|
|
// clean up...
|
|
for (child = d->child; child; child = child2)
|
|
{
|
|
child2 = child->child;
|
|
// make sure it does not touch its parent which may already be freed
|
|
child->parent = child;
|
|
ASN1_CloseDecoder((ASN1decoding_t) child);
|
|
}
|
|
d->child = NULL;
|
|
}
|
|
|
|
/* return error code */
|
|
ReturnCode = d->parent->info.err;
|
|
goto ErrorExit;
|
|
}
|
|
else
|
|
{
|
|
ReturnCode = ASN1_ERR_MEMORY;
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ReturnCode = ASN1DecSetError(dec, ASN1_ERR_BADPDU);
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
|
|
ReturnCode = ASN1_ERR_BADARGS;
|
|
|
|
ErrorExit:
|
|
if (ASN1_FAILED(ReturnCode))
|
|
{
|
|
if (NULL != valref)
|
|
{
|
|
ASN1_FreeDecoded(dec ,*valref, id);
|
|
*valref = NULL;
|
|
}
|
|
}
|
|
|
|
return ReturnCode;
|
|
}
|
|
|
|
/* control function for decoding */
|
|
ASN1error_e ASN1_SetDecoderOption
|
|
(
|
|
ASN1decoding_t dec,
|
|
ASN1optionparam_t *pOptParam
|
|
)
|
|
{
|
|
if (NULL != dec)
|
|
{
|
|
ASN1INTERNdecoding_t d = (ASN1INTERNdecoding_t)dec;
|
|
ASN1error_e rc = ASN1_SUCCESS;
|
|
|
|
/* check magic number */
|
|
DecAssert(dec, MAGIC_DECODER == dec->magic);
|
|
|
|
switch (pOptParam->eOption)
|
|
{
|
|
case ASN1OPT_CHANGE_RULE:
|
|
dec->eRule = pOptParam->eRule;
|
|
break;
|
|
|
|
case ASN1OPT_SET_DECODED_BUFFER:
|
|
if (NULL != pOptParam->Buffer.pbBuf && 0 != pOptParam->Buffer.cbBufSize)
|
|
{
|
|
d->fExtBuf = TRUE;
|
|
d->lpOrigExtBuf = pOptParam->Buffer.pbBuf;
|
|
d->cbOrigExtBufSize = pOptParam->Buffer.cbBufSize;
|
|
d->lpRemExtBuf = d->lpOrigExtBuf;
|
|
d->cbRemExtBufSize = d->cbOrigExtBufSize;
|
|
}
|
|
else
|
|
{
|
|
rc = ASN1_ERR_BADARGS;
|
|
}
|
|
break;
|
|
|
|
case ASN1OPT_DEL_DECODED_BUFFER:
|
|
d->fExtBuf = FALSE;
|
|
d->lpOrigExtBuf = NULL;
|
|
d->cbOrigExtBufSize = 0;
|
|
d->lpRemExtBuf = NULL;
|
|
d->cbRemExtBufSize = 0;
|
|
break;
|
|
|
|
default:
|
|
rc = ASN1_ERR_BADARGS;
|
|
break;
|
|
}
|
|
|
|
return ASN1DecSetError(dec, rc);
|
|
}
|
|
|
|
return ASN1_ERR_BADARGS;
|
|
}
|
|
|
|
|
|
/* control function for decoding */
|
|
ASN1error_e ASN1_GetDecoderOption
|
|
(
|
|
ASN1decoding_t dec,
|
|
ASN1optionparam_t *pOptParam
|
|
)
|
|
{
|
|
if (NULL != dec)
|
|
{
|
|
ASN1INTERNdecoding_t d = (ASN1INTERNdecoding_t)dec;
|
|
ASN1error_e rc = ASN1_SUCCESS;
|
|
|
|
/* check magic number */
|
|
DecAssert(dec, MAGIC_DECODER == dec->magic);
|
|
|
|
switch (pOptParam->eOption)
|
|
{
|
|
case ASN1OPT_GET_RULE:
|
|
pOptParam->eRule = dec->eRule;
|
|
break;
|
|
|
|
case ASN1OPT_GET_DECODED_BUFFER_SIZE:
|
|
pOptParam->cbRequiredDecodedBufSize = d->cbLinearBufSize;
|
|
break;
|
|
|
|
default:
|
|
rc = ASN1_ERR_BADARGS;
|
|
break;
|
|
}
|
|
|
|
return ASN1DecSetError(dec, rc);
|
|
}
|
|
|
|
return ASN1_ERR_BADARGS;
|
|
}
|
|
|
|
|
|
/* destroy decoding stream */
|
|
void ASN1_CloseDecoder
|
|
(
|
|
ASN1decoding_t dec
|
|
)
|
|
{
|
|
if (NULL != dec)
|
|
{
|
|
ASN1INTERNdecoding_t d = (ASN1INTERNdecoding_t)dec;
|
|
|
|
/* check magic number */
|
|
DecAssert(dec, MAGIC_DECODER == dec->magic);
|
|
|
|
if (d != d->parent)
|
|
{
|
|
DecAssert(dec, d == d->parent->child);
|
|
d->parent->child = NULL;
|
|
}
|
|
|
|
if ((NULL != d->info.buf)
|
|
&& (d->info.dwFlags & ASN1DECODE_AUTOFREEBUFFER))
|
|
MemFree(d->info.buf);
|
|
|
|
/* free decoding stream */
|
|
MemFree(d);
|
|
}
|
|
}
|
|
|
|
/* free an encoded value */
|
|
void ASN1_FreeEncoded
|
|
(
|
|
ASN1encoding_t enc,
|
|
void *val
|
|
)
|
|
{
|
|
if (NULL != enc)
|
|
{
|
|
/* check magic number */
|
|
EncAssert(enc, MAGIC_ENCODER == enc->magic);
|
|
|
|
EncMemFree(enc, val);
|
|
}
|
|
}
|
|
|
|
/* free a unencoded value */
|
|
void ASN1_FreeDecoded
|
|
(
|
|
ASN1decoding_t dec,
|
|
void *val,
|
|
ASN1uint32_t id
|
|
)
|
|
{
|
|
if (NULL != dec)
|
|
{
|
|
ASN1INTERNdecoding_t d = (ASN1INTERNdecoding_t)dec;
|
|
|
|
/* check magic number */
|
|
DecAssert(dec, MAGIC_DECODER == dec->magic);
|
|
|
|
// same behavior of LocalFree
|
|
if (val != NULL)
|
|
{
|
|
if (id != ASN1DECFREE_NON_PDU_ID)
|
|
{
|
|
ASN1FreeFun_t pfnFreeMemory;
|
|
|
|
/* free value */
|
|
if (id < dec->module->cPDUs)
|
|
{
|
|
if (NULL != (pfnFreeMemory = dec->module->apfnFreeMemory[id]))
|
|
{
|
|
(*pfnFreeMemory)(val);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
// free the top-level structure
|
|
DecMemFree(dec, val);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
ASN1module_t ASN1_CreateModule
|
|
(
|
|
ASN1uint32_t version,
|
|
ASN1encodingrule_e eEncodingRule,
|
|
ASN1uint32_t dwFlags,
|
|
ASN1uint32_t cPDUs,
|
|
const ASN1GenericFun_t apfnEncoder[],
|
|
const ASN1GenericFun_t apfnDecoder[],
|
|
const ASN1FreeFun_t apfnFreeMemory[],
|
|
const ASN1uint32_t acbStructSize[],
|
|
ASN1magic_t nModuleName
|
|
)
|
|
{
|
|
ASN1module_t module = NULL;
|
|
|
|
/* compiler output and library version match together? */
|
|
if (
|
|
// version <= ASN1_THIS_VERSION &&
|
|
NULL != apfnEncoder &&
|
|
NULL != apfnDecoder &&
|
|
NULL != apfnFreeMemory &&
|
|
NULL != acbStructSize)
|
|
{
|
|
if (NULL != (module = (ASN1module_t)MemAlloc(sizeof(*module), nModuleName)))
|
|
{
|
|
module->nModuleName = nModuleName;
|
|
module->eRule = eEncodingRule;
|
|
module->dwFlags = dwFlags;
|
|
module->cPDUs = cPDUs;
|
|
|
|
module->apfnFreeMemory = apfnFreeMemory;
|
|
module->acbStructSize = acbStructSize;
|
|
|
|
if (ASN1_PER_RULE & eEncodingRule)
|
|
{
|
|
module->PER.apfnEncoder = (const ASN1PerEncFun_t *) apfnEncoder;
|
|
module->PER.apfnDecoder = (const ASN1PerDecFun_t *) apfnDecoder;
|
|
}
|
|
#ifdef ENABLE_BER
|
|
else
|
|
if (ASN1_BER_RULE & eEncodingRule)
|
|
{
|
|
module->BER.apfnEncoder = (const ASN1BerEncFun_t *) apfnEncoder;
|
|
module->BER.apfnDecoder = (const ASN1BerDecFun_t *) apfnDecoder;
|
|
}
|
|
#endif // ENABLE_BER
|
|
}
|
|
}
|
|
return module;
|
|
}
|
|
|
|
|
|
void ASN1_CloseModule(ASN1module_t pModule)
|
|
{
|
|
MemFree(pModule);
|
|
}
|
|
|
|
|
|
|
|
#ifdef TEST_CODER
|
|
|
|
static int MyMemCmp(ASN1octet_t *p1, ASN1octet_t *p2, ASN1uint32_t c)
|
|
{
|
|
BYTE diff;
|
|
while (c--)
|
|
{
|
|
if ((diff = *p1++ - *p2++) != 0)
|
|
return (int) diff;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
__inline ASN1INTERNencoding_t TestEnc_GetEnc(ASN1INTERNencoding_t e)
|
|
{ return &(((ASN1testcoder_t) (e+1))->e); }
|
|
__inline ASN1INTERNdecoding_t TestEnc_GetDec(ASN1INTERNencoding_t e)
|
|
{ return &(((ASN1testcoder_t) (e+1))->d); }
|
|
__inline ASN1INTERNencoding_t TestDec_GetEnc(ASN1INTERNdecoding_t d)
|
|
{ return &(((ASN1testcoder_t) (d+1))->e); }
|
|
__inline ASN1INTERNdecoding_t TestDec_GetDec(ASN1INTERNdecoding_t d)
|
|
{ return &(((ASN1testcoder_t) (d+1))->d); }
|
|
|
|
static void Test_InitEnc(ASN1INTERNencoding_t e, ASN1module_t mod, ASN1encodingrule_e eRule)
|
|
{
|
|
ZeroMemory(e, sizeof(*e));
|
|
e->info.magic = MAGIC_ENCODER;
|
|
e->info.err = ASN1_SUCCESS;
|
|
e->info.module = mod;
|
|
e->info.eRule = eRule;
|
|
e->parent = e;
|
|
e->child = NULL;
|
|
}
|
|
|
|
static void Test_InitDec(ASN1INTERNdecoding_t d, ASN1module_t mod, ASN1encodingrule_e eRule)
|
|
{
|
|
ZeroMemory(d, sizeof(*d));
|
|
d->info.magic = MAGIC_DECODER;
|
|
d->info.err = ASN1_SUCCESS;
|
|
d->info.module = mod;
|
|
d->info.eRule = eRule;
|
|
d->parent = d;
|
|
d->child = NULL;
|
|
}
|
|
|
|
static int TestEnc_InitCoder(ASN1INTERNencoding_t e, ASN1module_t mod)
|
|
{
|
|
ASN1INTERNencoding_t ee = TestEnc_GetEnc(e);
|
|
ASN1INTERNdecoding_t ed = TestEnc_GetDec(e);
|
|
Test_InitEnc(ee, mod, e->info.eRule);
|
|
Test_InitDec(ed, mod, e->info.eRule);
|
|
return 1;
|
|
}
|
|
|
|
static int TestDec_InitCoder(ASN1INTERNdecoding_t d, ASN1module_t mod)
|
|
{
|
|
ASN1INTERNencoding_t de = TestDec_GetEnc(d);
|
|
ASN1INTERNdecoding_t dd = TestDec_GetDec(d);
|
|
Test_InitEnc(de, mod, d->info.eRule);
|
|
Test_InitDec(dd, mod, d->info.eRule);
|
|
return 1;
|
|
}
|
|
|
|
static int Test_Encode(ASN1INTERNencoding_t e, void *value, ASN1uint32_t id)
|
|
{
|
|
ASN1encoding_t enc = (ASN1encoding_t) e;
|
|
|
|
/* clear error */
|
|
ASN1EncSetError(enc, ASN1_SUCCESS);
|
|
|
|
// clean buffer
|
|
enc->pos = enc->buf;
|
|
enc->bit = enc->len = 0;
|
|
|
|
if (ASN1_PER_RULE & enc->eRule)
|
|
{
|
|
/* encode value */
|
|
ASN1PerEncFun_t pfnPER;
|
|
if (NULL != (pfnPER = enc->module->PER.apfnEncoder[id]))
|
|
{
|
|
if ((*pfnPER)(enc, value))
|
|
{
|
|
ASN1PEREncFlush(enc);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return ASN1EncSetError(enc, ASN1_ERR_BADPDU);
|
|
}
|
|
}
|
|
#ifdef ENABLE_BER
|
|
else
|
|
if (ASN1_BER_RULE & enc->eRule)
|
|
{
|
|
/* encode value */
|
|
ASN1BerEncFun_t pfnBER;
|
|
if (NULL != (pfnBER = enc->module->BER.apfnEncoder[id]))
|
|
{
|
|
if ((*pfnBER)(enc, 0, value)) // lonchanc: tag is 0 to make it compiled
|
|
{
|
|
ASN1BEREncFlush(enc);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return ASN1EncSetError(enc, ASN1_ERR_BADPDU);
|
|
}
|
|
}
|
|
#endif // ENABLE_BER
|
|
else
|
|
{
|
|
return ASN1EncSetError(enc, ASN1_ERR_RULE);
|
|
}
|
|
|
|
/* call abort/done function for non-parented encoding stream */
|
|
if (e->parent->info.err >= 0)
|
|
{
|
|
if (e == e->parent)
|
|
{
|
|
ASN1EncDone(enc);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASN1INTERNencoding_t child, child2;
|
|
|
|
if (e == e->parent)
|
|
{
|
|
ASN1EncAbort(enc);
|
|
}
|
|
|
|
// clean up...
|
|
ASN1_FreeEncoded(enc, enc->buf);
|
|
enc->pos = enc->buf = NULL;
|
|
enc->size = enc->len = enc->bit = 0;
|
|
for (child = e->child; child; child = child2)
|
|
{
|
|
child2 = child->child;
|
|
// make sure it does not touch its parent which may already be freed
|
|
child->parent = child;
|
|
ASN1_CloseEncoder((ASN1encoding_t) child);
|
|
}
|
|
e->child = NULL;
|
|
}
|
|
|
|
/* return error code */
|
|
return e->parent->info.err;
|
|
}
|
|
|
|
static int Test_Decode(ASN1INTERNdecoding_t d, void ** valref, ASN1uint32_t id, ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize)
|
|
{
|
|
ASN1decoding_t dec = (ASN1decoding_t) d;
|
|
ASN1uint32_t cbTopLevelStruct;
|
|
|
|
/* clear error */
|
|
ASN1DecSetError(dec, ASN1_SUCCESS);
|
|
|
|
// set up buffer containing encoded data
|
|
dec->pos = dec->buf = pbBuf;
|
|
dec->size = cbBufSize;
|
|
dec->bit = dec->len = 0;
|
|
|
|
/* clear length of linear buffer required */
|
|
d->cbLinearBufSize = 0;
|
|
d->fExtBuf = FALSE;
|
|
|
|
cbTopLevelStruct = dec->module->acbStructSize[id];
|
|
if (NULL != (*valref = DecMemAlloc(dec, cbTopLevelStruct)))
|
|
{
|
|
if (ASN1_PER_RULE & dec->eRule)
|
|
{
|
|
ASN1PerDecFun_t pfnPER;
|
|
/* decode value */
|
|
if (NULL != (pfnPER = dec->module->PER.apfnDecoder[id]))
|
|
{
|
|
if ((*pfnPER)(dec, *valref))
|
|
{
|
|
ASN1PERDecFlush(dec);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return ASN1DecSetError(dec, ASN1_ERR_BADPDU);
|
|
}
|
|
}
|
|
#ifdef ENABLE_BER
|
|
else
|
|
if (ASN1_BER_RULE & dec->eRule)
|
|
{
|
|
ASN1BerDecFun_t pfnBER;
|
|
/* decode value */
|
|
if (NULL != (pfnBER = dec->module->BER.apfnDecoder[id]))
|
|
{
|
|
if ((*pfnBER)(dec, 0, *valref))
|
|
{
|
|
ASN1BERDecFlush(dec);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return ASN1DecSetError(dec, ASN1_ERR_BADPDU);
|
|
}
|
|
}
|
|
#endif // ENABLE_BER
|
|
else
|
|
{
|
|
return ASN1DecSetError(dec, ASN1_ERR_RULE);
|
|
}
|
|
|
|
/* call abort/done function for non-parented decoding stream */
|
|
if (d->parent->info.err >= 0)
|
|
{
|
|
// not parented
|
|
if (d == d->parent)
|
|
{
|
|
ASN1DecDone(dec);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ASN1INTERNdecoding_t child, child2;
|
|
|
|
// not parented
|
|
if (d == d->parent)
|
|
{
|
|
ASN1DecAbort(dec);
|
|
}
|
|
|
|
// clean up...
|
|
ASN1_FreeDecoded(dec ,*valref, id);
|
|
*valref = NULL;
|
|
for (child = d->child; child; child = child2)
|
|
{
|
|
child2 = child->child;
|
|
// make sure it does not touch its parent which may already be freed
|
|
child->parent = child;
|
|
ASN1_CloseDecoder((ASN1decoding_t) child);
|
|
}
|
|
d->child = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return ASN1_ERR_MEMORY;
|
|
}
|
|
|
|
/* return error code */
|
|
return d->parent->info.err;
|
|
}
|
|
|
|
static void Test_CleanEnc(ASN1INTERNencoding_t e)
|
|
{
|
|
if (e->info.buf)
|
|
{
|
|
EncMemFree((ASN1encoding_t) e, e->info.buf);
|
|
}
|
|
Test_InitEnc(e, e->info.module, e->info.eRule);
|
|
}
|
|
|
|
static void Test_CleanDec(ASN1INTERNdecoding_t d)
|
|
{
|
|
Test_InitDec(d, d->info.module, d->info.eRule);
|
|
}
|
|
|
|
static int TestEnc_Compare(ASN1INTERNencoding_t e, ASN1uint32_t id, ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize)
|
|
{
|
|
ASN1INTERNencoding_t ee = TestEnc_GetEnc(e);
|
|
ASN1INTERNdecoding_t ed = TestEnc_GetDec(e);
|
|
int ret;
|
|
void *val = NULL;
|
|
int fRet = 0;
|
|
|
|
ee->info.eRule = e->info.eRule;
|
|
ed->info.eRule = e->info.eRule;
|
|
|
|
ret = Test_Decode(ed, &val, id, pbBuf, cbBufSize);
|
|
if (ret == ASN1_SUCCESS)
|
|
{
|
|
ret = Test_Encode(ee, val, id);
|
|
if (ret == ASN1_SUCCESS)
|
|
{
|
|
if (ee->info.len == cbBufSize)
|
|
{
|
|
fRet = (MyMemCmp(pbBuf, ee->info.buf, cbBufSize) == 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (val)
|
|
{
|
|
ASN1_FreeDecoded((ASN1decoding_t) ed, val, id);
|
|
}
|
|
|
|
Test_CleanEnc(ee);
|
|
Test_CleanDec(ed);
|
|
|
|
return fRet;
|
|
}
|
|
|
|
static int TestDec_Compare(ASN1INTERNdecoding_t d, ASN1uint32_t id, void *val, ASN1octet_t *pbBuf, ASN1uint32_t cbBufSize)
|
|
{
|
|
ASN1INTERNencoding_t de = TestDec_GetEnc(d);
|
|
int ret;
|
|
int fRet = 0;
|
|
|
|
de->info.eRule = d->info.eRule;
|
|
|
|
ret = Test_Encode(de, val, id);
|
|
if (ret == ASN1_SUCCESS)
|
|
{
|
|
if (de->info.len == cbBufSize)
|
|
{
|
|
fRet = (MyMemCmp(pbBuf, de->info.buf, cbBufSize) == 0);
|
|
}
|
|
}
|
|
|
|
Test_CleanEnc(de);
|
|
|
|
return fRet;
|
|
}
|
|
#endif
|
|
|