/* HEADER Testing ASN.1 encoding and decoding */
int i;
#if 0
snmp_set_do_debugging(TRUE);
debug_register_tokens("dumpv_recv,dumpv_send,asn");
#endif
{
const long intval[] = {
-0x80000000L,
-0x7fffffffL,
-0xffffL,
-3,
-1,
0,
1,
3,
0xffff,
0x7fffffff,
};
for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) {
u_char encoded[256];
size_t encoded_length;
u_char *build_result;
size_t decoded_length;
u_char decoded_type;
long decoded_value = 0;
u_char *parse_result;
u_char *rbuild_result = NULL;
size_t rbuild_len = 0;
size_t offset = 0;
encoded_length = sizeof(encoded);
build_result = asn_build_int(encoded, &encoded_length, ASN_INTEGER,
&intval[i], sizeof(intval[i]));
OKF(build_result + encoded_length == encoded + sizeof(encoded),
("asn_build_int(%ld)", intval[i]));
decoded_length = sizeof(encoded) - encoded_length;
parse_result = asn_parse_int(encoded, &decoded_length, &decoded_type,
&decoded_value, sizeof(decoded_value));
OKF(parse_result == build_result && decoded_type == ASN_INTEGER
&& decoded_value == intval[i],
("asn_parse_int(asn_build_int(%ld)) %s; decoded type %d <> %d;"
" decoded value %ld",
intval[i], parse_result == build_result ? "succeeded" : "failed",
decoded_type, ASN_INTEGER, decoded_value));
OKF(asn_realloc_rbuild_int(&rbuild_result, &rbuild_len, &offset, 1,
ASN_INTEGER, &intval[i], sizeof(intval[i])),
("asn_realloc_rbuild_int(%ld)", intval[i]));
OKF(sizeof(encoded) - encoded_length == offset &&
memcmp(encoded, rbuild_result + rbuild_len - offset,
offset) == 0,
("asn_build_int(%ld) != asn_realloc_rbuild_int(%ld)",
intval[i], intval[i]));
free (rbuild_result);
}
}
{
const unsigned long intval[] = {
0, 1, 3, 0xffff, 0x7fffffff, 0x80000000U, 0xffffffffU
};
for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) {
u_char encoded[256];
size_t encoded_length;
u_char *build_result;
size_t decoded_length;
u_char decoded_type;
unsigned long decoded_value = 0;
u_char *parse_result;
u_char *rbuild_result = NULL;
size_t rbuild_len = 0;
size_t offset = 0;
encoded_length = sizeof(encoded);
build_result = asn_build_unsigned_int(encoded, &encoded_length,
ASN_UINTEGER,
&intval[i], sizeof(intval[i]));
OKF(build_result + encoded_length == encoded + sizeof(encoded),
("asn_build_unsigned_int(%lu)", intval[i]));
decoded_length = sizeof(encoded) - encoded_length;
parse_result = asn_parse_unsigned_int(encoded, &decoded_length,
&decoded_type, &decoded_value,
sizeof(decoded_value));
OKF(parse_result && decoded_type == ASN_UINTEGER
&& decoded_value == intval[i],
("asn_parse_unsigned_int(asn_build_unsigned_int(%lu)) %s;"
" decoded type %d <> %d; decoded value %lu",
intval[i], parse_result == build_result ? "succeeded" : "failed",
decoded_type, ASN_UINTEGER, decoded_value));
OKF(asn_realloc_rbuild_unsigned_int(&rbuild_result, &rbuild_len,
&offset, 1, ASN_UINTEGER,
&intval[i], sizeof(intval[i])),
("asn_realloc_rbuild_unsigned_int(%lud)", intval[i]));
OKF(sizeof(encoded) - encoded_length == offset &&
memcmp(encoded, rbuild_result + rbuild_len - offset,
offset) == 0,
("asn_build_unsigned_int(%ld) != "
"asn_realloc_rbuild_unsigned_int(%ld)",
intval[i], intval[i]));
free (rbuild_result);
}
}
{
static struct {
unsigned char encoded[8];
unsigned encoded_len;
unsigned long decoded;
} data[] = {
{ { ASN_UINTEGER, 1, 0x80 }, 3, 0x80 },
{ { ASN_UINTEGER, 2, 0x80, 0x00 }, 4, 0x8000 },
{ { ASN_UINTEGER, 3, 0x80, 0x00, 0x00 }, 5, 0x800000 },
{ { ASN_UINTEGER, 4, 0x80, 0x00, 0x00, 0x00 }, 6, 0x80000000 },
};
for (i = 0; i < sizeof(data)/sizeof(data[0]); i++) {
size_t decoded_length;
u_char decoded_type;
unsigned long decoded_value = 0;
u_char *parse_result;
decoded_length = data[i].encoded_len;
parse_result = asn_parse_unsigned_int(data[i].encoded,
&decoded_length,
&decoded_type, &decoded_value,
sizeof(decoded_value));
OKF(parse_result && decoded_type == ASN_UINTEGER
&& decoded_value == data[i].decoded,
("asn_parse_unsigned_int(%02x %02x %02x %02x %02x %02x %02x %02x, %d) %s;"
" decoded type %d <> %d; decoded length %d; decoded value %lu",
data[i].encoded[0], data[i].encoded[1], data[i].encoded[2],
data[i].encoded[3], data[i].encoded[4], data[i].encoded[5],
data[i].encoded[6], data[i].encoded[7], data[i].encoded_len,
parse_result ? "succeeded" : "failed",
decoded_type, ASN_UINTEGER, (int)decoded_length, decoded_value));
}
}
#ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
#define TOINT64(c) ((long long)(long)(c).high << 32 | (c).low)
{
const struct counter64 intval[] = {
{ 0x80000000U, 0U },
{ 0x80000000U, 0xffffffffU },
{ 0xffffffffU, 0 },
{ 0xffffffffU, 0xffff0000U },
{ 0xffffffffU, 0xfffffffcU },
{ 0xffffffffU, 0xffffffffU },
{ 0, 0 },
{ 0, 1 },
{ 0, 3 },
{ 0, 0xffff },
{ 0, 0x7fffffff },
{ 1, 0 },
{ 1, 0xffffffff },
{ 0x7fffffff, 0 },
{ 0x7fffffff, 0xdeadbeef },
{ 0x7fffffff, 0xffffffff },
};
for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) {
u_char encoded[256];
size_t encoded_length;
u_char *build_result;
size_t decoded_length;
u_char decoded_type;
struct counter64 decoded_value = { 0 };
u_char *parse_result;
u_char *rbuild_result = NULL;
size_t rbuild_len = 0;
size_t offset = 0;
encoded_length = sizeof(encoded);
build_result = asn_build_signed_int64(encoded, &encoded_length,
ASN_OPAQUE_I64,
&intval[i], sizeof(intval[i]));
OKF(build_result + encoded_length == encoded + sizeof(encoded),
("asn_build_signed_int64(%lld)", TOINT64(intval[i])));
decoded_length = sizeof(encoded) - encoded_length;
parse_result = asn_parse_signed_int64(encoded, &decoded_length,
&decoded_type, &decoded_value,
sizeof(decoded_value));
OKF(parse_result == build_result && decoded_type == ASN_OPAQUE_I64
&& memcmp(&decoded_value, &intval[i], sizeof(decoded_value)) == 0,
("asn_parse_signed_int64(asn_build_signed_int64(%lld)) %s;"
" decoded type %d <> %d; decoded value %lld",
TOINT64(intval[i]),
parse_result == build_result ? "succeeded" : "failed",
decoded_type, ASN_OPAQUE_I64, TOINT64(decoded_value)));
OKF(asn_realloc_rbuild_signed_int64(&rbuild_result, &rbuild_len,
&offset, 1, ASN_OPAQUE_I64,
&intval[i], sizeof(intval[i])),
("asn_realloc_rbuild_signed_int64(%lld)", TOINT64(intval[i])));
OKF(sizeof(encoded) - encoded_length == offset &&
memcmp(encoded, rbuild_result + rbuild_len - offset,
offset) == 0,
("asn_build_signed_int64(%lld) != "
"asn_realloc_rbuild_signed_int64(%lld)",
TOINT64(intval[i]), TOINT64(intval[i])));
free (rbuild_result);
}
}
#endif
#define TOUINT64(c) ((unsigned long long)(c).high << 32 | (c).low)
{
const struct counter64 intval[] = {
{ 0, 0 },
{ 0, 1 },
{ 0, 3 },
{ 0, 0xffff },
{ 0, 0x7fffffff },
{ 0, 0x80000000 },
{ 0, 0xffffffff },
{ 1, 0 },
{ 1, 0xffffffff },
{ 0x7fffffff, 0 },
{ 0x7fffffff, 0xdeadbeef },
{ 0x7fffffff, 0xffffffff },
{ 0xffffffff, 0 },
{ 0xffffffff, 0xdeadbeef },
{ 0xffffffff, 0xffffffff },
};
for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) {
u_char encoded[256];
size_t encoded_length;
u_char *build_result;
size_t decoded_length;
u_char decoded_type;
struct counter64 decoded_value = { 0 };
u_char *parse_result;
u_char *rbuild_result = NULL;
size_t rbuild_len = 0;
size_t offset = 0;
encoded_length = sizeof(encoded);
build_result = asn_build_unsigned_int64(encoded, &encoded_length,
ASN_COUNTER64,
&intval[i], sizeof(intval[i]));
OKF(build_result + encoded_length == encoded + sizeof(encoded),
("asn_build_unsigned_int64(%llu)", TOUINT64(intval[i])));
decoded_length = sizeof(encoded) - encoded_length;
parse_result = asn_parse_unsigned_int64(encoded, &decoded_length,
&decoded_type, &decoded_value,
sizeof(decoded_value));
OKF(parse_result && decoded_type == ASN_COUNTER64
&& memcmp(&decoded_value, &intval[i], sizeof(decoded_value)) == 0,
("asn_parse_unsigned_int64(asn_build_unsigned_int64(%llu)) %s;"
" decoded type %d <> %d; decoded value %llu",
TOUINT64(intval[i]),
parse_result == build_result ? "succeeded" : "failed",
decoded_type, ASN_COUNTER64, TOUINT64(decoded_value)));
OKF(asn_realloc_rbuild_unsigned_int64(&rbuild_result, &rbuild_len,
&offset, 1, ASN_COUNTER64,
&intval[i], sizeof(intval[i])),
("asn_realloc_rbuild_unsigned_int64(%llud)", TOUINT64(intval[i])));
OKF(sizeof(encoded) - encoded_length == offset &&
memcmp(encoded, rbuild_result + rbuild_len - offset,
offset) == 0,
("asn_build_unsigned_int64(%lld) != "
"asn_realloc_rbuild_unsigned_int64(%lld)",
TOUINT64(intval[i]), TOUINT64(intval[i])));
free (rbuild_result);
}
#ifdef NETSNMP_WITH_OPAQUE_SPECIAL_TYPES
for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) {
u_char encoded[256];
size_t encoded_length;
u_char *build_result;
size_t decoded_length;
u_char decoded_type;
struct counter64 decoded_value = { 0 };
u_char *parse_result;
u_char *rbuild_result = NULL;
size_t rbuild_len = 0;
size_t offset = 0;
encoded_length = sizeof(encoded);
build_result = asn_build_unsigned_int64(encoded, &encoded_length,
ASN_OPAQUE_COUNTER64,
&intval[i], sizeof(intval[i]));
OKF(build_result + encoded_length == encoded + sizeof(encoded),
("asn_build_unsigned_int64(%llu)", TOUINT64(intval[i])));
decoded_length = sizeof(encoded) - encoded_length;
parse_result = asn_parse_unsigned_int64(encoded, &decoded_length,
&decoded_type, &decoded_value,
sizeof(decoded_value));
OKF(parse_result && decoded_type == ASN_OPAQUE_COUNTER64
&& memcmp(&decoded_value, &intval[i], sizeof(decoded_value)) == 0,
("asn_parse_unsigned_int64(asn_build_unsigned_int64(%llu)) %s;"
" decoded type %d <> %d; decoded value %llu",
TOUINT64(intval[i]),
parse_result == build_result ? "succeeded" : "failed",
decoded_type, ASN_OPAQUE_COUNTER64, TOUINT64(decoded_value)));
OKF(asn_realloc_rbuild_unsigned_int64(&rbuild_result, &rbuild_len,
&offset, 1, ASN_OPAQUE_COUNTER64,
&intval[i], sizeof(intval[i])),
("asn_realloc_rbuild_unsigned_int64(%llud)", TOUINT64(intval[i])));
OKF(sizeof(encoded) - encoded_length == offset &&
memcmp(encoded, rbuild_result + rbuild_len - offset,
offset) == 0,
("asn_build_unsigned_int64(%lld) != "
"asn_realloc_rbuild_unsigned_int64(%lld)",
TOUINT64(intval[i]), TOUINT64(intval[i])));
free (rbuild_result);
}
for (i = 0; i < sizeof(intval)/sizeof(intval[0]); ++i) {
u_char encoded[256];
size_t encoded_length;
u_char *build_result;
size_t decoded_length;
u_char decoded_type;
struct counter64 decoded_value = { 0 };
u_char *parse_result;
u_char *rbuild_result = NULL;
size_t rbuild_len = 0;
size_t offset = 0;
encoded_length = sizeof(encoded);
build_result = asn_build_unsigned_int64(encoded, &encoded_length,
ASN_OPAQUE_U64,
&intval[i], sizeof(intval[i]));
OKF(build_result + encoded_length == encoded + sizeof(encoded),
("asn_build_unsigned_int64(%llu)", TOUINT64(intval[i])));
decoded_length = sizeof(encoded) - encoded_length;
parse_result = asn_parse_unsigned_int64(encoded, &decoded_length,
&decoded_type, &decoded_value,
sizeof(decoded_value));
OKF(parse_result && decoded_type == ASN_OPAQUE_U64
&& memcmp(&decoded_value, &intval[i], sizeof(decoded_value)) == 0,
("asn_parse_unsigned_int64(asn_build_unsigned_int64(%llu)) %s;"
" decoded type %d <> %d; decoded value %llu",
TOUINT64(intval[i]),
parse_result == build_result ? "succeeded" : "failed",
decoded_type, ASN_OPAQUE_U64, TOUINT64(decoded_value)));
OKF(asn_realloc_rbuild_unsigned_int64(&rbuild_result, &rbuild_len,
&offset, 1, ASN_OPAQUE_U64,
&intval[i], sizeof(intval[i])),
("asn_realloc_rbuild_unsigned_int64(%llud)", TOUINT64(intval[i])));
OKF(sizeof(encoded) - encoded_length == offset &&
memcmp(encoded, rbuild_result + rbuild_len - offset,
offset) == 0,
("asn_build_unsigned_int64(%lld) != "
"asn_realloc_rbuild_unsigned_int64(%lld)",
TOUINT64(intval[i]), TOUINT64(intval[i])));
free (rbuild_result);
}
#endif
}