mirror of
https://gitlab.nic.cz/labs/bird.git
synced 2024-12-23 10:11:53 +00:00
1826 lines
45 KiB
C
1826 lines
45 KiB
C
/*
|
|
* BIRD -- Simple Network Management Protocol (SNMP) Unit tests
|
|
*
|
|
* (c) 2022 Vojtech Vilimek <vojtech.vilimek@nic.cz>
|
|
* (c) 2022 CZ.NIC z.s.p.o
|
|
*
|
|
* Can be freely distributed and used under the terms of the GNU GPL.
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include "test/birdtest.h"
|
|
#include "test/bt-utils.h"
|
|
|
|
#include "bgp4_mib.h"
|
|
#include "subagent.h"
|
|
#include "snmp.h"
|
|
#include "snmp_utils.h"
|
|
#include "mib_tree.h"
|
|
|
|
/*************************************************************************
|
|
*
|
|
* TODO: reject OIDs longer than OID_MAX_LEN in subagent.c/snmp_utils.c
|
|
*
|
|
*************************************************************************/
|
|
|
|
// TODO: limit for prefixed OID used for walking is 27 ids (32 - 4inet -1prefix
|
|
// resp. 33 - 4inet-1prefix-1empty)
|
|
|
|
// TODO test walk state stack overflow
|
|
// TODO hint for child len alloc size
|
|
|
|
static int t_oid_empty(void);
|
|
static int t_oid_compare(void);
|
|
static int t_oid_prefixize(void);
|
|
static int t_walk_oid_desc(void);
|
|
static int t_tree_find(void);
|
|
static int t_tree_traversal(void);
|
|
static int t_tree_leafs(void);
|
|
static int t_tree_add(void);
|
|
static int t_tree_delete(void);
|
|
|
|
#define SNMP_BUFFER_SIZE 1024
|
|
#define TESTS_NUM 32
|
|
#define SMALL_TESTS_NUM 10
|
|
static int tree_sizes[] = { 0, 1, 10, 100, 1000 };
|
|
|
|
/* smaller than theoretical maximum (2^32) to fit in memory */
|
|
#define OID_MAX_ID 16
|
|
|
|
#define SNMP_EXPECTED(actual, expected) \
|
|
bt_debug("%s expected: %3u actual: %3u\n", \
|
|
#expected, expected, actual);
|
|
|
|
static inline struct oid *
|
|
oid_allocate(uint size)
|
|
{
|
|
return tmp_alloc(sizeof(struct oid) + size * sizeof(u32));
|
|
}
|
|
|
|
static inline void
|
|
oid_init2(struct oid *oid, u8 n_subid, u8 prefix, u8 include, va_list ids)
|
|
{
|
|
oid->n_subid = n_subid;
|
|
oid->prefix = prefix;
|
|
oid->include = include;
|
|
oid->reserved = 0;
|
|
|
|
for (u8 i = 0; i < n_subid; i++)
|
|
{
|
|
u32 id = va_arg(ids, u32);
|
|
oid->ids[i] = id;
|
|
}
|
|
}
|
|
|
|
static inline void
|
|
oid_init(struct oid *oid, u8 n_subid, u8 prefix, u8 include, ...)
|
|
{
|
|
va_list ids;
|
|
va_start(ids, include);
|
|
oid_init2(oid, n_subid, prefix, include, ids);
|
|
va_end(ids);
|
|
}
|
|
|
|
static inline struct oid *
|
|
oid_create(u8 n_subid, u8 prefix, u8 include, ...)
|
|
{
|
|
struct oid *result = tmp_alloc(snmp_oid_size_from_len(n_subid));
|
|
va_list ids;
|
|
|
|
va_start(ids, include);
|
|
oid_init2(result, n_subid, prefix, include, ids);
|
|
va_end(ids);
|
|
|
|
return result;
|
|
}
|
|
|
|
static u32
|
|
xrandom(u32 max)
|
|
{
|
|
return (bt_random() % max);
|
|
}
|
|
|
|
static u32
|
|
oid_random_id(void)
|
|
{
|
|
return (bt_random() % (OID_MAX_ID));
|
|
}
|
|
|
|
static struct oid *
|
|
random_prefixed_oid(void)
|
|
{
|
|
u32 len = xrandom(OID_MAX_LEN + 1 - (ARRAY_SIZE(snmp_internet) + 1));
|
|
|
|
u8 prefix = (u8) xrandom(UINT8_MAX + 1);
|
|
|
|
if (!prefix)
|
|
return oid_create(0, 0, 0, 0);
|
|
|
|
struct oid *random = tmp_alloc(snmp_oid_size_from_len(len));
|
|
/* (xrandom(2) * bt_random()) has 0.5 probability to have value 0 and
|
|
* 0.5 to have random u32 (including zero) */
|
|
oid_init(random, 0, prefix, xrandom(2) * bt_random());
|
|
random->n_subid = len;
|
|
|
|
for (u32 id = 0; id < len; id++)
|
|
random->ids[id] = oid_random_id();
|
|
|
|
return random;
|
|
}
|
|
|
|
static struct oid *
|
|
random_no_prefix_oid(void)
|
|
{
|
|
/* probability that the random OID is prefixable is practically zero */
|
|
u32 len = xrandom(OID_MAX_LEN + 1);
|
|
|
|
struct oid *random = tmp_alloc(snmp_oid_size_from_len(len));
|
|
/* (xrandom(2) * bt_random()) has 0.5 probability to have value 0 and
|
|
* 0.5 to have random u32 (including zero) */
|
|
oid_init(random, 0, 0, xrandom(2) * bt_random());
|
|
random->n_subid = len;
|
|
|
|
for (u32 id = 0; id < len; id++)
|
|
random->ids[id] = oid_random_id();
|
|
|
|
return random;
|
|
}
|
|
|
|
static struct oid *
|
|
random_prefixable_oid(void)
|
|
{
|
|
/* generate the len without the snmp_internet prefix included and prefix ID */
|
|
u32 len = xrandom(OID_MAX_LEN + 1 - (ARRAY_SIZE(snmp_internet) + 1));
|
|
|
|
struct oid *random = tmp_alloc(
|
|
snmp_oid_size_from_len(len + ARRAY_SIZE(snmp_internet) + 1));
|
|
/* (xrandom(2) * bt_random()) has 0.5 probability to have value 0 and
|
|
* 0.5 to have random u32 (including zero) */
|
|
oid_init(random, 0, 0, xrandom(2) * bt_random());
|
|
random->n_subid = len + ARRAY_SIZE(snmp_internet) + 1;
|
|
|
|
for (u32 inet_id = 0; inet_id < ARRAY_SIZE(snmp_internet); inet_id++)
|
|
random->ids[inet_id] = snmp_internet[inet_id];
|
|
|
|
random->ids[ARRAY_SIZE(snmp_internet)] = xrandom(UINT8_MAX + 1);
|
|
|
|
for (u32 id = 0; id < len; id++)
|
|
random->ids[id + ARRAY_SIZE(snmp_internet) + 1] = oid_random_id();
|
|
|
|
return random;
|
|
}
|
|
|
|
static struct oid *
|
|
random_oid(void)
|
|
{
|
|
u32 option = xrandom(3);
|
|
|
|
if (option == 0)
|
|
return random_prefixed_oid();
|
|
else if (option == 1)
|
|
return random_no_prefix_oid();
|
|
else
|
|
return random_prefixable_oid();
|
|
}
|
|
|
|
static int
|
|
t_oid_empty(void)
|
|
{
|
|
struct lp_state tmps;
|
|
lp_save(tmp_linpool, &tmps);
|
|
|
|
bt_assert(snmp_is_oid_empty(NULL) == 0);
|
|
|
|
{
|
|
struct oid *blank = oid_create(0, 0, 0 /* no ids */);
|
|
bt_assert(snmp_is_oid_empty(blank) == 1);
|
|
lp_restore(tmp_linpool, &tmps);
|
|
}
|
|
|
|
|
|
{
|
|
struct oid *prefixed = oid_create(3, 100, 1,
|
|
/* ids */ ~((u32) 0), 0, 256);
|
|
bt_assert(snmp_is_oid_empty(prefixed) == 0);
|
|
lp_restore(tmp_linpool, &tmps);
|
|
}
|
|
|
|
|
|
{
|
|
struct oid *to_prefix = oid_create(8, 0, 1,
|
|
/* ids */ 1, 3, 6, 1, 100, ~((u32) 0), 0, 256);
|
|
bt_assert(snmp_is_oid_empty(to_prefix) == 0);
|
|
lp_restore(tmp_linpool, &tmps);
|
|
}
|
|
|
|
|
|
{
|
|
struct oid *unprefixable = oid_create(2, 0, 0,
|
|
/* ids */ 65535, 4);
|
|
bt_assert(snmp_is_oid_empty(unprefixable) == 0);
|
|
lp_restore(tmp_linpool, &tmps);
|
|
}
|
|
|
|
{
|
|
struct oid *unprefixable2 = oid_create(8, 0, 1,
|
|
/* ids */ 1, 3, 6, 2, 1, 2, 15, 6);
|
|
bt_assert(snmp_is_oid_empty(unprefixable2) == 0);
|
|
lp_restore(tmp_linpool, &tmps);
|
|
}
|
|
|
|
tmp_flush();
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
t_oid_compare(void)
|
|
{
|
|
struct lp_state tmps;
|
|
lp_save(tmp_linpool, &tmps);
|
|
|
|
/* same length, no prefix */
|
|
struct oid *l1 = oid_create(5, 0, 1,
|
|
/* ids */ 1, 2, 3, 4, 5);
|
|
|
|
struct oid *r1 = oid_create(5, 0, 0,
|
|
/* ids */ 1, 2, 3, 4, 6);
|
|
|
|
bt_assert(snmp_oid_compare(l1, r1) == -1);
|
|
bt_assert(snmp_oid_compare(r1, l1) == 1);
|
|
|
|
bt_assert(snmp_oid_compare(l1, l1) == 0);
|
|
bt_assert(snmp_oid_compare(r1, r1) == 0);
|
|
|
|
/* same results for prefixed oids */
|
|
l1->prefix = 1;
|
|
r1->prefix = 1;
|
|
|
|
bt_assert(snmp_oid_compare(l1, r1) == -1);
|
|
bt_assert(snmp_oid_compare(r1, l1) == 1);
|
|
|
|
bt_assert(snmp_oid_compare(l1, l1) == 0);
|
|
bt_assert(snmp_oid_compare(r1, r1) == 0);
|
|
|
|
/* different prefix -- has higher priority */
|
|
l1->prefix = 8;
|
|
r1->prefix = 4;
|
|
|
|
bt_assert(snmp_oid_compare(l1, r1) == 1);
|
|
bt_assert(snmp_oid_compare(r1, l1) == -1);
|
|
|
|
bt_assert(snmp_oid_compare(l1, l1) == 0);
|
|
bt_assert(snmp_oid_compare(r1, r1) == 0);
|
|
|
|
lp_restore(tmp_linpool, &tmps);
|
|
|
|
|
|
/* different length, no prefix */
|
|
l1 = oid_create(4, 0, 0,
|
|
/* ids */ 1, 2, 3, 4);
|
|
|
|
r1 = oid_create(5, 0, 1,
|
|
/* ids */ 1, 2, 3, 4, 1);
|
|
|
|
bt_assert(snmp_oid_compare(l1, r1) == -1);
|
|
bt_assert(snmp_oid_compare(r1, l1) == 1);
|
|
|
|
bt_assert(snmp_oid_compare(l1, l1) == 0);
|
|
bt_assert(snmp_oid_compare(r1, r1) == 0);
|
|
|
|
/* same results for prefixed oids */
|
|
l1->prefix = 3;
|
|
r1->prefix = 3;
|
|
|
|
bt_assert(snmp_oid_compare(l1, r1) == -1);
|
|
bt_assert(snmp_oid_compare(r1, l1) == 1);
|
|
|
|
bt_assert(snmp_oid_compare(l1, l1) == 0);
|
|
bt_assert(snmp_oid_compare(r1, r1) == 0);
|
|
|
|
/* different prefix -- has higher priority */
|
|
l1->prefix = 17;
|
|
r1->prefix = 14;
|
|
|
|
bt_assert(snmp_oid_compare(l1, r1) == 1);
|
|
bt_assert(snmp_oid_compare(r1, l1) == -1);
|
|
|
|
bt_assert(snmp_oid_compare(l1, l1) == 0);
|
|
bt_assert(snmp_oid_compare(r1, r1) == 0);
|
|
|
|
lp_restore(tmp_linpool, &tmps);
|
|
|
|
|
|
/* inverse order different length, no prefix */
|
|
l1 = oid_create(4, 0, 0,
|
|
/* ids */ 1, 2, 3, 5);
|
|
|
|
r1 = oid_create(5, 0, 0,
|
|
/* ids */ 1, 2, 3, 4, 1);
|
|
|
|
bt_assert(snmp_oid_compare(l1, r1) == 1);
|
|
bt_assert(snmp_oid_compare(r1, l1) == -1);
|
|
|
|
bt_assert(snmp_oid_compare(l1, l1) == 0);
|
|
bt_assert(snmp_oid_compare(r1, r1) == 0);
|
|
|
|
/* same results for prefixed oids */
|
|
l1->prefix = 254;
|
|
r1->prefix = 254;
|
|
|
|
bt_assert(snmp_oid_compare(l1, r1) == 1);
|
|
bt_assert(snmp_oid_compare(r1, l1) == -1);
|
|
|
|
bt_assert(snmp_oid_compare(l1, l1) == 0);
|
|
bt_assert(snmp_oid_compare(r1, r1) == 0);
|
|
|
|
/* different prefix -- has higher priority */
|
|
l1->prefix = 127;
|
|
r1->prefix = 35;
|
|
|
|
bt_assert(snmp_oid_compare(l1, r1) == 1);
|
|
bt_assert(snmp_oid_compare(r1, l1) == -1);
|
|
|
|
lp_restore(tmp_linpool, &tmps);
|
|
|
|
|
|
/* ==== MIXED PREFIXED / NON PREFIXED OID compare ==== */
|
|
/* same length, mixed */
|
|
l1 = oid_create(6, 0, 1,
|
|
/* ids */ 1, 2, 17, 3, 21, 4);
|
|
|
|
r1 = oid_create(1, 5, 1,
|
|
/* ids */ 3);
|
|
|
|
bt_assert(snmp_oid_compare(l1, r1) == -1);
|
|
bt_assert(snmp_oid_compare(r1, l1) == 1);
|
|
|
|
bt_assert(snmp_oid_compare(l1, l1) == 0);
|
|
bt_assert(snmp_oid_compare(r1, r1) == 0);
|
|
|
|
lp_restore(tmp_linpool, &tmps);
|
|
|
|
struct oid *super = oid_create(4, 0, 0, /* ids */ 1, 3, 6, 1);
|
|
struct oid *weird = oid_create(4, 70, 0, /* ids */ 9, 10, 10, 12);
|
|
|
|
bt_assert(snmp_oid_compare(super, weird) != 0);
|
|
|
|
struct oid *pref = oid_create(0, 7, 0); // no ids, only prefix
|
|
struct oid *no_pref = oid_create(5, 0, 0, /* ids */ 1, 3, 6, 1, 7);
|
|
|
|
bt_assert(snmp_oid_compare(pref, no_pref) == 0);
|
|
|
|
struct oid *inet = oid_create(4, 0, 0, /* ids */ 1, 3, 6, 1);
|
|
|
|
bt_assert(snmp_oid_compare(inet, pref) < 0);
|
|
bt_assert(snmp_oid_compare(pref, inet) > 0);
|
|
bt_assert(snmp_oid_compare(inet, no_pref) < 0);
|
|
bt_assert(snmp_oid_compare(no_pref, inet) > 0);
|
|
|
|
struct oid *pref2 = oid_create(0, 16, 0); // no ids, only prefix
|
|
struct oid *no_pref2 = oid_create(5, 0, 0, /* ids */ 1, 3, 6, 1, 16);
|
|
|
|
bt_assert(snmp_oid_compare(pref2, no_pref2) == 0);
|
|
bt_assert(snmp_oid_compare(no_pref2, pref2) == 0);
|
|
|
|
bt_assert(snmp_oid_compare(pref, pref2) < 0);
|
|
bt_assert(snmp_oid_compare(pref2, pref) > 0);
|
|
bt_assert(snmp_oid_compare(pref, no_pref2) < 0);
|
|
bt_assert(snmp_oid_compare(no_pref2, pref) > 0);
|
|
bt_assert(snmp_oid_compare(no_pref, pref2) < 0);
|
|
bt_assert(snmp_oid_compare(pref2, no_pref) > 0);
|
|
bt_assert(snmp_oid_compare(no_pref, no_pref2) < 0);
|
|
bt_assert(snmp_oid_compare(no_pref2, no_pref) > 0);
|
|
|
|
|
|
tmp_flush();
|
|
return 1;
|
|
}
|
|
|
|
static struct oid *
|
|
snmp_oid_prefixize(struct snmp_proto *p, const struct oid *oid, struct snmp_pdu *c)
|
|
{
|
|
struct agentx_varbind *vb = snmp_vb_to_tx(p, oid, c);
|
|
bt_assert(vb->reserved == 0);
|
|
return &vb->name;
|
|
}
|
|
|
|
/*
|
|
* t_oid_prefixize - test prefixing aspect of function snmp_vb_to_tx()
|
|
*/
|
|
static int
|
|
t_oid_prefixize(void)
|
|
{
|
|
lp_state tmps = { };
|
|
struct snmp_proto *snmp_proto = NULL;
|
|
|
|
byte *buffer = tmp_alloc(SNMP_BUFFER_SIZE);
|
|
const struct snmp_pdu copy = {
|
|
.buffer = buffer,
|
|
.size = SNMP_BUFFER_SIZE,
|
|
.error = AGENTX_RES_NO_ERROR,
|
|
.index = 0,
|
|
};
|
|
struct snmp_pdu c;
|
|
|
|
lp_save(tmp_linpool, &tmps);
|
|
|
|
|
|
/* testing prefixable OIDs */
|
|
for (int test = 0; test < TESTS_NUM; test++)
|
|
{
|
|
const struct oid *oid = random_prefixable_oid();
|
|
|
|
u8 subids = oid->n_subid;
|
|
u8 include = oid->include;
|
|
u32 pid = oid->ids[ARRAY_SIZE(snmp_internet)];
|
|
|
|
/* reset to the default snmp_pdu */
|
|
c = copy; memset(buffer, 0, snmp_oid_size(oid) + 8);
|
|
|
|
struct oid *new = snmp_oid_prefixize(snmp_proto, oid, &c);
|
|
|
|
bt_assert(new->n_subid == subids - (ARRAY_SIZE(snmp_internet) + 1));
|
|
bt_assert(new->prefix == pid);
|
|
bt_assert(!!new->include == !!include);
|
|
bt_assert(new->reserved == 0);
|
|
|
|
for (u32 i = 0; i < new->n_subid; i++)
|
|
{
|
|
bt_assert(new->ids[i] == oid->ids[i + ARRAY_SIZE(snmp_internet) + 1]);
|
|
}
|
|
|
|
for (u32 j = 0; j < ARRAY_SIZE(snmp_internet); j++)
|
|
bt_assert(oid->ids[j] == snmp_internet[j]);
|
|
|
|
lp_restore(tmp_linpool, &tmps);
|
|
}
|
|
|
|
/* testing already prefixed OIDs */
|
|
for (int test = 0; test < TESTS_NUM; test++)
|
|
{
|
|
const struct oid *prefixed = random_prefixed_oid();
|
|
|
|
/* reset to the default snmp_pdu */
|
|
c = copy; memset(buffer, 0, snmp_oid_size(prefixed) + 8);
|
|
|
|
struct oid *new = snmp_oid_prefixize(snmp_proto, prefixed, &c);
|
|
|
|
bt_assert(new->n_subid == prefixed->n_subid);
|
|
bt_assert(new->prefix == prefixed->prefix);
|
|
bt_assert(!!new->include == !!prefixed->include);
|
|
bt_assert(new->reserved == 0);
|
|
bt_assert(!memcmp(&new->ids[0], &prefixed->ids[0], new->n_subid * sizeof(u32)));
|
|
|
|
lp_restore(tmp_linpool, &tmps);
|
|
}
|
|
|
|
lp_restore(tmp_linpool, &tmps);
|
|
|
|
/* testing non-prefixable OIDs */
|
|
for (int test = 0; test < TESTS_NUM; test++)
|
|
{
|
|
const struct oid *oid = random_no_prefix_oid();
|
|
|
|
/* test that the OID is _really_ not prefixable */
|
|
if (oid->n_subid > ARRAY_SIZE(snmp_internet) &&
|
|
oid->ids[ARRAY_SIZE(snmp_internet) + 1] <= UINT8_MAX)
|
|
{
|
|
for (u32 i = 0; i < ARRAY_SIZE(snmp_internet); i++)
|
|
if (oid->ids[i] != snmp_internet[i]) goto continue_testing;
|
|
|
|
break; /* outer for loop */
|
|
}
|
|
|
|
continue_testing:
|
|
|
|
/* reset to the default snmp_pdu */
|
|
c = copy; memset(buffer, 0, snmp_oid_size(oid) + 8);
|
|
|
|
struct oid *new = snmp_oid_prefixize(snmp_proto, oid, &c);
|
|
|
|
bt_assert(new->n_subid == oid->n_subid);
|
|
bt_assert(new->prefix == oid->prefix);
|
|
bt_assert(!!new->include == !!oid->include);
|
|
bt_assert(new->reserved == 0);
|
|
bt_assert(!memcmp(&new->ids[0], &oid->ids[0], new->n_subid * sizeof(u32)));
|
|
|
|
lp_restore(tmp_linpool, &tmps);
|
|
}
|
|
|
|
for (int test = 0; test < SMALL_TESTS_NUM; test++)
|
|
{
|
|
const struct oid *oid;
|
|
{
|
|
struct oid *work = random_prefixable_oid();
|
|
|
|
/* include also the prefix ID (at index 4) */
|
|
u32 index = xrandom(ARRAY_SIZE(snmp_internet) + 1);
|
|
/* change randomly picked id at index from 0..5 (included) */
|
|
u32 random = bt_random();
|
|
if (index == ARRAY_SIZE(snmp_internet) && random > 255)
|
|
work->ids[index] = random;
|
|
else if (index != ARRAY_SIZE(snmp_internet) && work->ids[index] != random)
|
|
work->ids[index] = random;
|
|
else
|
|
continue;
|
|
oid = work;
|
|
}
|
|
|
|
/* reset to the default snmp_pdu */
|
|
c = copy; memset(buffer, 0, snmp_oid_size(oid) + 8);
|
|
|
|
struct oid *new = snmp_oid_prefixize(snmp_proto, oid, &c);
|
|
|
|
bt_assert(new->n_subid == oid->n_subid);
|
|
bt_assert(new->prefix == oid->prefix);
|
|
bt_assert(!!new->include == !!oid->include);
|
|
bt_assert(new->reserved == 0);
|
|
bt_assert(!memcmp(&new->ids[0], &oid->ids[0], new->n_subid * sizeof(u32)));
|
|
|
|
lp_restore(tmp_linpool, &tmps);
|
|
}
|
|
|
|
tmp_flush();
|
|
return 1;
|
|
}
|
|
|
|
static inline void
|
|
walk_to_oid_one(pool *pool, const struct oid *oid)
|
|
{
|
|
struct mib_tree storage, *tree = &storage;
|
|
mib_tree_init(pool, tree);
|
|
|
|
struct mib_walk_state walk;
|
|
mib_tree_walk_init(&walk, tree);
|
|
|
|
const struct oid *inet_pref = oid_create(1, 0, 0, /* ids */ 1);
|
|
mib_tree_remove(tree, inet_pref);
|
|
|
|
(void) mib_tree_add(pool, tree, oid, xrandom(2));
|
|
mib_tree_find(tree, &walk, oid);
|
|
|
|
char buf[1024];
|
|
struct oid *from_walk = (void *) buf;
|
|
|
|
int r = mib_tree_walk_to_oid(&walk, from_walk,
|
|
(1024 - sizeof(struct oid)) / sizeof(u32));
|
|
|
|
/* the memory limit should not be breached */
|
|
bt_assert(r == 0);
|
|
|
|
bt_assert(snmp_oid_compare(from_walk, oid) == 0);
|
|
|
|
/* cleanup */
|
|
mib_tree_remove(tree, inet_pref);
|
|
}
|
|
|
|
/* test MIB tree walk to OID */
|
|
static int
|
|
t_walk_to_oid(void)
|
|
{
|
|
lp_state tmps;
|
|
lp_save(tmp_linpool, &tmps);
|
|
|
|
|
|
pool *pool = &root_pool;
|
|
|
|
for (int test = 0; test < TESTS_NUM; test++)
|
|
{
|
|
|
|
walk_to_oid_one(pool, random_prefixed_oid());
|
|
walk_to_oid_one(pool, random_no_prefix_oid());
|
|
walk_to_oid_one(pool, random_prefixable_oid());
|
|
/* only a one of above */
|
|
//walk_to_oid_one(random_oid);
|
|
|
|
lp_restore(tmp_linpool, &tmps);
|
|
}
|
|
|
|
tmp_flush();
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
static void
|
|
test_both(void *buffer, uint size, const struct oid *left, const struct oid
|
|
*right, const struct oid *expected)
|
|
{
|
|
memset(buffer, 0, size);
|
|
snmp_oid_common_ancestor(left, right, buffer);
|
|
bt_assert(snmp_oid_compare(buffer, expected) == 0);
|
|
|
|
memset(buffer, 0, size);
|
|
snmp_oid_common_ancestor(right, left, buffer);
|
|
bt_assert(snmp_oid_compare(buffer, expected) == 0);
|
|
}
|
|
|
|
#define TEST_BOTH(l, r, e) test_both(buffer, 1024, l, r, e)
|
|
static int
|
|
t_oid_ancestor(void)
|
|
{
|
|
const struct oid *null = oid_create(0, 0, 0);
|
|
const struct oid *shorter = oid_create(3, 15, 0, /* ids */ 192, 1, 7);
|
|
const struct oid *prefixed = oid_create(4, 15, 0, /* ids */ 192, 1, 7, 82);
|
|
const struct oid *no_prefix = oid_create(9, 0, 0, /* ids */ 1, 3, 6, 1, 15, 192, 1, 7, 82);
|
|
const struct oid *outside = oid_create(7, 0, 0, /* ids */ 4, 3, 2, 1, 8, 0, 2);
|
|
const struct oid *prefix_only = oid_create(0, 15, 0);
|
|
const struct oid *prefix_only2 = oid_create(0, 9, 0);
|
|
const struct oid *partial = oid_create(3, 0, 0, /* ids */ 1, 3, 6);
|
|
const struct oid *no_inet = oid_create(5, 0, 0, /* ids */ 1, 3, 6, 2, 5);
|
|
|
|
const struct oid *inet = oid_create(4, 0, 0, /* ids */ 1, 3, 6, 1);
|
|
|
|
|
|
const struct oid *oids[] = {
|
|
null, shorter, prefixed, no_prefix, outside, prefix_only, partial, no_inet, inet
|
|
};
|
|
|
|
char buffer[1024];
|
|
|
|
/* skip null oid */
|
|
for (size_t o = 1; o < ARRAY_SIZE(oids); o++)
|
|
TEST_BOTH(null, oids[o], null);
|
|
|
|
for (size_t o = 0; o < ARRAY_SIZE(oids); o++)
|
|
TEST_BOTH(oids[o], oids[o], oids[o]);
|
|
|
|
TEST_BOTH(partial, no_prefix, partial);
|
|
TEST_BOTH(partial, prefixed, partial);
|
|
TEST_BOTH(partial, prefix_only, partial);
|
|
TEST_BOTH(partial, prefix_only2, partial);
|
|
|
|
TEST_BOTH(prefix_only2, prefixed, inet);
|
|
TEST_BOTH(prefix_only2, no_prefix, inet);
|
|
|
|
TEST_BOTH(prefix_only2, inet, inet);
|
|
|
|
TEST_BOTH(prefix_only, prefix_only2, inet);
|
|
|
|
TEST_BOTH(prefix_only, prefixed, prefix_only);
|
|
TEST_BOTH(prefix_only, no_prefix, prefix_only);
|
|
|
|
TEST_BOTH(prefix_only, inet, inet);
|
|
|
|
/* skip null oid */
|
|
for (size_t o = 1; o < ARRAY_SIZE(oids); o++)
|
|
{
|
|
if (oids[o] == outside) continue;
|
|
|
|
TEST_BOTH(outside, oids[o], null);
|
|
}
|
|
|
|
TEST_BOTH(no_inet, partial, partial);
|
|
TEST_BOTH(no_inet, inet, partial);
|
|
TEST_BOTH(no_inet, prefix_only, partial);
|
|
TEST_BOTH(no_inet, prefix_only2, partial);
|
|
TEST_BOTH(no_inet, prefixed, partial);
|
|
TEST_BOTH(no_inet, no_prefix, partial);
|
|
|
|
TEST_BOTH(shorter, prefixed, shorter);
|
|
TEST_BOTH(shorter, no_prefix, shorter);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
test_snmp_oid_compare(const void *left, const void *right)
|
|
{
|
|
return snmp_oid_compare(
|
|
*((const struct oid **) left),
|
|
*((const struct oid **) right)
|
|
);
|
|
}
|
|
|
|
static void
|
|
generate_raw_oids(struct oid *oids[], int size, struct oid *(*generator)(void))
|
|
{
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
/* binary version of ~5% */
|
|
if (i > 0 && xrandom(256) <= 13)
|
|
{
|
|
/* at this chance, we create a copy instead of generating new oid */
|
|
oids[i] = tmp_alloc(snmp_oid_size(oids[i-1]));
|
|
memcpy(oids[i], oids[i-1], snmp_oid_size(oids[i-1]));
|
|
}
|
|
else
|
|
oids[i] = generator();
|
|
}
|
|
}
|
|
|
|
static int
|
|
generate_oids(struct oid *oids[], struct oid *sorted[], int size, struct oid *(*generator)(void))
|
|
{
|
|
generate_raw_oids(oids, size, generator);
|
|
|
|
memcpy(sorted, oids, size * sizeof(struct oid *));
|
|
|
|
qsort(sorted, (size_t) size, sizeof(struct oid *),
|
|
test_snmp_oid_compare);
|
|
|
|
// test sizes 0, 1, 2, 10, ...
|
|
int last_used = 0;
|
|
for (int index = 0; index < size; index++)
|
|
{
|
|
if (snmp_oid_compare(sorted[last_used], sorted[index]) != 0)
|
|
sorted[++last_used] = sorted[index];
|
|
}
|
|
|
|
/* delete old pointers */
|
|
for (int i = last_used + 1; i < size; i++)
|
|
sorted[i] = NULL;
|
|
|
|
return (size > 1) ? last_used + 1 : size;
|
|
}
|
|
|
|
static int
|
|
t_walk_oid_desc(void)
|
|
{
|
|
lp_state tmps;
|
|
lp_save(tmp_linpool, &tmps);
|
|
|
|
pool *pool = &root_pool;
|
|
|
|
struct mib_tree storage, *tree = &storage;
|
|
mib_tree_init(pool, tree);
|
|
|
|
STATIC_ASSERT(ARRAY_SIZE(tree_sizes) > 0);
|
|
int size = tree_sizes[ARRAY_SIZE(tree_sizes) - 1];
|
|
ASSERT(size > 0);
|
|
struct oid **oids = mb_alloc(pool, size * sizeof(struct oid *));
|
|
struct oid **sorted = mb_alloc(pool, size * sizeof(struct oid *));
|
|
|
|
(void) generate_oids(oids, sorted, size, random_oid);
|
|
|
|
for (int i = 0; i < size; i++)
|
|
(void) mib_tree_add(pool, tree, oids[i], 0);
|
|
|
|
for (int test = 0; test < size; test++)
|
|
{
|
|
int i = xrandom(size);
|
|
|
|
char buffer[1024];
|
|
struct oid *oid = (void *) buffer;
|
|
|
|
memcpy(buffer, oids[i], snmp_oid_size(oids[i]));
|
|
|
|
struct mib_walk_state walk;
|
|
mib_tree_walk_init(&walk, NULL);
|
|
(void) mib_tree_find(tree, &walk, oid);
|
|
|
|
int type = xrandom(4);
|
|
switch (type)
|
|
{
|
|
case 0:
|
|
bt_assert(mib_tree_walk_is_oid_descendant(&walk, oids[i]) == 0);
|
|
break;
|
|
|
|
case 1:
|
|
{
|
|
/* oid is longer than walk or has same length */
|
|
u8 ids = LOAD_U8(oid->n_subid);
|
|
u32 upto = MIN(OID_MAX_LEN - ids, 16);
|
|
|
|
if (!upto)
|
|
continue;
|
|
|
|
u32 new = xrandom(upto) + 1;
|
|
STORE_U8(oid->n_subid, ids + new);
|
|
ASSERT(snmp_oid_size(oid) < 1024);
|
|
|
|
for (u32 i = 0; i < new; i++)
|
|
STORE_U32(oid->ids[ids + i], xrandom(OID_MAX_ID));
|
|
|
|
bt_assert(mib_tree_walk_is_oid_descendant(&walk, oid) > 0);
|
|
|
|
break;
|
|
}
|
|
case 2:
|
|
case 3:
|
|
{
|
|
/* oid is shorter than walk */
|
|
u8 ids = LOAD_U8(oid->n_subid);
|
|
|
|
if (ids == 0 || ids == OID_MAX_LEN)
|
|
continue;
|
|
|
|
u32 split = (ids > 1) ? xrandom(ids - 1) + 1 : 0;
|
|
u32 ext = (type == 3) ? xrandom(MIN(OID_MAX_LEN - ids, 16)) : 0;
|
|
|
|
STORE_U16(oid->n_subid, split + ext);
|
|
for (u32 i = 0; i < ext; i++)
|
|
STORE_U32(oid->ids[split + i], xrandom(OID_MAX_ID));
|
|
|
|
int no_change = 1;
|
|
for (u32 j = 0; j < MIN(ids, split + ext); j++)
|
|
{
|
|
if (LOAD_U32(oid->ids[split + j]) != LOAD_U32(oids[i]->ids[split + j]))
|
|
no_change = 1;
|
|
}
|
|
|
|
if (no_change)
|
|
continue;
|
|
|
|
bt_assert(mib_tree_walk_is_oid_descendant(&walk, oid) < 0);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
struct mib_walk_state walk;
|
|
mib_tree_walk_init(&walk, tree);
|
|
|
|
u32 zero = 0;
|
|
const struct oid *null_oid = (void *) &zero;
|
|
u32 index = xrandom(size);
|
|
|
|
bt_assert(mib_tree_walk_is_oid_descendant(&walk, null_oid) == 0);
|
|
bt_assert(mib_tree_walk_is_oid_descendant(&walk, oids[index]) > 0);
|
|
(void) mib_tree_find(tree, &walk, oids[index]);
|
|
bt_assert(mib_tree_walk_is_oid_descendant(&walk, null_oid) < 0);
|
|
}
|
|
|
|
u32 null_oid = 0;
|
|
mib_tree_remove(tree, (struct oid *) &null_oid);
|
|
lp_restore(tmp_linpool, &tmps);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void UNUSED
|
|
print_dups(const struct oid *oids[], uint size)
|
|
{
|
|
for (uint i = 0; i < size; i++)
|
|
for (uint j = i + 1; j < size; j++)
|
|
if (snmp_oid_compare(oids[i], oids[j]) == 0)
|
|
log(L_WARN "pair (%u, %u)", i, j);
|
|
}
|
|
|
|
static void UNUSED
|
|
print_all(const struct oid *oids[], uint size)
|
|
{
|
|
for (uint i = 0; i < size; i++)
|
|
snmp_oid_log(oids[i]);
|
|
}
|
|
|
|
static inline int
|
|
oid_is_leaf(const struct oid *oid, const struct oid *leafs[], uint leaf_idx)
|
|
{
|
|
for (uint l = 0; l < leaf_idx; l++)
|
|
if (snmp_oid_compare(oid, leafs[l]) == 0)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
all_invalid(const struct oid *oids[], const byte *invalid, uint size, uint index)
|
|
{
|
|
if (!invalid[index])
|
|
return 0;
|
|
|
|
for (uint i = 0; i < size; i++)
|
|
{
|
|
if (i == index) continue;
|
|
|
|
if (snmp_oid_compare(oids[i], oids[index]) == 0 &&
|
|
!invalid[i])
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
count_error(const struct oid *oids[], const byte *invalid, uint size)
|
|
{
|
|
int error = 0;
|
|
for (uint i = 0; i < size; i++)
|
|
{
|
|
if (!invalid[i]) continue;
|
|
|
|
int skip = 0;
|
|
for (uint j = 0; j < i; j++)
|
|
{
|
|
if (snmp_oid_compare(oids[i], oids[j]) == 0)
|
|
{
|
|
skip = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (skip) continue;
|
|
|
|
if (all_invalid(oids, invalid, size, i))
|
|
error++;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
static int
|
|
gen_test_add(struct oid *(*generator)(void))
|
|
{
|
|
lp_state tmps;
|
|
lp_save(tmp_linpool, &tmps);
|
|
|
|
pool *pool = &root_pool;
|
|
|
|
for (int test = 0; test < TESTS_NUM; test++)
|
|
{
|
|
size_t tsz = ARRAY_SIZE(tree_sizes);
|
|
|
|
int size = tree_sizes[test % tsz];
|
|
int with_leafs = (test % (2 * tsz)) < tsz;
|
|
int no_inet_prefix = (test % (4 * tsz)) < (2 * tsz);
|
|
|
|
struct oid **oids = mb_alloc(pool, size * sizeof(struct oid *));
|
|
byte *types = mb_alloc(pool, size * sizeof(byte));
|
|
byte *invalid_hist = mb_alloc(pool, size * sizeof(byte));
|
|
struct oid **sorted = mb_alloc(pool, size * sizeof(struct oid *));
|
|
struct oid **leafs = (with_leafs) ? mb_alloc(pool, size * sizeof(struct oid *))
|
|
: NULL;
|
|
int leaf_idx = 0;
|
|
int empty_prefix_added = 0;
|
|
int distinct = generate_oids(oids, sorted, size, generator);
|
|
|
|
struct mib_tree storage, *tree = &storage;
|
|
mib_tree_init(pool, tree);
|
|
|
|
if (no_inet_prefix)
|
|
{
|
|
/* remove the node .1 and all children */
|
|
const struct oid *inet_pref = oid_create(1, 0, 0, /* ids */ 1);
|
|
mib_tree_remove(tree, inet_pref);
|
|
}
|
|
|
|
int invalid_counter = 0;
|
|
int counter = 0;
|
|
int cut = 0;
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
int invalid = 0;
|
|
int is_leaf = (with_leafs) ? (int) xrandom(2) : 0;
|
|
types[i] = (byte) is_leaf;
|
|
|
|
int will_cut = 0;
|
|
int oid_nulled = snmp_is_oid_empty(oids[i]);
|
|
|
|
if (oid_nulled && is_leaf)
|
|
invalid = 1;
|
|
|
|
if (!no_inet_prefix)
|
|
{
|
|
char buffer[1024];
|
|
struct oid *o = (void *) buffer;
|
|
|
|
struct oid *inet = oid_create(4, 0, 0, /* ids */ 1, 3, 6, 1);
|
|
snmp_oid_common_ancestor(oids[i], inet, o);
|
|
|
|
/* If the standard internet prefix is present,
|
|
* then the prefix leafs are invalid. */
|
|
if (snmp_oid_compare(oids[i], o) == 0)
|
|
invalid = is_leaf;
|
|
}
|
|
|
|
/* check existence of ancestor node of a new leaf */
|
|
for (int oi = 0; !invalid && !oid_nulled && oi < i; oi++)
|
|
{
|
|
char buffer[1024];
|
|
struct oid *o = (void *) buffer;
|
|
|
|
if (invalid_hist[oi])
|
|
continue;
|
|
|
|
int other_is_leaf = (int) types[oi];
|
|
|
|
if (snmp_oid_compare(oids[oi], oids[i]) == 0 &&
|
|
!snmp_is_oid_empty(oids[i]))
|
|
{
|
|
if (other_is_leaf == is_leaf)
|
|
will_cut = 1;
|
|
else if (other_is_leaf != is_leaf)
|
|
invalid = 1;
|
|
|
|
break;
|
|
}
|
|
|
|
snmp_oid_common_ancestor(oids[oi], oids[i], o);
|
|
|
|
if ((snmp_oid_compare(oids[i], o) == 0 && is_leaf) ||
|
|
(snmp_oid_compare(oids[oi], o) == 0 && other_is_leaf))
|
|
{
|
|
invalid = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!invalid && will_cut)
|
|
cut++;
|
|
|
|
if (is_leaf && !invalid)
|
|
/* leafs could have duplicates */
|
|
leafs[leaf_idx++] = oids[i];
|
|
|
|
mib_node_u *node = mib_tree_add(pool, tree, oids[i], is_leaf);
|
|
|
|
bt_assert((node == NULL) == invalid);
|
|
|
|
invalid_hist[i] = 0;
|
|
if (invalid)
|
|
{
|
|
invalid_hist[i] = 1;
|
|
invalid_counter++;
|
|
}
|
|
|
|
if (node != NULL && (!snmp_is_oid_empty(oids[i]) || !empty_prefix_added))
|
|
counter++;
|
|
|
|
if (snmp_is_oid_empty(oids[i]) && !is_leaf)
|
|
empty_prefix_added = 1;
|
|
}
|
|
|
|
int error = count_error((const struct oid **) oids, invalid_hist, size);
|
|
bt_assert(counter - cut == distinct - error);
|
|
|
|
lp_restore(tmp_linpool, &tmps);
|
|
mb_free(oids);
|
|
mb_free(sorted);
|
|
mb_free(leafs);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
t_tree_add(void)
|
|
{
|
|
|
|
gen_test_add(random_prefixed_oid);
|
|
gen_test_add(random_no_prefix_oid);
|
|
gen_test_add(random_prefixable_oid);
|
|
gen_test_add(random_oid);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
gen_test_find(struct oid *(*generator)(void))
|
|
{
|
|
lp_state tmps;
|
|
lp_save(tmp_linpool, &tmps);
|
|
|
|
pool *pool = &root_pool;
|
|
|
|
for (int test = 0; test < TESTS_NUM; test++)
|
|
{
|
|
size_t tsz = ARRAY_SIZE(tree_sizes);
|
|
|
|
int size = tree_sizes[test % tsz];
|
|
int with_leafs = (test % (2 * tsz)) < tsz;
|
|
int no_inet_prefix = (test % (4 * tsz)) < (2 * tsz);
|
|
|
|
struct oid **oids = mb_alloc(pool, size * sizeof(struct oid *));
|
|
mib_node_u **nodes = mb_alloc(pool, size * sizeof(mib_node_u *));
|
|
struct oid **searched = mb_alloc(pool, size * sizeof(struct oid *));
|
|
byte *types = mb_alloc(pool, size * sizeof(byte));
|
|
|
|
/* enough to hold snmp_internet copy */
|
|
uint longest_inet_pref_len = 0;
|
|
struct oid *longest_inet_pref = oid_create(4, 0, 0, /* ids */ 0, 0, 0, 0);
|
|
|
|
generate_raw_oids(oids, size, generator);
|
|
generate_raw_oids(searched, size, generator);
|
|
|
|
struct mib_tree storage, *tree = &storage;
|
|
mib_tree_init(pool, tree);
|
|
|
|
if (no_inet_prefix)
|
|
{
|
|
/* remove the node .1 and all children */
|
|
const struct oid *inet_pref = oid_create(1, 0, 0, /* ids */ 1);
|
|
mib_tree_remove(tree, inet_pref);
|
|
}
|
|
|
|
for (int i = 0; i < size; i++)
|
|
types[i] = (byte) ((with_leafs) ? xrandom(2) : 0);
|
|
|
|
/*
|
|
* by default initialized MIB tree will have internet prefix have inserted
|
|
*/
|
|
if (!no_inet_prefix)
|
|
{
|
|
memcpy(longest_inet_pref->ids, snmp_internet, sizeof(snmp_internet));
|
|
longest_inet_pref_len = 4;
|
|
}
|
|
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
nodes[i] = mib_tree_add(pool, tree, oids[i], types[i]);
|
|
|
|
if (nodes[i] == NULL) continue;
|
|
|
|
if (snmp_oid_is_prefixed(oids[i]))
|
|
{
|
|
memcpy(longest_inet_pref->ids, snmp_internet, sizeof(snmp_internet));
|
|
longest_inet_pref_len = 4;
|
|
}
|
|
else
|
|
{
|
|
for (uint j = 0; j < MIN(LOAD_U8(oids[i]->n_subid),
|
|
ARRAY_SIZE(snmp_internet)); j++)
|
|
{
|
|
if (LOAD_U32(oids[i]->ids[j]) == snmp_internet[j] &&
|
|
j >= longest_inet_pref_len)
|
|
{
|
|
longest_inet_pref->ids[j] = snmp_internet[j];
|
|
longest_inet_pref_len = j + 1;
|
|
}
|
|
else if (LOAD_U32(oids[i]->ids[j]) == snmp_internet[j])
|
|
;
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
for (int j = 0; j < size; j++)
|
|
{
|
|
if (nodes[i] != NULL &&
|
|
nodes[j] != NULL &&
|
|
snmp_oid_compare(oids[i], oids[j]) == 0)
|
|
bt_assert(nodes[i] == nodes[j]);
|
|
}
|
|
}
|
|
|
|
mib_node_u *last = NULL;
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
/*
|
|
* This solves cases where we tried to insert
|
|
* both leaf and inner node for same OID.
|
|
* Result of insertion should be NULL in cases
|
|
* when the insertion is inconsistent with the current tree state.
|
|
* (the first insertion wins)
|
|
*/
|
|
int expected_precise = 1;
|
|
mib_node_u *expected = nodes[i];
|
|
|
|
if (!no_inet_prefix)
|
|
{
|
|
char buf[1024];
|
|
struct oid *o = (void *) buf;
|
|
snmp_oid_common_ancestor(oids[i], longest_inet_pref, o);
|
|
if (snmp_oid_compare(oids[i], o) == 0)
|
|
expected_precise = 0;
|
|
}
|
|
|
|
if (snmp_is_oid_empty(oids[i]))
|
|
{
|
|
expected_precise = 0;
|
|
}
|
|
|
|
for (int j = 0; expected_precise && j < size; j++)
|
|
{
|
|
if (i == j) continue;
|
|
|
|
if (snmp_oid_compare(oids[i], oids[j]) == 0 &&
|
|
types[i] != types[j] && nodes[i] == NULL)
|
|
{
|
|
if (nodes[j] != NULL)
|
|
{
|
|
expected = nodes[j];
|
|
break;
|
|
}
|
|
|
|
/* else expected = NULL; */
|
|
}
|
|
|
|
char buf[1024];
|
|
struct oid *o = (void *) buf;
|
|
|
|
snmp_oid_common_ancestor(oids[i], oids[j], o);
|
|
|
|
/* oids[j] lies on path from root to oids[i] */
|
|
if (snmp_oid_compare(oids[i], o) == 0 &&
|
|
nodes[j] != NULL &&
|
|
expected == NULL)
|
|
{
|
|
expected_precise = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
struct mib_walk_state walk;
|
|
//mib_tree_walk_init(&walk, tree, 0);
|
|
mib_tree_walk_init(&walk, NULL);
|
|
mib_node_u *found = mib_tree_find(tree, &walk, oids[i]);
|
|
|
|
bt_assert(walk.stack_pos <= MIB_WALK_STACK_SIZE + 1);
|
|
bt_assert(walk.id_pos <= OID_MAX_LEN);
|
|
|
|
if (expected_precise)
|
|
bt_assert(found == expected);
|
|
else
|
|
/* found is an auto-inserted node on path to some dest OID */
|
|
bt_assert(found != NULL);
|
|
|
|
last = found;
|
|
|
|
/* test finding with walk state not pointing at the root of the tree */
|
|
u8 subids = LOAD_U8(oids[i]->n_subid);
|
|
if (subids > 0)
|
|
{
|
|
found = NULL;
|
|
u32 new_ids = xrandom(subids);
|
|
mib_tree_walk_init(&walk, (xrandom(2)) ? tree : NULL);
|
|
|
|
STORE_U8(oids[i]->n_subid, new_ids);
|
|
|
|
mib_node_u *ignored UNUSED;
|
|
ignored = mib_tree_find(tree, &walk, oids[i]);
|
|
|
|
STORE_U8(oids[i]->n_subid, subids);
|
|
|
|
found = mib_tree_find(tree, &walk, oids[i]);
|
|
|
|
/* see above */
|
|
if (expected_precise)
|
|
bt_assert(found == expected);
|
|
else
|
|
{
|
|
/* test that the result is same as direct searched from tree root */
|
|
bt_assert(found == last);
|
|
bt_assert(found != NULL);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int search = 0; search < size; search++)
|
|
{
|
|
int has_node = 0;
|
|
for (int stored = 0; stored < size; stored++)
|
|
{
|
|
char buf[1024];
|
|
struct oid *o = (void *) buf;
|
|
snmp_oid_common_ancestor(oids[stored], searched[search], o);
|
|
|
|
/* test if OID oids[stored] is valid and if it forms a path from root
|
|
* with OID searched[search] */
|
|
if (nodes[stored] != NULL && snmp_oid_compare(searched[search], o) == 0)
|
|
{
|
|
has_node = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
const struct oid *oid = searched[search];
|
|
if (!has_node && !snmp_oid_is_prefixed(oid))
|
|
{
|
|
for (uint i = 0; i < MIN(ARRAY_SIZE(snmp_internet),
|
|
LOAD_U8(oid->n_subid)); i++)
|
|
{
|
|
if (longest_inet_pref->ids[i] != 0 &&
|
|
longest_inet_pref->ids[i] == oid->ids[i])
|
|
has_node = 1;
|
|
else
|
|
{
|
|
has_node = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (has_node && LOAD_U8(oid->n_subid) > ARRAY_SIZE(snmp_internet))
|
|
has_node = 0;
|
|
}
|
|
|
|
struct mib_walk_state walk;
|
|
mib_tree_walk_init(&walk, NULL);
|
|
//mib_tree_walk_init(&walk, tree); /* TODO should work also like this */
|
|
mib_node_u *found = mib_tree_find(tree, &walk, searched[search]);
|
|
bt_assert(has_node == (found != NULL));
|
|
|
|
bt_assert(walk.stack_pos <= MIB_WALK_STACK_SIZE + 1);
|
|
bt_assert(walk.id_pos <= OID_MAX_LEN);
|
|
|
|
last = found;
|
|
|
|
u8 subids = LOAD_U8(searched[search]->n_subid);
|
|
if (subids > 0)
|
|
{
|
|
found = NULL;
|
|
u32 new_ids = xrandom(subids);
|
|
mib_tree_walk_init(&walk, (xrandom(2)) ? tree : NULL);
|
|
|
|
STORE_U8(searched[search]->n_subid, new_ids);
|
|
|
|
mib_node_u *ignored UNUSED;
|
|
ignored = mib_tree_find(tree, &walk, searched[search]);
|
|
|
|
STORE_U8(searched[search]->n_subid, subids);
|
|
|
|
found = mib_tree_find(tree, &walk, searched[search]);
|
|
|
|
bt_assert(has_node == (found != NULL));
|
|
|
|
bt_assert(walk.stack_pos <= MIB_WALK_STACK_SIZE + 1);
|
|
bt_assert(walk.id_pos <= OID_MAX_LEN);
|
|
|
|
/* test that the result is same as direct search from tree root */
|
|
bt_assert(last == found);
|
|
}
|
|
}
|
|
|
|
lp_restore(tmp_linpool, &tmps);
|
|
mb_free(oids);
|
|
mb_free(nodes);
|
|
mb_free(searched);
|
|
mb_free(types);
|
|
}
|
|
|
|
tmp_flush();
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
t_tree_find(void)
|
|
{
|
|
|
|
gen_test_find(random_prefixed_oid);
|
|
gen_test_find(random_no_prefix_oid);
|
|
gen_test_find(random_prefixable_oid);
|
|
gen_test_find(random_oid);
|
|
|
|
return 1;
|
|
}
|
|
|
|
#if 0
|
|
static int
|
|
delete_cleanup(const struct oid *oid, struct oid *oids[], mib_node_u *valid[], int size)
|
|
{
|
|
uint counter = 0;
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
char buf[1024];
|
|
struct oid *o = (void *) buf;
|
|
|
|
if (oid == oids[i])
|
|
{
|
|
counter++;
|
|
continue;
|
|
}
|
|
|
|
snmp_oid_common_ancestor(oid, oids[i], o);
|
|
|
|
if (snmp_oid_compare(oid, o) == 0)
|
|
{
|
|
valid[i] = NULL;
|
|
counter++;
|
|
}
|
|
}
|
|
|
|
return counter;
|
|
}
|
|
#endif
|
|
|
|
static int
|
|
gen_test_delete_remove(struct oid *(*generator)(void), int remove)
|
|
{
|
|
lp_state tmps;
|
|
lp_save(tmp_linpool, &tmps);
|
|
|
|
pool *pool = &root_pool;
|
|
|
|
for (int test = 0; test < TESTS_NUM; test++)
|
|
{
|
|
size_t tsz = ARRAY_SIZE(tree_sizes);
|
|
|
|
int size = tree_sizes[test % tsz];
|
|
int with_leafs = (test % (2 * tsz)) < tsz;
|
|
int no_inet_prefix = (test % (4 * tsz)) < (2 * tsz);
|
|
|
|
struct oid **oids = mb_alloc(pool, size * sizeof(struct oid *));
|
|
struct oid **sorted = mb_alloc(pool, size * sizeof(struct oid *));
|
|
mib_node_u **nodes = mb_alloc(pool, size * sizeof(mib_node_u *));
|
|
byte *types = mb_alloc(pool, size * sizeof(byte));
|
|
|
|
struct mib_tree storage, *tree = &storage;
|
|
mib_tree_init(pool, tree);
|
|
|
|
if (no_inet_prefix)
|
|
{
|
|
/* remove the node .1 and all children */
|
|
const struct oid *inet_pref = oid_create(1, 0, 0, /* ids */ 1);
|
|
mib_tree_remove(tree, inet_pref);
|
|
}
|
|
|
|
int distinct = generate_oids(oids, sorted, size, generator);
|
|
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
int is_leaf;
|
|
is_leaf = types[i] = (byte) (with_leafs) ? xrandom(2) : 0;
|
|
(void) mib_tree_add(pool, tree, oids[i], is_leaf);
|
|
}
|
|
|
|
for (int d = 0; d < distinct; d++)
|
|
{
|
|
struct mib_walk_state walk;
|
|
mib_tree_walk_init(&walk, NULL);
|
|
//mib_tree_walk_init(&walk, tree); TODO
|
|
nodes[d] = mib_tree_find(tree, &walk, sorted[d]);
|
|
}
|
|
|
|
/* we need to populate the nodes array after all insertions because
|
|
* some insertion may fail (== NULL) because we try to insert a leaf */
|
|
#if 0
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
struct mib_walk_state walk;
|
|
mib_tree_walk_init(&walk, tree, 0);
|
|
nodes[i] = mib_tree_find(tree, &walk, oids[i]);
|
|
}
|
|
#endif
|
|
|
|
int deleted, invalid_counter;
|
|
/* test deletion one of the inserted OIDs */
|
|
for (int round = 0; round < (size + 3) / 4 + remove; round++)
|
|
{
|
|
/* note: we do not run any rounds for size zero because xrandom(0)
|
|
* does not exist */
|
|
int i;
|
|
struct oid *oid;
|
|
if (!remove)
|
|
{
|
|
/* this way we are also testing remove non-existent tree nodes */
|
|
i = xrandom(size); /* not xrandom(distinct) */
|
|
oid = oids[i];
|
|
}
|
|
else
|
|
{
|
|
i = -1; /* break fast */
|
|
oid = generator();
|
|
}
|
|
|
|
struct mib_walk_state walk;
|
|
mib_tree_walk_init(&walk, NULL);
|
|
// mib_tree_walk_init(&walk, tree); TODO
|
|
mib_node_u *node = mib_tree_find(tree, &walk, oid);
|
|
|
|
if (node == NULL)
|
|
continue;
|
|
|
|
if (!remove)
|
|
deleted = mib_tree_delete(tree, &walk);
|
|
else
|
|
deleted = mib_tree_remove(tree, oid);
|
|
|
|
bt_assert(deleted > 0 || snmp_is_oid_empty(oid));
|
|
|
|
invalid_counter = 0;
|
|
int counted_removed = 0;
|
|
for (int j = 0; j < distinct; j++)
|
|
{
|
|
//mib_tree_walk_init(&walk, tree, 0);
|
|
mib_tree_walk_init(&walk, NULL);
|
|
mib_node_u *node = mib_tree_find(tree, &walk, sorted[j]);
|
|
|
|
if (snmp_is_oid_empty(oid))
|
|
;
|
|
/* the oid could have multiple instances in the oids dataset */
|
|
else if (snmp_oid_compare(oid, sorted[j]) == 0 && !counted_removed)
|
|
{
|
|
invalid_counter++;
|
|
counted_removed = 1;
|
|
bt_assert(node == NULL);
|
|
nodes[j] = NULL;
|
|
}
|
|
else if (node != nodes[j])
|
|
{
|
|
invalid_counter++;
|
|
bt_assert(node == NULL);
|
|
nodes[j] = NULL;
|
|
}
|
|
}
|
|
|
|
/* we do not count the internal node that are included in the deleted */
|
|
bt_assert(deleted >= invalid_counter);
|
|
}
|
|
|
|
lp_restore(tmp_linpool, &tmps);
|
|
mb_free(oids);
|
|
mb_free(sorted);
|
|
mb_free(nodes);
|
|
}
|
|
|
|
tmp_flush();
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
t_tree_delete(void)
|
|
{
|
|
|
|
gen_test_delete_remove(random_prefixed_oid, 0);
|
|
gen_test_delete_remove(random_no_prefix_oid, 0);
|
|
gen_test_delete_remove(random_prefixable_oid, 0);
|
|
gen_test_delete_remove(random_oid, 0);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
t_tree_remove(void)
|
|
{
|
|
|
|
gen_test_delete_remove(random_prefixed_oid, 1);
|
|
gen_test_delete_remove(random_no_prefix_oid, 1);
|
|
gen_test_delete_remove(random_prefixable_oid, 1);
|
|
gen_test_delete_remove(random_oid, 1);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void
|
|
gen_test_traverse(struct oid *(*generator)(void))
|
|
{
|
|
lp_state tmps;
|
|
lp_save(tmp_linpool, &tmps);
|
|
|
|
pool *pool = &root_pool;
|
|
|
|
for (int test = 0; test < TESTS_NUM; test++)
|
|
{
|
|
size_t tsz = ARRAY_SIZE(tree_sizes);
|
|
|
|
int size = tree_sizes[test % tsz];
|
|
int with_leafs = (test % (2 * tsz)) < tsz;
|
|
int no_inet_prefix = (test % (4 * tsz)) < (2 * tsz);
|
|
|
|
struct oid **oids = mb_alloc(pool, size * sizeof(struct oid *));
|
|
struct oid **sorted = mb_alloc(pool, size * sizeof(struct oid *));
|
|
mib_node_u **nodes = mb_allocz(pool, size * sizeof(mib_node_u *));
|
|
|
|
const int distinct = generate_oids(oids, sorted, size, generator);
|
|
|
|
struct mib_tree storage, *tree = &storage;
|
|
mib_tree_init(pool, tree);
|
|
|
|
if (no_inet_prefix)
|
|
{
|
|
/* remove the node .1 and all children */
|
|
const struct oid *inet_pref = oid_create(1, 0, 0, /* ids */ 1);
|
|
mib_tree_remove(tree, inet_pref);
|
|
}
|
|
|
|
for (int o = 0; o < size; o++)
|
|
{
|
|
int is_leaf = (with_leafs) ? (int) xrandom(2) : 0;
|
|
(void) mib_tree_add(pool, tree, oids[o], is_leaf);
|
|
}
|
|
|
|
for (int d = 0; d < distinct; d++)
|
|
{
|
|
struct mib_walk_state walk;
|
|
mib_tree_walk_init(&walk, NULL);
|
|
nodes[d] = mib_tree_find(tree, &walk, sorted[d]);
|
|
}
|
|
|
|
int bound = 0;
|
|
|
|
for (int d = 0; d < distinct; d++)
|
|
{
|
|
if (snmp_oid_is_prefixed(sorted[d]))
|
|
bound += 5;
|
|
bound += (int)LOAD_U8(sorted[d]->n_subid);
|
|
}
|
|
|
|
if (!no_inet_prefix)
|
|
bound += (ARRAY_SIZE(snmp_internet) + 1);
|
|
|
|
struct mib_walk_state walk;
|
|
mib_tree_walk_init(&walk, tree);
|
|
|
|
char buf[1024], buf2[1024];
|
|
struct oid *oid = (void *) buf;
|
|
struct oid *last = (void *) buf2;
|
|
memset(oid, 0, sizeof(struct oid)); /* create a null OID */
|
|
memset(last, 0, sizeof(struct oid));
|
|
|
|
int oid_index = 0;
|
|
if (size > 0 && snmp_is_oid_empty(sorted[oid_index]))
|
|
oid_index++;
|
|
|
|
mib_node_u *current;
|
|
int i = 0;
|
|
while ((current = mib_tree_walk_next(tree, &walk)) != NULL && i++ < bound)
|
|
{
|
|
memcpy(last, oid, snmp_oid_size(oid));
|
|
mib_tree_walk_to_oid(&walk, oid,
|
|
(1024 - sizeof(struct oid) / sizeof(u32)));
|
|
|
|
bt_assert(snmp_oid_compare(last, oid) < 0);
|
|
|
|
while (oid_index < distinct && nodes[oid_index] == NULL)
|
|
oid_index++;
|
|
|
|
if (oid_index < distinct && snmp_oid_compare(sorted[oid_index], oid) == 0)
|
|
oid_index++;
|
|
}
|
|
|
|
bt_assert(current == NULL);
|
|
while (oid_index < distinct && nodes[oid_index] == NULL)
|
|
oid_index++;
|
|
|
|
/* the bound check is only for that the loop is finite */
|
|
bt_assert(i <= bound + 2);
|
|
|
|
current = mib_tree_walk_next(tree, &walk);
|
|
bt_assert(current == NULL);
|
|
bt_assert(oid_index == distinct);
|
|
|
|
mb_free(oids);
|
|
mb_free(sorted);
|
|
mb_free(nodes);
|
|
|
|
lp_restore(tmp_linpool, &tmps);
|
|
}
|
|
|
|
tmp_flush();
|
|
}
|
|
|
|
static int
|
|
t_tree_traversal(void)
|
|
{
|
|
gen_test_traverse(random_prefixed_oid);
|
|
gen_test_traverse(random_no_prefix_oid);
|
|
gen_test_traverse(random_prefixable_oid);
|
|
gen_test_traverse(random_oid);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void
|
|
gen_test_leafs(struct oid *(*generator)(void))
|
|
{
|
|
lp_state tmps;
|
|
lp_save(tmp_linpool, &tmps);
|
|
|
|
pool *pool = &root_pool;
|
|
|
|
for (int test = 0; test < TESTS_NUM; test++)
|
|
{
|
|
size_t tsz = ARRAY_SIZE(tree_sizes);
|
|
|
|
int size = tree_sizes[test % tsz];
|
|
int with_leafs = (test % (2 * tsz)) < tsz;
|
|
int no_inet_prefix = (test % (4 * tsz)) < (2 * tsz);
|
|
|
|
struct oid **oids = mb_alloc(pool, size * sizeof(struct oid *));
|
|
struct oid **sorted = mb_alloc(pool, size * sizeof(struct oid *));
|
|
mib_node_u **nodes = mb_allocz(pool, size * sizeof(mib_node_u *));
|
|
|
|
const int distinct = generate_oids(oids, sorted, size, generator);
|
|
|
|
struct mib_tree storage, *tree = &storage;
|
|
mib_tree_init(pool, tree);
|
|
|
|
if (no_inet_prefix)
|
|
{
|
|
/* remove the node .1 and all children */
|
|
const struct oid *inet_pref = oid_create(1, 0, 0, /* ids */ 1);
|
|
mib_tree_remove(tree, inet_pref);
|
|
}
|
|
|
|
for (int o = 0; o < size; o++)
|
|
{
|
|
int is_leaf = (with_leafs) ? (int) xrandom(2) : 0;
|
|
(void) mib_tree_add(pool, tree, oids[o], is_leaf);
|
|
}
|
|
|
|
int leafs = 0;
|
|
for (int d = 0; d < distinct; d++)
|
|
{
|
|
struct mib_walk_state walk;
|
|
mib_tree_walk_init(&walk, NULL);
|
|
nodes[d] = mib_tree_find(tree, &walk, sorted[d]);
|
|
|
|
/* count only leafs that was successfully inserted without duplicits */
|
|
if (nodes[d] != NULL && mib_node_is_leaf(nodes[d]))
|
|
leafs++;
|
|
}
|
|
|
|
struct mib_walk_state walk;
|
|
mib_tree_walk_init(&walk, tree);
|
|
if (!with_leafs)
|
|
{
|
|
struct mib_leaf *leaf = mib_tree_walk_next_leaf(tree, &walk);
|
|
bt_assert(leaf == NULL);
|
|
|
|
continue;
|
|
}
|
|
|
|
char buf[1024], buf2[1024];
|
|
struct oid *oid = (void *) buf;
|
|
struct oid *last = (void *) buf2;
|
|
memset(oid, 0, sizeof(struct oid)); /* create a null OID */
|
|
memset(last, 0, sizeof(struct oid));
|
|
|
|
int oid_index = 0;
|
|
|
|
struct mib_leaf *current;
|
|
int i = 0; /* iteration counter ~ leafs found */
|
|
while ((current = mib_tree_walk_next_leaf(tree, &walk)) != NULL && i++ < leafs)
|
|
{
|
|
memcpy(last, oid, snmp_oid_size(oid));
|
|
mib_tree_walk_to_oid(&walk, oid,
|
|
(1024 - sizeof(struct oid) / sizeof(u32)));
|
|
|
|
bt_assert(snmp_oid_compare(last, oid) < 0);
|
|
bt_assert(mib_node_is_leaf(((mib_node_u *)current)));
|
|
|
|
while (oid_index < distinct &&
|
|
(nodes[oid_index] == NULL || !mib_node_is_leaf(nodes[oid_index])))
|
|
oid_index++;
|
|
|
|
if (oid_index < distinct && snmp_oid_compare(sorted[oid_index], oid) == 0)
|
|
oid_index++;
|
|
}
|
|
|
|
bt_assert(current == NULL);
|
|
while (oid_index < distinct &&
|
|
(nodes[oid_index] == NULL || !mib_node_is_leaf(nodes[oid_index])))
|
|
oid_index++;
|
|
|
|
current = mib_tree_walk_next_leaf(tree, &walk);
|
|
bt_assert(current == NULL);
|
|
bt_assert(oid_index == distinct);
|
|
bt_assert(i == leafs);
|
|
|
|
mb_free(oids);
|
|
mb_free(sorted);
|
|
mb_free(nodes);
|
|
|
|
lp_restore(tmp_linpool, &tmps);
|
|
}
|
|
|
|
tmp_flush();
|
|
}
|
|
|
|
static int
|
|
t_tree_leafs(void)
|
|
{
|
|
|
|
gen_test_leafs(random_prefixed_oid);
|
|
gen_test_leafs(random_no_prefix_oid);
|
|
gen_test_leafs(random_prefixable_oid);
|
|
gen_test_leafs(random_oid);
|
|
|
|
return 1;
|
|
}
|
|
|
|
#if 0
|
|
static int
|
|
t_tree_all(void)
|
|
{
|
|
/* random sequences of insertion/deletion/searches and walks */
|
|
return 0; /* failed */
|
|
}
|
|
#endif
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
bt_init(argc, argv);
|
|
bt_bird_init();
|
|
|
|
//unsigned seed = rand();
|
|
unsigned seed = 1000789714;
|
|
log("random seed is %d", seed);
|
|
srandom(seed);
|
|
|
|
bt_test_suite(t_oid_empty, "Function that determines if the OID is empty");
|
|
bt_test_suite(t_oid_compare, "Function defining lexicographical order on OIDs");
|
|
bt_test_suite(t_oid_prefixize, "Function transforming OID to prefixed form");
|
|
bt_test_suite(t_oid_ancestor, "Function finding common ancestor of two OIDs");
|
|
bt_test_suite(t_walk_to_oid, "Function transforming MIB tree walk state to OID");
|
|
bt_test_suite(t_walk_oid_desc, "Function comparing MIB tree walk to OID");
|
|
|
|
bt_test_suite(t_tree_find, "MIB tree search");
|
|
bt_test_suite(t_tree_traversal, "MIB tree traversal");
|
|
bt_test_suite(t_tree_leafs, "MIB tree leafs traversal");
|
|
bt_test_suite(t_tree_add, "MIB tree insertion");
|
|
bt_test_suite(t_tree_delete, "MIB tree deletion");
|
|
bt_test_suite(t_tree_remove, "MIB tree removal");
|
|
//bt_test_suite(t_tree_all, "MIB tree random find, add, delete mix");
|
|
|
|
return bt_exit_value();
|
|
}
|