976 lines
27 KiB
C
976 lines
27 KiB
C
/* Copyright (C) Boris Nikolaus, Germany, 1996-1997. All rights reserved. */
|
|
/* Copyright (C) Microsoft Corporation, 1997-1998. All rights reserved. */
|
|
|
|
// lonchanc: we seem to have a significant amount of memory leak
|
|
// while dealing with real number and unlimited integers.
|
|
// we definitely want to re-visit all the following routines carefully
|
|
// in the future.
|
|
// moreover, we need to make sure all the memory allocation and free
|
|
// are either using encoding and decoding memory manager or kernel one.
|
|
// need to make sure we do not mix them together.
|
|
|
|
#include "precomp.h"
|
|
|
|
|
|
/* builtin intx values */
|
|
ASN1octet_t ASN1intx_0_[] = { 0 };
|
|
ASN1intx_t ASN1intx_0 = { 1, ASN1intx_0_ };
|
|
ASN1octet_t ASN1intx_1_[] = { 1 };
|
|
ASN1intx_t ASN1intx_1 = { 1, ASN1intx_1_ };
|
|
ASN1octet_t ASN1intx_2_[] = { 2 };
|
|
ASN1intx_t ASN1intx_2 = { 1, ASN1intx_2_ };
|
|
ASN1octet_t ASN1intx_16_[] = { 16 };
|
|
ASN1intx_t ASN1intx_16 = { 1, ASN1intx_16_ };
|
|
ASN1octet_t ASN1intx_256_[] = { 1, 0 };
|
|
ASN1intx_t ASN1intx_256 = { 2, ASN1intx_256_ };
|
|
ASN1octet_t ASN1intx_64K_[] = { 1, 0, 0 };
|
|
ASN1intx_t ASN1intx_64K = { 3, ASN1intx_64K_ };
|
|
ASN1octet_t ASN1intx_1G_[] = { 64, 0, 0, 0 };
|
|
ASN1intx_t ASN1intx_1G = { 4, ASN1intx_1G_ };
|
|
|
|
/* add two intx values */
|
|
void ASN1intx_add(ASN1intx_t *dst, ASN1intx_t *arg1, ASN1intx_t *arg2)
|
|
{
|
|
ASN1octet_t *v;
|
|
int l;
|
|
int s1, s2;
|
|
int o1, o2;
|
|
int i;
|
|
int c;
|
|
int w;
|
|
|
|
/* get signs */
|
|
s1 = arg1->value[0] > 0x7f ? 0xff : 0x00;
|
|
s2 = arg2->value[0] > 0x7f ? 0xff : 0x00;
|
|
|
|
/* result length will be <= l */
|
|
l = arg1->length > arg2->length ? arg1->length + 1 : arg2->length + 1;
|
|
|
|
/* offset into values */
|
|
o1 = l - arg1->length;
|
|
o2 = l - arg2->length;
|
|
|
|
/* allocate result */
|
|
v = (ASN1octet_t *)MemAlloc(l, UNKNOWN_MODULE);
|
|
if (v)
|
|
{
|
|
/* clear carry bit */
|
|
c = 0;
|
|
|
|
/* add octet by octet */
|
|
for (i = l - 1; i >= 0; i--) {
|
|
w = (i >= o1 ? arg1->value[i - o1] : s1) + (i >= o2 ? arg2->value[i - o2] : s2) + c;
|
|
v[i] = (ASN1octet_t)w;
|
|
c = w > 0xff;
|
|
}
|
|
|
|
/* octets which may shall dropped */
|
|
w = v[0] > 0x7f ? 0xff : 0x00;
|
|
|
|
/* count octets that shall be dropped */
|
|
for (i = 0; i < l - 1; i++) {
|
|
if (v[i] != w)
|
|
break;
|
|
}
|
|
if ((v[i] ^ w) & 0x80)
|
|
i--;
|
|
|
|
/* allocate and copy result */
|
|
dst->length = l - i;
|
|
dst->value = (ASN1octet_t *)MemAlloc(l - i, UNKNOWN_MODULE);
|
|
if (dst->value)
|
|
{
|
|
CopyMemory(dst->value, v + i, l - i);
|
|
}
|
|
MemFree(v);
|
|
}
|
|
}
|
|
|
|
/* substract two intx values */
|
|
void ASN1intx_sub(ASN1intx_t *dst, ASN1intx_t *arg1, ASN1intx_t *arg2)
|
|
{
|
|
ASN1octet_t *v;
|
|
int l;
|
|
int s1, s2;
|
|
int o1, o2;
|
|
int i;
|
|
int c;
|
|
int w;
|
|
|
|
/* get signs */
|
|
s1 = arg1->value[0] > 0x7f ? 0xff : 0x00;
|
|
s2 = arg2->value[0] > 0x7f ? 0xff : 0x00;
|
|
|
|
/* result length will be <= l */
|
|
l = arg1->length > arg2->length ? arg1->length + 1 : arg2->length + 1;
|
|
|
|
/* offset into values */
|
|
o1 = l - arg1->length;
|
|
o2 = l - arg2->length;
|
|
|
|
/* allocate result */
|
|
v = (ASN1octet_t *)MemAlloc(l, UNKNOWN_MODULE);
|
|
if (v)
|
|
{
|
|
/* clear borrow bit */
|
|
c = 0;
|
|
|
|
/* substract octet by octet */
|
|
for (i = l - 1; i >= 0; i--) {
|
|
w = (i >= o1 ? arg1->value[i - o1] : s1) - (i >= o2 ? arg2->value[i - o2] : s2) - c;
|
|
v[i] = (ASN1octet_t)w;
|
|
c = w < 0;
|
|
}
|
|
|
|
/* octets which may shall dropped */
|
|
w = v[0] > 0x7f ? 0xff : 0x00;
|
|
|
|
/* count octets that shall be dropped */
|
|
for (i = 0; i < l - 1; i++) {
|
|
if (v[i] != w)
|
|
break;
|
|
}
|
|
if ((v[i] ^ w) & 0x80)
|
|
i--;
|
|
|
|
// lonchanc: do we forget to free dst->value???
|
|
// in case that dst and arg1 are identical. for instance,
|
|
// ASN1BEREncReal() calls ASN1intx_sub(&exponent, &exponent, &help);
|
|
/* allocate and copy result */
|
|
dst->length = l - i;
|
|
dst->value = (ASN1octet_t *)MemAlloc(l - i, UNKNOWN_MODULE);
|
|
if (dst->value)
|
|
{
|
|
CopyMemory(dst->value, v + i, l - i);
|
|
}
|
|
MemFree(v);
|
|
}
|
|
}
|
|
|
|
/* add one octet to an intx */
|
|
#ifdef ENABLE_ALL
|
|
void ASN1intx_addoctet(ASN1intx_t *dst, ASN1intx_t *arg1, ASN1octet_t arg2)
|
|
{
|
|
ASN1octet_t *v;
|
|
int l;
|
|
int i;
|
|
int c;
|
|
int w;
|
|
|
|
/* result length will be <= l */
|
|
l = arg1->length + 1;
|
|
|
|
/* allocate result */
|
|
v = (ASN1octet_t *)MemAlloc(l, UNKNOWN_MODULE);
|
|
if (v)
|
|
{
|
|
/* add octet by octet */
|
|
c = arg2;
|
|
for (i = l - 2; i >= 0; i--) {
|
|
w = arg1->value[i] + c;
|
|
v[i + 1] = (ASN1octet_t)w;
|
|
c = (w > 0xff);
|
|
}
|
|
v[0] = arg1->value[0] > 0x7f ? (ASN1octet_t)(0xff + c) : (ASN1octet_t)c;
|
|
|
|
/* octets which may shall dropped */
|
|
w = v[0] > 0x7f ? 0xff : 0x00;
|
|
|
|
/* count octets that shall be dropped */
|
|
for (i = 0; i < l - 1; i++) {
|
|
if (v[i] != w)
|
|
break;
|
|
}
|
|
if ((v[i] ^ w) & 0x80)
|
|
i--;
|
|
|
|
/* allocate and copy result */
|
|
dst->length = l - i;
|
|
dst->value = (ASN1octet_t *)MemAlloc(l - i, UNKNOWN_MODULE);
|
|
if (dst->value)
|
|
{
|
|
CopyMemory(dst->value, v + i, l - i);
|
|
}
|
|
MemFree(v);
|
|
}
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* substract one octet to an intx */
|
|
#ifdef ENABLE_ALL
|
|
void ASN1intx_suboctet(ASN1intx_t *dst, ASN1intx_t *arg1, ASN1octet_t arg2)
|
|
{
|
|
ASN1octet_t *v;
|
|
int l;
|
|
int i;
|
|
int c;
|
|
int w;
|
|
|
|
/* result length will be <= l */
|
|
l = arg1->length + 1;
|
|
|
|
/* allocate result */
|
|
v = (ASN1octet_t *)MemAlloc(l, UNKNOWN_MODULE);
|
|
if (v)
|
|
{
|
|
/* substract octet by octet */
|
|
c = arg2;
|
|
for (i = l - 2; i >= 0; i--) {
|
|
w = arg1->value[i] - c;
|
|
v[i + 1] = (ASN1octet_t)w;
|
|
c = (w < 0);
|
|
}
|
|
v[0] = arg1->value[0] > 0x7f ? (ASN1octet_t)(0xff - c) : (ASN1octet_t)c;
|
|
|
|
/* octets which may shall dropped */
|
|
w = v[0] > 0x7f ? 0xff : 0x00;
|
|
|
|
/* count octets that shall be dropped */
|
|
for (i = 0; i < l - 1; i++) {
|
|
if (v[i] != w)
|
|
break;
|
|
}
|
|
if ((v[i] ^ w) & 0x80)
|
|
i--;
|
|
|
|
/* allocate and copy result */
|
|
dst->length = l - i;
|
|
dst->value = (ASN1octet_t *)MemAlloc(l - i, UNKNOWN_MODULE);
|
|
if (dst->value)
|
|
{
|
|
CopyMemory(dst->value, v + i, l - i);
|
|
}
|
|
MemFree(v);
|
|
}
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* multiply intx by an octet */
|
|
void ASN1intx_muloctet(ASN1intx_t *dst, ASN1intx_t *arg1, ASN1octet_t arg2)
|
|
{
|
|
ASN1octet_t *v;
|
|
int l;
|
|
int c;
|
|
int i;
|
|
int w;
|
|
|
|
/* result length will be <= l */
|
|
l = arg1->length + 1;
|
|
|
|
/* allocate result */
|
|
v = (ASN1octet_t *)MemAlloc(l, UNKNOWN_MODULE);
|
|
if (v)
|
|
{
|
|
/* multiply octet by octet */
|
|
c = 0;
|
|
for (i = l - 2; i >= 0; i--) {
|
|
w = arg1->value[i] * arg2 + c;
|
|
v[i + 1] = (ASN1octet_t)w;
|
|
c = w >> 8;
|
|
}
|
|
v[0] = (ASN1octet_t)(arg1->value[0] > 0x7f ? 0xff * arg2 + c : c);
|
|
|
|
/* octets which may shall dropped */
|
|
w = v[0] > 0x7f ? 0xff : 0x00;
|
|
|
|
/* count octets that shall be dropped */
|
|
for (i = 0; i < l - 1; i++) {
|
|
if (v[i] != w)
|
|
break;
|
|
}
|
|
if ((v[i] ^ w) & 0x80)
|
|
i--;
|
|
|
|
/* allocate and copy result */
|
|
dst->length = l - i;
|
|
dst->value = (ASN1octet_t *)MemAlloc(l - i, UNKNOWN_MODULE);
|
|
if (dst->value)
|
|
{
|
|
CopyMemory(dst->value, v + i, l - i);
|
|
}
|
|
MemFree(v);
|
|
}
|
|
}
|
|
|
|
/* increment an intx */
|
|
#ifdef ENABLE_ALL
|
|
void ASN1intx_inc(ASN1intx_t *val)
|
|
{
|
|
ASN1octet_t *v;
|
|
int l;
|
|
int i;
|
|
int w;
|
|
|
|
/* result length will be <= l */
|
|
l = val->length + 1;
|
|
|
|
/* allocate result */
|
|
v = (ASN1octet_t *)MemAlloc(l, UNKNOWN_MODULE);
|
|
if (v)
|
|
{
|
|
/* copy value */
|
|
CopyMemory(v + 1, val->value, l - 1);
|
|
MemFree(val->value);
|
|
v[0] = v[1] > 0x7f ? 0xff : 0x00;
|
|
|
|
/* increment value */
|
|
for (i = l - 1; i >= 0; i--) {
|
|
if (++v[i])
|
|
break;
|
|
}
|
|
|
|
/* octets which may shall dropped */
|
|
w = v[0] > 0x7f ? 0xff : 0x00;
|
|
|
|
/* count octets that shall be dropped */
|
|
for (i = 0; i < l - 1; i++) {
|
|
if (v[i] != w)
|
|
break;
|
|
}
|
|
if ((v[i] ^ w) & 0x80)
|
|
i--;
|
|
|
|
/* allocate and copy result */
|
|
val->length = l - i;
|
|
val->value = (ASN1octet_t *)MemAlloc(l - i, UNKNOWN_MODULE);
|
|
if (val->value)
|
|
{
|
|
CopyMemory(val->value, v + i, l - i);
|
|
}
|
|
MemFree(v);
|
|
}
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* decrement an intx */
|
|
#ifdef ENABLE_ALL
|
|
void ASN1intx_dec(ASN1intx_t *val)
|
|
{
|
|
ASN1octet_t *v;
|
|
int l;
|
|
int i;
|
|
int w;
|
|
|
|
/* result length will be <= l */
|
|
l = val->length + 1;
|
|
|
|
/* allocate result */
|
|
v = (ASN1octet_t *)MemAlloc(l, UNKNOWN_MODULE);
|
|
if (v)
|
|
{
|
|
/* copy value */
|
|
CopyMemory(v + 1, val->value, l - 1);
|
|
MemFree(val->value);
|
|
v[0] = v[1] > 0x7f ? 0xff : 0x00;
|
|
|
|
/* decrement value */
|
|
for (i = l - 1; i >= 0; i--) {
|
|
if (v[i]--)
|
|
break;
|
|
}
|
|
|
|
/* octets which may shall dropped */
|
|
w = v[0] > 0x7f ? 0xff : 0x00;
|
|
|
|
/* count octets that shall be dropped */
|
|
for (i = 0; i < l - 1; i++) {
|
|
if (v[i] != w)
|
|
break;
|
|
}
|
|
if ((v[i] ^ w) & 0x80)
|
|
i--;
|
|
|
|
/* allocate and copy result */
|
|
val->length = l - i;
|
|
val->value = (ASN1octet_t *)MemAlloc(l - i, UNKNOWN_MODULE);
|
|
if (val->value)
|
|
{
|
|
CopyMemory(val->value, v + i, l - i);
|
|
}
|
|
MemFree(v);
|
|
}
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* negate an intx value */
|
|
#ifdef ENABLE_ALL
|
|
void ASN1intx_neg(ASN1intx_t *dst, ASN1intx_t *arg)
|
|
{
|
|
ASN1uint32_t i;
|
|
|
|
/* duplicate value */
|
|
if (ASN1intx_dup(dst, arg))
|
|
{
|
|
/* ones complement */
|
|
for (i = 0; i < dst->length; i++)
|
|
dst->value[i] = ~dst->value[i];
|
|
|
|
/* and increment */
|
|
ASN1intx_inc(dst);
|
|
}
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* returns floor(log2(arg - 1)) */
|
|
#ifdef ENABLE_ALL
|
|
ASN1uint32_t ASN1intx_log2(ASN1intx_t *arg)
|
|
{
|
|
ASN1uint32_t i;
|
|
ASN1intx_t v;
|
|
ASN1uint32_t n;
|
|
|
|
if (ASN1intx_dup(&v, arg))
|
|
{
|
|
ASN1intx_dec(&v);
|
|
if (v.value[0] > 0x7f) {
|
|
ASN1intx_free(&v);
|
|
return 0;
|
|
}
|
|
for (i = 0; i < v.length; i++) {
|
|
if (v.value[i])
|
|
break;
|
|
}
|
|
if (i >= v.length) {
|
|
n = 0;
|
|
} else if (v.value[i] > 0x7f) {
|
|
n = 8 * (v.length - i - 1) + 8;
|
|
} else if (v.value[i] > 0x3f) {
|
|
n = 8 * (v.length - i - 1) + 7;
|
|
} else if (v.value[i] > 0x1f) {
|
|
n = 8 * (v.length - i - 1) + 6;
|
|
} else if (v.value[i] > 0x0f) {
|
|
n = 8 * (v.length - i - 1) + 5;
|
|
} else if (v.value[i] > 0x07) {
|
|
n = 8 * (v.length - i - 1) + 4;
|
|
} else if (v.value[i] > 0x03) {
|
|
n = 8 * (v.length - i - 1) + 3;
|
|
} else if (v.value[i] > 0x01) {
|
|
n = 8 * (v.length - i - 1) + 2;
|
|
} else {
|
|
n = 8 * (v.length - i - 1) + 1;
|
|
}
|
|
ASN1intx_free(&v);
|
|
return n;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* returns floor(log2(arg - 1)) */
|
|
#ifdef ENABLE_ALL
|
|
ASN1uint32_t ASN1uint32_log2(ASN1uint32_t arg)
|
|
{
|
|
ASN1uint32_t i;
|
|
|
|
arg--;
|
|
for (i = 32; i != 0; i--) {
|
|
if (arg & (1 << (i - 1)))
|
|
break;
|
|
}
|
|
return i;
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* returns floor(log256(arg - 1)) */
|
|
#ifdef ENABLE_ALL
|
|
ASN1uint32_t ASN1intx_log256(ASN1intx_t *arg)
|
|
{
|
|
ASN1uint32_t i;
|
|
ASN1intx_t v;
|
|
|
|
if (ASN1intx_dup(&v, arg))
|
|
{
|
|
ASN1intx_dec(&v);
|
|
if (v.value[0] > 0x7f) {
|
|
ASN1intx_free(&v);
|
|
return 0;
|
|
}
|
|
for (i = 0; i < v.length; i++) {
|
|
if (v.value[i])
|
|
break;
|
|
}
|
|
ASN1intx_free(&v);
|
|
return v.length - i;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* returns floor(log256(arg - 1)) */
|
|
#ifdef ENABLE_ALL
|
|
ASN1uint32_t ASN1uint32_log256(ASN1uint32_t arg)
|
|
{
|
|
if (arg > 0x10000) {
|
|
if (arg > 0x1000000)
|
|
return 4;
|
|
return 3;
|
|
}
|
|
if (arg > 0x100)
|
|
return 2;
|
|
if (arg > 1)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* compare two intx values; return 0 iff equal */
|
|
#ifdef ENABLE_ALL
|
|
ASN1int32_t ASN1intx_cmp(ASN1intx_t *arg1, ASN1intx_t *arg2)
|
|
{
|
|
int s1, s2;
|
|
int o1, o2;
|
|
int l;
|
|
int i;
|
|
int d;
|
|
|
|
s1 = arg1->value[0] > 0x7f ? 0xff : 0x00;
|
|
s2 = arg2->value[0] > 0x7f ? 0xff : 0x00;
|
|
if (s1 != s2)
|
|
return s1 == 0xff ? -1 : 1;
|
|
l = arg1->length > arg2->length ? arg1->length : arg2->length;
|
|
o1 = l - arg1->length;
|
|
o2 = l - arg2->length;
|
|
for (i = 0; i < l; i++) {
|
|
d = (i >= o1 ? arg1->value[i - o1] : s1) - (i >= o2 ? arg2->value[i - o2] : s2);
|
|
if (d)
|
|
return d;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* create an intx value from an uint32 value */
|
|
#ifdef ENABLE_ALL
|
|
void ASN1intx_setuint32(ASN1intx_t *dst, ASN1uint32_t val)
|
|
{
|
|
ASN1octet_t o[5], *v = o;
|
|
int n = 5;
|
|
v[0] = 0;
|
|
v[1] = (ASN1octet_t)(val >> 24);
|
|
v[2] = (ASN1octet_t)(val >> 16);
|
|
v[3] = (ASN1octet_t)(val >> 8);
|
|
v[4] = (ASN1octet_t)(val);
|
|
while (n > 1 && !*v && v[1] <= 0x7f) {
|
|
n--;
|
|
v++;
|
|
}
|
|
dst->length = n;
|
|
dst->value = (ASN1octet_t *)MemAlloc(n, UNKNOWN_MODULE);
|
|
if (dst->value)
|
|
{
|
|
CopyMemory(dst->value, v, n);
|
|
}
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* create an intx value from an int32 value */
|
|
#ifdef ENABLE_ALL
|
|
void ASN1intx_setint32(ASN1intx_t *dst, ASN1int32_t val)
|
|
{
|
|
ASN1octet_t o[5], *v = o;
|
|
int n = 5;
|
|
v[0] = (ASN1octet_t)(val < 0 ? 0xff : 0x00);
|
|
v[1] = (ASN1octet_t)(val >> 24);
|
|
v[2] = (ASN1octet_t)(val >> 16);
|
|
v[3] = (ASN1octet_t)(val >> 8);
|
|
v[4] = (ASN1octet_t)(val);
|
|
while (n > 1 && ((!*v && v[1] <= 0x7f) || (*v == 0xff && v[1] > 0x7f))) {
|
|
n--;
|
|
v++;
|
|
}
|
|
dst->length = n;
|
|
dst->value = (ASN1octet_t *)MemAlloc(n, UNKNOWN_MODULE);
|
|
if (dst->value)
|
|
{
|
|
CopyMemory(dst->value, v, n);
|
|
}
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* copy constructor */
|
|
ASN1int32_t ASN1intx_dup(ASN1intx_t *dst, ASN1intx_t *val)
|
|
{
|
|
dst->length = val->length;
|
|
dst->value = (ASN1octet_t *)MemAlloc(val->length, UNKNOWN_MODULE);
|
|
if (dst->value)
|
|
{
|
|
CopyMemory(dst->value, val->value, val->length);
|
|
return 1;
|
|
}
|
|
|
|
// fail to allocate memory
|
|
dst->length = 0;
|
|
return 0;
|
|
}
|
|
|
|
/* free an intx value */
|
|
void ASN1intx_free(ASN1intx_t *val)
|
|
{
|
|
if (val)
|
|
{
|
|
MemFree(val->value);
|
|
}
|
|
}
|
|
|
|
#ifdef HAS_SIXTYFOUR_BITS
|
|
/* convert an intx value to a uint64 value */
|
|
#ifdef ENABLE_ALL
|
|
ASN1uint64_t ASN1intx2uint64(ASN1intx_t *val)
|
|
{
|
|
switch (val->length) {
|
|
case 1:
|
|
return (ASN1uint64_t)val->value[val->length - 1];
|
|
case 2:
|
|
return (ASN1uint64_t)(val->value[val->length - 1] |
|
|
((ASN1uint32_t)val->value[val->length - 2] << 8));
|
|
case 3:
|
|
return (ASN1uint64_t)(val->value[val->length - 1] |
|
|
((ASN1uint32_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint32_t)val->value[val->length - 3] << 16));
|
|
case 4:
|
|
return (ASN1uint64_t)(val->value[val->length - 1] |
|
|
((ASN1uint32_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint32_t)val->value[val->length - 3] << 16) |
|
|
((ASN1uint32_t)val->value[val->length - 4] << 24));
|
|
case 5:
|
|
return (ASN1uint64_t)(val->value[val->length - 1] |
|
|
((ASN1uint64_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint64_t)val->value[val->length - 3] << 16) |
|
|
((ASN1uint64_t)val->value[val->length - 4] << 24) |
|
|
((ASN1uint64_t)val->value[val->length - 5] << 32));
|
|
case 6:
|
|
return (ASN1uint64_t)(val->value[val->length - 1] |
|
|
((ASN1uint64_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint64_t)val->value[val->length - 3] << 16) |
|
|
((ASN1uint64_t)val->value[val->length - 4] << 24) |
|
|
((ASN1uint64_t)val->value[val->length - 5] << 32) |
|
|
((ASN1uint64_t)val->value[val->length - 6] << 40));
|
|
case 7:
|
|
return (ASN1uint64_t)(val->value[val->length - 1] |
|
|
((ASN1uint64_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint64_t)val->value[val->length - 3] << 16) |
|
|
((ASN1uint64_t)val->value[val->length - 4] << 24) |
|
|
((ASN1uint64_t)val->value[val->length - 5] << 32) |
|
|
((ASN1uint64_t)val->value[val->length - 6] << 40) |
|
|
((ASN1uint64_t)val->value[val->length - 7] << 48));
|
|
default:
|
|
return (ASN1uint64_t)(val->value[val->length - 1] |
|
|
((ASN1uint64_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint64_t)val->value[val->length - 3] << 16) |
|
|
((ASN1uint64_t)val->value[val->length - 4] << 24) |
|
|
((ASN1uint64_t)val->value[val->length - 5] << 32) |
|
|
((ASN1uint64_t)val->value[val->length - 6] << 40) |
|
|
((ASN1uint64_t)val->value[val->length - 7] << 48) |
|
|
((ASN1uint64_t)val->value[val->length - 8] << 56));
|
|
}
|
|
}
|
|
#endif // ENABLE_ALL
|
|
#endif
|
|
|
|
/* check if intx value is a uint64 value */
|
|
#ifdef ENABLE_ALL
|
|
int ASN1intxisuint64(ASN1intx_t *val)
|
|
{
|
|
if (val->value[0] > 0x7f)
|
|
return 0;
|
|
return ASN1intx_uoctets(val) <= 8;
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
#ifdef HAS_SIXTYFOUR_BITS
|
|
/* convert an intx value to a int64 value */
|
|
#ifdef ENABLE_ALL
|
|
ASN1int64_t ASN1intx2int64(ASN1intx_t *val)
|
|
{
|
|
switch (val->length) {
|
|
case 1:
|
|
return (ASN1int64_t)(ASN1int8_t)val->value[val->length - 1];
|
|
case 2:
|
|
return (ASN1int64_t)(ASN1int16_t)(val->value[val->length - 1] |
|
|
((ASN1uint32_t)val->value[val->length - 2] << 8));
|
|
case 3:
|
|
return (ASN1int64_t)(ASN1int32_t)(val->value[val->length - 1] |
|
|
((ASN1uint32_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint32_t)val->value[val->length - 3] << 16) |
|
|
((ASN1uint32_t)val->value[val->length - 3] > 0x7f ?
|
|
0xffffffffff000000LL : 0));
|
|
case 4:
|
|
return (ASN1int64_t)(ASN1int32_t)(val->value[val->length - 1] |
|
|
((ASN1uint32_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint32_t)val->value[val->length - 3] << 16) |
|
|
((ASN1uint32_t)val->value[val->length - 4] << 24));
|
|
case 5:
|
|
return (ASN1int64_t)(val->value[val->length - 1] |
|
|
((ASN1uint64_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint64_t)val->value[val->length - 3] << 16) |
|
|
((ASN1uint64_t)val->value[val->length - 4] << 24) |
|
|
((ASN1uint64_t)val->value[val->length - 5] << 32) |
|
|
((ASN1uint64_t)val->value[val->length - 5] > 0x7f ?
|
|
0xffffff0000000000LL : 0));
|
|
case 6:
|
|
return (ASN1int64_t)(val->value[val->length - 1] |
|
|
((ASN1uint64_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint64_t)val->value[val->length - 3] << 16) |
|
|
((ASN1uint64_t)val->value[val->length - 4] << 24) |
|
|
((ASN1uint64_t)val->value[val->length - 5] << 32) |
|
|
((ASN1uint64_t)val->value[val->length - 6] << 40) |
|
|
((ASN1uint64_t)val->value[val->length - 6] > 0x7f ?
|
|
0xffff000000000000LL : 0));
|
|
case 7:
|
|
return (ASN1int64_t)((ASN1uint64_t)val->value[val->length - 1] |
|
|
((ASN1uint64_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint64_t)val->value[val->length - 3] << 16) |
|
|
((ASN1uint64_t)val->value[val->length - 4] << 24) |
|
|
((ASN1uint64_t)val->value[val->length - 5] << 32) |
|
|
((ASN1uint64_t)val->value[val->length - 6] << 40) |
|
|
((ASN1uint64_t)val->value[val->length - 7] << 48) |
|
|
((ASN1uint64_t)val->value[val->length - 7] > 0x7f ?
|
|
0xff00000000000000LL : 0));
|
|
default:
|
|
return (ASN1int64_t)((ASN1uint64_t)val->value[val->length - 1] |
|
|
((ASN1uint64_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint64_t)val->value[val->length - 3] << 16) |
|
|
((ASN1uint64_t)val->value[val->length - 4] << 24) |
|
|
((ASN1uint64_t)val->value[val->length - 5] << 32) |
|
|
((ASN1uint64_t)val->value[val->length - 6] << 40) |
|
|
((ASN1uint64_t)val->value[val->length - 7] << 48) |
|
|
((ASN1uint64_t)val->value[val->length - 8] << 56));
|
|
}
|
|
}
|
|
#endif // USE_ASN1intx2int64
|
|
#endif
|
|
|
|
/* check if intx value is an int64 value */
|
|
#ifdef USE_ASN1intxisint64
|
|
int
|
|
ASN1intxisint64(ASN1intx_t *val)
|
|
{
|
|
return ASN1intx_octets(val) <= 8;
|
|
}
|
|
#endif // USE_ASN1intxisint64
|
|
|
|
/* convert intx value to uint32 value */
|
|
#ifdef ENABLE_ALL
|
|
ASN1uint32_t ASN1intx2uint32(ASN1intx_t *val)
|
|
{
|
|
switch (val->length) {
|
|
case 1:
|
|
return (ASN1uint32_t)val->value[val->length - 1];
|
|
case 2:
|
|
return (ASN1uint32_t)(val->value[val->length - 1] |
|
|
((ASN1uint32_t)val->value[val->length - 2] << 8));
|
|
case 3:
|
|
return (ASN1uint32_t)(val->value[val->length - 1] |
|
|
((ASN1uint32_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint32_t)val->value[val->length - 3] << 16));
|
|
default:
|
|
return (ASN1uint32_t)(val->value[val->length - 1] |
|
|
((ASN1uint32_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint32_t)val->value[val->length - 3] << 16) |
|
|
((ASN1uint32_t)val->value[val->length - 4] << 24));
|
|
}
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* check if intx value is an uint32 value */
|
|
#ifdef ENABLE_ALL
|
|
int ASN1intxisuint32(ASN1intx_t *val)
|
|
{
|
|
if (val->value[0] > 0x7f)
|
|
return 0;
|
|
return ASN1intx_uoctets(val) <= 4;
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* convert intx value to int32 value */
|
|
ASN1int32_t ASN1intx2int32(ASN1intx_t *val)
|
|
{
|
|
switch (val->length) {
|
|
case 1:
|
|
return (ASN1int32_t)(ASN1int8_t)val->value[val->length - 1];
|
|
case 2:
|
|
return (ASN1int32_t)(ASN1int16_t)(val->value[val->length - 1] |
|
|
((ASN1uint32_t)val->value[val->length - 2] << 8));
|
|
case 3:
|
|
return (ASN1int32_t)(val->value[val->length - 1] |
|
|
((ASN1uint32_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint32_t)val->value[val->length - 3] << 16) |
|
|
((ASN1uint32_t)val->value[val->length - 3] > 0x7f ?
|
|
0xff000000 : 0));
|
|
default:
|
|
return (ASN1int32_t)(val->value[val->length - 1] |
|
|
((ASN1uint32_t)val->value[val->length - 2] << 8) |
|
|
((ASN1uint32_t)val->value[val->length - 3] << 16) |
|
|
((ASN1uint32_t)val->value[val->length - 4] << 24));
|
|
}
|
|
}
|
|
|
|
/* check if intx value is an int32 value */
|
|
#ifdef ENABLE_ALL
|
|
int ASN1intxisint32(ASN1intx_t *val)
|
|
{
|
|
return ASN1intx_octets(val) <= 4;
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* convert intx value to uint16 value */
|
|
#ifdef ENABLE_ALL
|
|
ASN1uint16_t ASN1intx2uint16(ASN1intx_t *val)
|
|
{
|
|
if (val->length == 1)
|
|
return (ASN1uint16_t)val->value[val->length - 1];
|
|
return (ASN1uint16_t)(val->value[val->length - 1] |
|
|
((ASN1uint32_t)val->value[val->length - 2] << 8));
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* check if intx value is an uint16 value */
|
|
#ifdef ENABLE_ALL
|
|
int ASN1intxisuint16(ASN1intx_t *val)
|
|
{
|
|
if (val->value[0] > 0x7f)
|
|
return 0;
|
|
return ASN1intx_uoctets(val) <= 2;
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* convert intx value to int16 value */
|
|
#ifdef ENABLE_ALL
|
|
ASN1int16_t ASN1intx2int16(ASN1intx_t *val)
|
|
{
|
|
if (val->length == 1)
|
|
return (ASN1int16_t)(ASN1int8_t)val->value[val->length - 1];
|
|
return (ASN1int16_t)(val->value[val->length - 1] |
|
|
((ASN1uint32_t)val->value[val->length - 2] << 8));
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* check if intx value is an int16 value */
|
|
#ifdef ENABLE_ALL
|
|
int ASN1intxisint16(ASN1intx_t *val)
|
|
{
|
|
return ASN1intx_octets(val) <= 2;
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* convert intx value to uint8 value */
|
|
#ifdef ENABLE_ALL
|
|
ASN1uint8_t ASN1intx2uint8(ASN1intx_t *val)
|
|
{
|
|
return (ASN1uint8_t)val->value[val->length - 1];
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* check if intx value is an uint8 value */
|
|
#ifdef ENABLE_ALL
|
|
int ASN1intxisuint8(ASN1intx_t *val)
|
|
{
|
|
if (val->value[0] > 0x7f)
|
|
return 0;
|
|
return ASN1intx_uoctets(val) <= 1;
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* convert intx value to int8 value */
|
|
#ifdef ENABLE_ALL
|
|
ASN1int8_t ASN1intx2int8(ASN1intx_t *val)
|
|
{
|
|
return (ASN1int8_t)val->value[val->length - 1];
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* check if intx value is an int8 value */
|
|
#ifdef ENABLE_ALL
|
|
int ASN1intxisint8(ASN1intx_t *val)
|
|
{
|
|
return ASN1intx_octets(val) <= 1;
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* count octets for a signed encoding of an intx value */
|
|
#ifdef ENABLE_ALL
|
|
ASN1uint32_t ASN1intx_octets(ASN1intx_t *val)
|
|
{
|
|
ASN1uint32_t i;
|
|
ASN1uint32_t s;
|
|
|
|
s = val->value[0] > 0x7f ? 0xff : 0x00;
|
|
for (i = 0; i < val->length; i++) {
|
|
if (val->value[i] != s)
|
|
break;
|
|
}
|
|
if (i && ((val->value[i] ^ s) & 0x80))
|
|
i--;
|
|
return val->length - i;
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* count octets for unsigned encoding of an unsigned intx value */
|
|
ASN1uint32_t ASN1intx_uoctets(ASN1intx_t *val)
|
|
{
|
|
ASN1uint32_t i;
|
|
|
|
for (i = 0; i < val->length; i++) {
|
|
if (val->value[i])
|
|
break;
|
|
}
|
|
return val->length - i;
|
|
}
|
|
|
|
/* count octets for signed encoding of an uint32 value */
|
|
#ifdef ENABLE_ALL
|
|
ASN1uint32_t ASN1uint32_octets(ASN1uint32_t val)
|
|
{
|
|
if (val >= 0x8000) {
|
|
if (val >= 0x800000) {
|
|
return ((val >= 0x80000000) ? 5 : 4);
|
|
}
|
|
return 3;
|
|
}
|
|
return ((val >= 0x80) ? 2 : 1);
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|
|
/* count octets for unsigned encoding of an uint32 value */
|
|
ASN1uint32_t ASN1uint32_uoctets(ASN1uint32_t val)
|
|
{
|
|
if (val >= 0x10000) {
|
|
return ((val >= 0x1000000) ? 4 : 3);
|
|
}
|
|
return ((val >= 0x100) ? 2 : 1);
|
|
}
|
|
|
|
/* count octets for signed encoding of an int32 value */
|
|
ASN1uint32_t ASN1int32_octets(ASN1int32_t val)
|
|
{
|
|
if (val >= 0) {
|
|
if (val >= 0x8000) {
|
|
return ((val >= 0x800000) ? 4 : 3);
|
|
}
|
|
return ((val >= 0x80) ? 2 : 1);
|
|
}
|
|
if (val < -0x8000) {
|
|
return ((val < -0x800000) ? 4 : 3);
|
|
}
|
|
return ((val < -0x80) ? 2 : 1);
|
|
}
|
|
|
|
/* convert an intx value into a double */
|
|
#ifdef ENABLE_ALL
|
|
double ASN1intx2double(ASN1intx_t *val)
|
|
{
|
|
double ret;
|
|
ASN1uint32_t i;
|
|
|
|
if (val->value[0] > 0x7f)
|
|
ret = (double)(val->value[0] - 0x100);
|
|
else
|
|
ret = (double)val->value[0];
|
|
for (i = 1; i < val->length; i++) {
|
|
ret = ret * 256.0 + (double)val->value[i];
|
|
}
|
|
return ret;
|
|
}
|
|
#endif // ENABLE_ALL
|
|
|