/* prepend testing */
static void
prepend_test (struct tests *t)
{
struct aspath *asp1, *asp2, *ascratch;
printf ("prepend %s: %s\n", t->test1->name, t->test1->desc);
printf ("to %s: %s\n", t->test2->name, t->test2->desc);
asp1 = make_aspath (t->test1->asdata, t->test1->len, 0);
asp2 = make_aspath (t->test2->asdata, t->test2->len, 0);
ascratch = aspath_dup (asp2);
aspath_unintern (asp2);
asp2 = aspath_prepend (asp1, ascratch);
printf ("aspath: %s\n", aspath_print (asp2));
if (!validate (asp2, &t->sp))
printf ("%s\n", OK);
else
printf ("%s!\n", FAILED);
printf ("\n");
aspath_unintern (asp1);
aspath_free (asp2);
}
/* empty-prepend testing */
static void
empty_prepend_test (struct test_segment *t)
{
struct aspath *asp1, *asp2, *ascratch;
printf ("empty prepend %s: %s\n", t->name, t->desc);
asp1 = make_aspath (t->asdata, t->len, 0);
asp2 = aspath_empty ();
ascratch = aspath_dup (asp2);
aspath_unintern (asp2);
asp2 = aspath_prepend (asp1, ascratch);
printf ("aspath: %s\n", aspath_print (asp2));
if (!validate (asp2, &t->sp))
printf (OK "\n");
else
printf (FAILED "!\n");
printf ("\n");
aspath_unintern (asp1);
aspath_free (asp2);
}
/* cmp_left tests */
static void
cmp_test ()
{
unsigned int i;
#define CMP_TESTS_MAX \
(sizeof(left_compare) / sizeof (struct compare_tests))
for (i = 0; i < CMP_TESTS_MAX; i++)
{
struct test_segment *t1 = &test_segments[left_compare[i].test_index1];
struct test_segment *t2 = &test_segments[left_compare[i].test_index2];
struct aspath *asp1, *asp2;
printf ("left cmp %s: %s\n", t1->name, t1->desc);
printf ("and %s: %s\n", t2->name, t2->desc);
asp1 = make_aspath (t1->asdata, t1->len, 0);
asp2 = make_aspath (t2->asdata, t2->len, 0);
if (aspath_cmp_left (asp1, asp2) != left_compare[i].shouldbe_cmp
|| aspath_cmp_left (asp2, asp1) != left_compare[i].shouldbe_cmp
|| aspath_cmp_left_confed (asp1, asp2)
!= left_compare[i].shouldbe_confed
|| aspath_cmp_left_confed (asp2, asp1)
!= left_compare[i].shouldbe_confed)
{
failed++;
printf (FAILED "\n");
printf ("result should be: cmp: %d, confed: %d\n",
left_compare[i].shouldbe_cmp,
left_compare[i].shouldbe_confed);
printf ("got: cmp %d, cmp_confed: %d\n",
aspath_cmp_left (asp1, asp2),
aspath_cmp_left_confed (asp1, asp2));
printf("path1: %s\npath2: %s\n", aspath_print (asp1),
aspath_print (asp2));
}
else
printf (OK "\n");
printf ("\n");
aspath_unintern (asp1);
aspath_unintern (asp2);
}
}
static int
handle_attr_test (struct aspath_tests *t)
{
struct bgp bgp = { 0 };
struct peer peer = { 0 };
struct attr attr = { 0 };
int ret;
int initfail = failed;
struct aspath *asp;
size_t datalen;
asp = make_aspath (t->segment->asdata, t->segment->len, 0);
peer.ibuf = stream_new (BGP_MAX_PACKET_SIZE);
peer.obuf = stream_fifo_new ();
peer.bgp = &bgp;
peer.host = (char *)"none";
peer.fd = -1;
peer.cap = t->cap;
stream_write (peer.ibuf, t->attrheader, t->len);
datalen = aspath_put (peer.ibuf, asp, t->as4 == AS4_DATA);
ret = bgp_attr_parse (&peer, &attr, t->len + datalen, NULL, NULL);
if (ret != t->result)
{
printf ("bgp_attr_parse returned %d, expected %d\n", ret, t->result);
printf ("datalen %zd\n", datalen);
failed++;
}
if (ret != 0)
goto out;
if (attr.aspath == NULL)
{
printf ("aspath is NULL!\n");
failed++;
}
if (attr.aspath && strcmp (attr.aspath->str, t->shouldbe))
{
printf ("attr str and 'shouldbe' mismatched!\n"
"attr str: %s\n"
"shouldbe: %s\n",
attr.aspath->str, t->shouldbe);
failed++;
}
out:
if (attr.aspath)
aspath_unintern (&attr.aspath);
if (asp)
aspath_unintern (&asp);
return failed - initfail;
}
/* as2+as4 reconciliation testing */
static void
as4_reconcile_test (struct tests *t)
{
struct aspath *asp1, *asp2, *ascratch;
printf ("reconciling %s:\n %s\n", t->test1->name, t->test1->desc);
printf ("with %s:\n %s\n", t->test2->name, t->test2->desc);
asp1 = make_aspath (t->test1->asdata, t->test1->len, 0);
asp2 = make_aspath (t->test2->asdata, t->test2->len, 0);
ascratch = aspath_reconcile_as4 (asp1, asp2);
if (!validate (ascratch, &t->sp))
printf (OK "\n");
else
printf (FAILED "!\n");
printf ("\n");
aspath_unintern (asp1);
aspath_unintern (asp2);
aspath_free (ascratch);
}
/* aggregation testing */
static void
aggregate_test (struct tests *t)
{
struct aspath *asp1, *asp2, *ascratch;
printf ("aggregate %s: %s\n", t->test1->name, t->test1->desc);
printf ("with %s: %s\n", t->test2->name, t->test2->desc);
asp1 = make_aspath (t->test1->asdata, t->test1->len, 0);
asp2 = make_aspath (t->test2->asdata, t->test2->len, 0);
ascratch = aspath_aggregate (asp1, asp2);
if (!validate (ascratch, &t->sp))
printf (OK "\n");
else
printf (FAILED "!\n");
printf ("\n");
aspath_unintern (asp1);
aspath_unintern (asp2);
aspath_free (ascratch);
/* aspath_unintern (ascratch);*/
}
/* basic parsing test */
static void
parse_test (struct test_segment *t)
{
struct aspath *asp;
printf ("%s: %s\n", t->name, t->desc);
asp = make_aspath (t->asdata, t->len, 0);
printf ("aspath: %s\nvalidating...:\n", aspath_print (asp));
if (!validate (asp, &t->sp))
printf (OK "\n");
else
printf (FAILED "\n");
printf ("\n");
aspath_unintern (asp);
}
/* validate the given aspath */
static int
validate (struct aspath *as, const struct test_spec *sp)
{
size_t bytes, bytes4;
int fails = 0;
const u_char *out;
static struct stream *s;
struct aspath *asinout, *asconfeddel, *asstr, *as4;
out = aspath_snmp_pathseg (as, &bytes);
asinout = make_aspath (out, bytes, 0);
/* Excercise AS4 parsing a bit, with a dogfood test */
if (!s)
s = stream_new (4096);
bytes4 = aspath_put (s, as, 1);
as4 = make_aspath (STREAM_DATA(s), bytes4, 1);
asstr = aspath_str2aspath (sp->shouldbe);
asconfeddel = aspath_delete_confed_seq (aspath_dup (asinout));
printf ("got: %s\n", aspath_print(as));
/* the parsed path should match the specified 'shouldbe' string.
* We should pass the "eat our own dog food" test, be able to output
* this path and then input it again. Ie the path resulting from:
*
* aspath_parse(aspath_put(as))
*
* should:
*
* - also match the specified 'shouldbe' value
* - hash to same value as original path
* - have same hops and confed counts as original, and as the
* the specified counts
*
* aspath_str2aspath() and shouldbe should match
*
* We do the same for:
*
* aspath_parse(aspath_put(as,USE32BIT))
*
* Confederation related tests:
* - aspath_delete_confed_seq(aspath) should match shouldbe_confed
* - aspath_delete_confed_seq should be idempotent.
*/
if (strcmp(aspath_print (as), sp->shouldbe)
/* hash validation */
|| (aspath_key_make (as) != aspath_key_make (asinout))
/* by string */
|| strcmp(aspath_print (asinout), sp->shouldbe)
/* By 4-byte parsing */
|| strcmp(aspath_print (as4), sp->shouldbe)
/* by various path counts */
|| (aspath_count_hops (as) != sp->hops)
|| (aspath_count_confeds (as) != sp->confeds)
|| (aspath_count_hops (asinout) != sp->hops)
|| (aspath_count_confeds (asinout) != sp->confeds))
{
failed++;
fails++;
printf ("shouldbe:\n%s\n", sp->shouldbe);
printf ("as4:\n%s\n", aspath_print (as4));
printf ("hash keys: in: %d out->in: %d\n",
aspath_key_make (as), aspath_key_make (asinout));
printf ("hops: %d, counted %d %d\n", sp->hops,
aspath_count_hops (as),
aspath_count_hops (asinout) );
printf ("confeds: %d, counted %d %d\n", sp->confeds,
aspath_count_confeds (as),
aspath_count_confeds (asinout));
printf ("out->in:\n%s\nbytes: ", aspath_print(asinout));
printbytes (out, bytes);
}
/* basic confed related tests */
if ((aspath_print (asconfeddel) == NULL
&& sp->shouldbe_delete_confed != NULL)
|| (aspath_print (asconfeddel) != NULL
&& sp->shouldbe_delete_confed == NULL)
|| strcmp(aspath_print (asconfeddel), sp->shouldbe_delete_confed)
/* delete_confed_seq should be idempotent */
|| (aspath_key_make (asconfeddel)
!= aspath_key_make (aspath_delete_confed_seq (asconfeddel))))
{
failed++;
fails++;
printf ("confed_del: %s\n", aspath_print (asconfeddel));
printf ("should be: %s\n", sp->shouldbe_delete_confed);
}
/* aspath_str2aspath test */
if ((aspath_print (asstr) == NULL && sp->shouldbe != NULL)
|| (aspath_print (asstr) != NULL && sp->shouldbe == NULL)
|| strcmp(aspath_print (asstr), sp->shouldbe))
{
failed++;
fails++;
printf ("asstr: %s\n", aspath_print (asstr));
}
/* loop, private and first as checks */
if ((sp->does_loop && aspath_loop_check (as, sp->does_loop) == 0)
|| (sp->doesnt_loop && aspath_loop_check (as, sp->doesnt_loop) != 0)
|| (aspath_private_as_check (as) != sp->private_as)
|| (aspath_firstas_check (as,sp->first)
&& sp->first == 0))
{
failed++;
fails++;
printf ("firstas: %d, got %d\n", sp->first,
aspath_firstas_check (as,sp->first));
printf ("loop does: %d %d, doesnt: %d %d\n",
sp->does_loop, aspath_loop_check (as, sp->does_loop),
sp->doesnt_loop, aspath_loop_check (as, sp->doesnt_loop));
printf ("private check: %d %d\n", sp->private_as,
aspath_private_as_check (as));
}
aspath_unintern (asinout);
aspath_unintern (as4);
aspath_free (asconfeddel);
aspath_free (asstr);
stream_reset (s);
return fails;
}