/*
* @brief test ipv4 parsing
*/
static void test_v4(void)
{
struct lrtr_ip_addr addr;
char buf[INET_ADDRSTRLEN];
lrtr_ip_str_to_addr("0.0.0.0", &addr);
assert(addr.ver == LRTR_IPV4);
assert(addr.u.addr4.addr == 0);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("0.0.0.0", buf) == 0);
lrtr_ip_str_to_addr("255.255.255.255", &addr);
assert(addr.ver == LRTR_IPV4);
assert(addr.u.addr4.addr == 0xffffffff);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("255.255.255.255", buf) == 0);
lrtr_ip_str_to_addr("0.2.6.7", &addr);
assert(addr.ver == LRTR_IPV4);
assert(addr.u.addr4.addr == 0x20607);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("0.2.6.7", buf) == 0);
lrtr_ip_str_to_addr("78.69.255.0", &addr);
assert(addr.ver == LRTR_IPV4);
assert(addr.u.addr4.addr == 0x4e45ff00);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("78.69.255.0", buf) == 0);
lrtr_ip_str_to_addr("1.1.1.1", &addr);
assert(addr.ver == LRTR_IPV4);
assert(addr.u.addr4.addr == 0x1010101);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("1.1.1.1", buf) == 0);
lrtr_ip_str_to_addr("5.0.255.255", &addr);
assert(addr.ver == LRTR_IPV4);
assert(addr.u.addr4.addr == 0x500ffff);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("5.0.255.255", buf) == 0);
lrtr_ip_str_to_addr("8.9.6.3", &addr);
assert(addr.ver == LRTR_IPV4);
assert(addr.u.addr4.addr == 0x8090603);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("8.9.6.3", buf) == 0);
/* check some malformed addresses */
assert(lrtr_ip_str_to_addr("8,3,4,5", &addr) == -1);
assert(lrtr_ip_str_to_addr("8.4.5", &addr) == -1);
}
/*
* @brief test ip comparsions
*/
void test_cmp(void)
{
struct lrtr_ip_addr addr1, addr2;
lrtr_ip_str_to_addr("2001:0:4136:e378:8000:63bf:3fff:fdd2", &addr1);
lrtr_ip_str_to_addr("2001:0:4136:e378:8000:63bf:3fff:fdd2", &addr2);
assert(lrtr_ip_addr_equal(addr1, addr2) == true);
lrtr_ip_str_to_addr("2001:0:4136:e378:8000:63bf:3fff:fdd3", &addr2);
assert(lrtr_ip_addr_equal(addr1, addr2) == false);
lrtr_ip_str_to_addr("141.22.5.22", &addr2);
assert(lrtr_ip_addr_equal(addr1, addr2) == false);
lrtr_ip_str_to_addr("141.22.5.22", &addr1);
assert(lrtr_ip_addr_equal(addr1, addr2) == true);
lrtr_ip_str_to_addr("141.26.5.23", &addr1);
}
/*
* @brief test ipv6 parsing
*/
static void test_v6(void)
{
struct lrtr_ip_addr addr;
char buf[INET6_ADDRSTRLEN];
lrtr_ip_str_to_addr("fdf8:f53b:82e4::53", &addr);
assert(addr.u.addr6.addr[0] == 0xfdf8f53b);
assert(addr.u.addr6.addr[1] == 0x82e40000);
assert(addr.u.addr6.addr[2] == 0);
assert(addr.u.addr6.addr[3] == 0x53);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("fdf8:f53b:82e4::53", buf) == 0);
lrtr_ip_str_to_addr("fe80::200:5aee:feaa:20a2", &addr);
assert(addr.u.addr6.addr[0] == 0xfe800000);
assert(addr.u.addr6.addr[1] == 0);
assert(addr.u.addr6.addr[2] == 0x2005aee);
assert(addr.u.addr6.addr[3] == 0xfeaa20a2);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("fe80::200:5aee:feaa:20a2", buf) == 0);
lrtr_ip_str_to_addr("2001::1", &addr);
assert(addr.u.addr6.addr[0] == 0x20010000);
assert(addr.u.addr6.addr[1] == 0);
assert(addr.u.addr6.addr[2] == 0);
assert(addr.u.addr6.addr[3] == 0x1);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("2001::1", buf) == 0);
lrtr_ip_str_to_addr("2001:0:4136:e378:8000:63bf:3fff:fdd2", &addr);
assert(addr.u.addr6.addr[0] == 0x20010000);
assert(addr.u.addr6.addr[1] == 0x4136e378);
assert(addr.u.addr6.addr[2] == 0x800063bf);
assert(addr.u.addr6.addr[3] == 0x3ffffdd2);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("2001:0:4136:e378:8000:63bf:3fff:fdd2", buf) == 0);
lrtr_ip_str_to_addr("2001:2:6c::430", &addr);
assert(addr.u.addr6.addr[0] == 0x20010002);
assert(addr.u.addr6.addr[1] == 0x6C0000);
assert(addr.u.addr6.addr[2] == 0);
assert(addr.u.addr6.addr[3] == 0x430);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("2001:2:6c::430", buf) == 0);
lrtr_ip_str_to_addr("2001:10:240:ab::a", &addr);
assert(addr.u.addr6.addr[0] == 0x20010010);
assert(addr.u.addr6.addr[1] == 0x24000AB);
assert(addr.u.addr6.addr[2] == 0);
assert(addr.u.addr6.addr[3] == 0xa);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("2001:10:240:ab::a", buf) == 0);
lrtr_ip_str_to_addr("2002:cb0a:3cdd:1::1", &addr);
assert(addr.u.addr6.addr[0] == 0x2002cb0a);
assert(addr.u.addr6.addr[1] == 0x3cdd0001);
assert(addr.u.addr6.addr[2] == 0);
assert(addr.u.addr6.addr[3] == 0x1);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("2002:cb0a:3cdd:1::1", buf) == 0);
lrtr_ip_str_to_addr("2001:db8:8:4::2", &addr);
assert(addr.u.addr6.addr[0] == 0x20010db8);
assert(addr.u.addr6.addr[1] == 0x80004);
assert(addr.u.addr6.addr[2] == 0);
assert(addr.u.addr6.addr[3] == 0x2);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("2001:db8:8:4::2", buf) == 0);
lrtr_ip_str_to_addr("FF01:0:0:0:0:0:0:2", &addr);
assert(addr.u.addr6.addr[0] == 0xff010000);
assert(addr.u.addr6.addr[1] == 0);
assert(addr.u.addr6.addr[2] == 0);
assert(addr.u.addr6.addr[3] == 0x2);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("ff01::2", buf) == 0);
lrtr_ip_str_to_addr("fdf8:f53b:82e4::53", &addr);
assert(addr.u.addr6.addr[0] == 0xfdf8f53b);
assert(addr.u.addr6.addr[1] == 0x82e40000);
assert(addr.u.addr6.addr[2] == 0);
assert(addr.u.addr6.addr[3] == 0x53);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("fdf8:f53b:82e4::53", buf) == 0);
lrtr_ip_str_to_addr("fe80::200:5aee:feaa:20a2", &addr);
assert(addr.u.addr6.addr[0] == 0xfe800000);
assert(addr.u.addr6.addr[1] == 0);
assert(addr.u.addr6.addr[2] == 0x2005aee);
assert(addr.u.addr6.addr[3] == 0xfeaa20a2);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("fe80::200:5aee:feaa:20a2", buf) == 0);
lrtr_ip_str_to_addr("2001::1", &addr);
assert(addr.u.addr6.addr[0] == 0x20010000);
assert(addr.u.addr6.addr[1] == 0);
assert(addr.u.addr6.addr[2] == 0);
assert(addr.u.addr6.addr[3] == 1);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("2001::1", buf) == 0);
lrtr_ip_str_to_addr("2001:0:4136:e378:8000:63bf:3fff:fdd2", &addr);
assert(addr.u.addr6.addr[0] == 0x20010000);
assert(addr.u.addr6.addr[1] == 0x4136e378);
assert(addr.u.addr6.addr[2] == 0x800063bf);
assert(addr.u.addr6.addr[3] == 0x3ffffdd2);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("2001:0:4136:e378:8000:63bf:3fff:fdd2", buf) == 0);
/* test embedded ipv4 */
lrtr_ip_str_to_addr("::ffff:192.0.2.128", &addr);
assert(addr.u.addr6.addr[0] == 0);
assert(addr.u.addr6.addr[1] == 0);
assert(addr.u.addr6.addr[2] == 0xffff);
assert(addr.u.addr6.addr[3] == 0xc0000280);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("::ffff:192.0.2.128", buf) == 0);
lrtr_ip_str_to_addr("::10.58.64.34", &addr);
assert(addr.u.addr6.addr[0] == 0);
assert(addr.u.addr6.addr[1] == 0);
assert(addr.u.addr6.addr[2] == 0);
assert(addr.u.addr6.addr[3] == 0xa3a4022);
lrtr_ip_addr_to_str(&addr, buf, sizeof(buf));
assert(strcmp("::10.58.64.34", buf) == 0);
/* test check for mallformed embedded ipv4 */
assert(lrtr_ip_str_to_addr("::ffff:192.0,2.128", &addr) == -1);
/* buffer size check*/
assert(lrtr_ip_addr_to_str(&addr, buf, 10) == -1);
/* test leading single colon check */
assert(lrtr_ip_str_to_addr(":ffff::ffff", &addr) == -1);
/* test multiple double colons check */
assert(lrtr_ip_str_to_addr("::ffff::ffff", &addr) == -1);
/* test check for to long addresses */
assert(lrtr_ip_str_to_addr("2001:0:6:8:0:f:3fff:fdd2:55", &addr) == -1);
/* test check for to big groups */
assert(lrtr_ip_str_to_addr("::fffff", &addr) == -1);
/* check for null byte in address string */
assert(lrtr_ip_str_to_addr("2001:\0::", &addr) == -1);
}
/*
* @brief Test IPv6 address bit operations required by trie
*/
static void get_bits_testv6(void)
{
struct lrtr_ip_addr addr;
struct lrtr_ip_addr result;
addr.ver = LRTR_IPV6;
addr.u.addr6.addr[0] = 0x22AABBCC;
addr.u.addr6.addr[1] = 0xDDEEFF99;
addr.u.addr6.addr[2] = 0x33001122;
addr.u.addr6.addr[3] = 0x33445566;
result = lrtr_ip_addr_get_bits(&addr, 0, 128);
assert(result.u.addr6.addr[0] == addr.u.addr6.addr[0] &&
result.u.addr6.addr[1] == addr.u.addr6.addr[1] &&
result.u.addr6.addr[2] == addr.u.addr6.addr[2] &&
result.u.addr6.addr[3] == addr.u.addr6.addr[3]);
result = lrtr_ip_addr_get_bits(&addr, 0, 64);
assert(result.u.addr6.addr[0] == addr.u.addr6.addr[0] &&
result.u.addr6.addr[1] == addr.u.addr6.addr[1] &&
result.u.addr6.addr[2] == 0 &&
result.u.addr6.addr[3] == 0);
bzero(&result, sizeof(result));
result = lrtr_ip_addr_get_bits(&addr, 64, 64);
assert(result.u.addr6.addr[0] == 0);
assert(result.u.addr6.addr[1] == 0);
assert(result.u.addr6.addr[2] == addr.u.addr6.addr[2]);
assert(result.u.addr6.addr[3] == addr.u.addr6.addr[3]);
result = lrtr_ip_addr_get_bits(&addr, 0, 8);
assert(result.u.addr6.addr[0] == 0x22000000 &&
result.u.addr6.addr[1] == 0);
result = lrtr_ip_addr_get_bits(&addr, 64, 8);
assert(result.u.addr6.addr[1] == 0 &&
result.u.addr6.addr[2] == 0x33000000);
result = lrtr_ip_addr_get_bits(&addr, 7, 8);
assert(result.u.addr6.addr[0] == 0xAA0000 &&
result.u.addr6.addr[1] == 0);
result = lrtr_ip_addr_get_bits(&addr, 68, 7);
assert(result.u.addr6.addr[0] == 0 &&
result.u.addr6.addr[2] == 0x03000000);
char buf[INET6_ADDRSTRLEN];
lrtr_ip_str_to_addr("fe80::862b:2bff:fe9a:f50f", &addr);
addr.ver = LRTR_IPV6;
assert(addr.u.addr6.addr[0] == 0xfe800000);
assert(addr.u.addr6.addr[1] == 0);
assert(addr.u.addr6.addr[2] == 0x862b2bff);
assert(addr.u.addr6.addr[3] == 0xfe9af50f);
assert(lrtr_ip_str_to_addr("2001::", &addr) == 0);
assert(addr.u.addr6.addr[0] == 0x20010000);
assert(addr.u.addr6.addr[1] == 0);
assert(addr.u.addr6.addr[2] == 0);
assert(addr.u.addr6.addr[3] == 0);
assert(lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)) == 0);
assert(strcmp("2001::", buf) == 0);
lrtr_ip_str_to_addr("2001:0db8:85a3:08d3:1319:8a2e:0370:7344", &addr);
assert(lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)) == 0);
assert(strcmp("2001:db8:85a3:8d3:1319:8a2e:370:7344", buf) == 0);
result = lrtr_ip_addr_get_bits(&addr, 0, 16);
assert(lrtr_ip_addr_to_str(&result, buf, sizeof(buf)) == 0);
assert(lrtr_ip_str_cmp(&result, "2001::"));
result = lrtr_ip_addr_get_bits(&addr, 16, 16);
assert(lrtr_ip_addr_to_str(&result, buf, sizeof(buf)) == 0);
assert(lrtr_ip_str_cmp(&result, "0:db8::"));
result = lrtr_ip_addr_get_bits(&addr, 0, 1);
assert(lrtr_ip_str_cmp(&result, "::"));
result = lrtr_ip_addr_get_bits(&addr, 126, 1);
assert(lrtr_ip_addr_to_str(&result, buf, sizeof(buf)) == 0);
assert(lrtr_ip_str_cmp(&result, "::"));
}
/*
* @brief Test IPv4 address bit operations required by trie
*/
static void get_bits_testv4(void)
{
struct lrtr_ip_addr addr;
struct lrtr_ip_addr result;
addr.ver = LRTR_IPV4;
addr.u.addr4.addr = 0xAABBCC22;
result = lrtr_ip_addr_get_bits(&addr, 0, 32);
assert(result.u.addr4.addr == 0xAABBCC22);
result = lrtr_ip_addr_get_bits(&addr, 0, 1);
assert(result.u.addr4.addr == 0x80000000);
result = lrtr_ip_addr_get_bits(&addr, 1, 1);
assert(result.u.addr4.addr == 0);
result = lrtr_ip_addr_get_bits(&addr, 2, 1);
assert(result.u.addr4.addr == 0x20000000);
result = lrtr_ip_addr_get_bits(&addr, 0, 8);
assert(result.u.addr4.addr == 0xAA000000);
result = lrtr_ip_addr_get_bits(&addr, 8, 8);
assert(result.u.addr4.addr == 0x00BB0000);
lrtr_ip_str_to_addr("10.10.10.0", &addr);
result = lrtr_ip_addr_get_bits(&addr, 0, 8);
assert(lrtr_ip_str_cmp(&result, "10.0.0.0"));
result = lrtr_ip_addr_get_bits(&addr, 0, 16);
assert(lrtr_ip_str_cmp(&result, "10.10.0.0"));
result = lrtr_ip_addr_get_bits(&addr, 8, 8);
assert(lrtr_ip_str_cmp(&result, "0.10.0.0"));
result = lrtr_ip_addr_get_bits(&addr, 8, 24);
assert(lrtr_ip_str_cmp(&result, "0.10.10.0"));
result = lrtr_ip_addr_get_bits(&addr, 31, 1);
assert(result.u.addr4.addr == 0);
result = lrtr_ip_addr_get_bits(&addr, 0, 1);
assert(result.u.addr4.addr == 0);
result = lrtr_ip_addr_get_bits(&addr, 3, 3);
assert(lrtr_ip_str_cmp(&result, "8.0.0.0"));
assert(lrtr_ip_str_to_addr("132.200.0.0", &addr) == 0);
result = lrtr_ip_addr_get_bits(&addr, 0, 1);
assert(result.u.addr4.addr == 0x80000000);
assert(lrtr_ip_str_to_addr("101.200.0.0", &addr) == 0);
result = lrtr_ip_addr_get_bits(&addr, 0, 1);
assert(result.u.addr4.addr == 0);
addr.u.addr4.addr = 0x6D698000;
result = lrtr_ip_addr_get_bits(&addr, 0, 19);
assert(result.u.addr4.addr == 0x6D698000);
/* ip_str_to_addr("109.105.128.0", &addr);
* result = ip_addr_get_bits(&addr, 0, 8);
* printf("%u\n", result.u.addr4.addr);
*/
char buf[INET_ADDRSTRLEN];
assert(lrtr_ip_str_to_addr("10.10.10.5", &addr) == 0);
assert(lrtr_ip_addr_to_str(&addr, buf, sizeof(buf)) == 0);
assert(strcmp("10.10.10.5", buf) == 0);
}
int main(int argc, char *argv[])
{
/* check arguments, need hostname/IP and port of cache-server */
if (argc < 3) {
printf("Usage: %s [host] [port]\n", argv[0]);
return EXIT_FAILURE;
}
struct tr_socket tr_tcp;
struct tr_tcp_config tcp_config = { argv[1], argv[2], NULL };
struct rtr_socket rtr_tcp;
struct rtr_mgr_config *conf;
struct rtr_mgr_group groups[1];
/* init a TCP transport and create rtr socket */
tr_tcp_init(&tcp_config, &tr_tcp);
rtr_tcp.tr_socket = &tr_tcp;
/* create a rtr_mgr_group array with 1 element */
groups[0].sockets = malloc(1 * sizeof(struct rtr_socket *));
groups[0].sockets_len = 1;
groups[0].sockets[0] = &rtr_tcp;
groups[0].preference = 1;
if (rtr_mgr_init(&conf, groups, 1, 30, 600, 600, NULL, NULL,
&connection_status_callback, NULL) < 0)
return EXIT_FAILURE;
rtr_mgr_start(conf);
char input[256];
int sleep_counter = 0;
/* wait till at least one rtr_mgr_group is synchronized with server */
while (!rtr_mgr_conf_in_sync(conf)) {
if (connection_error(connection_status))
return EXIT_FAILURE;
sleep(1);
sleep_counter++;
if (sleep_counter >= connection_timeout) {
/*
* Wait for input before printing "timeout",
* to avoid "broken pipee error while communicating
* with the Python program
*/
if (fgets(input, 256, stdin))
;
printf("timeout\n");
fflush(stdout);
return EXIT_FAILURE;
}
}
char ip[128];
int mask;
int asn;
int counter;
/* loop for input */
while (1) {
int input_len;
int spaces;
/* recheck connection, exit on failure */
if (connection_error(connection_status))
return EXIT_FAILURE;
/* try reading from stdin, exit on failure */
if (!fgets(input, 256, stdin)) {
printf("input error\n");
return EXIT_FAILURE;
}
/* remove newline, if present */
input_len = strlen(input) - 1;
if (input[input_len] == '\n')
input[input_len] = '\0';
/* check if there are exactly 3 arguments */
spaces = 0;
for (counter = 0; counter < input_len; counter++) {
if (input[counter] == ' ' &&
input[counter + 1] != ' ' &&
input[counter + 1] != '\0' && counter != 0)
spaces++;
}
/* check input matching pattern */
if (spaces != 2) {
printf("Arguments required: IP Mask ASN\n");
fflush(stdout);
continue;
}
char delims[] = " ";
char *input_tok = NULL;
input_tok = strtok(input, delims);
strcpy(ip, input_tok);
input_tok = strtok(NULL, delims);
mask = atoi(input_tok);
input_tok = strtok(NULL, delims); asn = atoi(input_tok);
struct lrtr_ip_addr pref;
enum pfxv_state result;
struct pfx_record *reason = NULL;
unsigned int reason_len = 0;
lrtr_ip_str_to_addr(ip, &pref);
/* do validation */
pfx_table_validate_r(groups[0].sockets[0]->pfx_table, &reason,
&reason_len, asn, &pref, mask, &result);
int validity_code = -1;
/* translate validation result */
if (result == BGP_PFXV_STATE_VALID)
validity_code = 0;
else if (result == BGP_PFXV_STATE_NOT_FOUND)
validity_code = 1;
else if (result == BGP_PFXV_STATE_INVALID)
validity_code = 2;
/* IP Mask BGP-ASN| */
printf("%s %d %d|", ip, mask, asn);
/* ROA-ASN IP MaskMin MaskMax, ... */
if (reason && (reason_len > 0)) {
unsigned int i;
for (i = 0; i < reason_len; i++) {
char tmp[100];
lrtr_ip_addr_to_str(&reason[i].prefix,
tmp, sizeof(tmp));
printf("%u %s %u %u",
reason[i].asn, tmp,
reason[i].min_len,
reason[i].max_len);
if ((i + 1) < reason_len)
printf(",");
}
}
/* |validity_code */
printf("|%d", validity_code);
printf("\n");
fflush(stdout);
}
rtr_mgr_stop(conf);
rtr_mgr_free(conf);
free(groups[0].sockets);
return EXIT_SUCCESS;
}
int test_rtr_validation()
{
cfg_tr = bgpstream_rtr_start_connection(TEST_RPKI_VALIDATOR_URL,
TEST_RPKI_VALIDATOR_PORT, NULL, NULL,
NULL, NULL, NULL, NULL);
struct pfx_table *pfxt = cfg_tr->groups[0].sockets[0]->pfx_table;
struct pfx_record pfx_v4;
char ipv4_address[INET_ADDRSTRLEN];
pfx_v4.min_len = TEST_MIN_LEN;
pfx_v4.max_len = TEST_MAX_LEN;
pfx_v4.socket = TEST_SOCKET;
pfx_v4.asn = TEST_ASN;
strcpy(ipv4_address, TEST_IP_ADDR);
lrtr_ip_str_to_addr(ipv4_address, &pfx_v4.prefix);
pfx_table_remove(pfxt, &pfx_v4);
struct pfx_record pfx_v6;
char ipv6_address[INET6_ADDRSTRLEN];
pfx_v6.min_len = 48;
pfx_v6.max_len = 48;
pfx_v6.socket = NULL;
pfx_v6.asn = 12654;
strcpy(ipv6_address, "2001:7fb:fd02::\0");
lrtr_ip_str_to_addr(ipv6_address, &pfx_v6.prefix);
pfx_table_remove(pfxt, &pfx_v6);
struct reasoned_result res;
CHECK("RTR: Add a valid pfx_record to pfx_table",
pfx_table_add(pfxt, &pfx_v4) == PFX_SUCCESS);
res = bgpstream_rtr_validate_reason(cfg_tr, pfx_v4.asn, ipv4_address,
pfx_v4.max_len);
CHECK("RTR: Compare valid IPv4 ROA with validation result",
res.result == BGP_PFXV_STATE_VALID);
CHECK("RTR: Add a valid pfx_record to pfx_table",
pfx_table_add(pfxt, &pfx_v6) == PFX_SUCCESS);
res = bgpstream_rtr_validate_reason(cfg_tr, pfx_v6.asn, ipv6_address,
pfx_v6.max_len);
CHECK("RTR: Compare valid IPv6 ROA with validation result",
res.result == BGP_PFXV_STATE_VALID);
res = bgpstream_rtr_validate_reason(cfg_tr, 196615, ipv4_address,
pfx_v4.max_len);
CHECK("RTR: Compare invalid (asn) IPv4 ROA with validation result",
res.result == BGP_PFXV_STATE_INVALID);
res = bgpstream_rtr_validate_reason(cfg_tr, 196615, ipv6_address,
pfx_v6.max_len);
CHECK("RTR: Compare invalid (asn) IPv6 ROA with validation result",
res.result == BGP_PFXV_STATE_INVALID);
res = bgpstream_rtr_validate_reason(cfg_tr, pfx_v4.asn, ipv4_address, 30);
CHECK("RTR: Compare invalid (max len) IPv4 ROA with validation result",
res.result == BGP_PFXV_STATE_INVALID);
res = bgpstream_rtr_validate_reason(cfg_tr, pfx_v6.asn, ipv6_address, 50);
CHECK("RTR: Compare invalid (max len) IPv6 ROA with validation result",
res.result == BGP_PFXV_STATE_INVALID);
pfx_v4.asn = 12345;
lrtr_ip_str_to_addr("84.205.83.0\0", &pfx_v4.prefix);
pfx_table_remove(pfxt, &pfx_v4);
res = bgpstream_rtr_validate_reason(cfg_tr, 12345, "84.205.83.0\0",
pfx_v4.max_len);
CHECK("RTR: Compare none existend IPv4 ROA with validation result",
res.result == BGP_PFXV_STATE_NOT_FOUND);
pfx_v6.asn = 12345;
lrtr_ip_str_to_addr("2001:7fb:ff03::\0", &pfx_v6.prefix);
pfx_table_remove(pfxt, &pfx_v6);
res = bgpstream_rtr_validate_reason(cfg_tr, 12345, "2001:7fb:ff03::\0",
pfx_v6.max_len);
CHECK("RTR: Compare none existend IPv6 ROA with validation result",
res.result == BGP_PFXV_STATE_NOT_FOUND);
free(res.reason);
bgpstream_rtr_close_connection(cfg_tr);
return 0;
}
int test_validation_process()
{
bgpstream_set_rtr_config(TEST_RPKI_VALIDATOR_URL, TEST_RPKI_VALIDATOR_PORT,
NULL, NULL, NULL, true);
cfg_tr =
bgpstream_rtr_start_connection(rtr_server_conf.host, rtr_server_conf.port,
NULL, NULL, NULL, NULL, NULL, NULL);
struct pfx_table *pfxt = cfg_tr->groups[0].sockets[0]->pfx_table;
bgpstream_elem_t *elem = bgpstream_elem_create();
elem->annotations.rpki_validation_status =
BGPSTREAM_ELEM_RPKI_VALIDATION_STATUS_NOTVALIDATED;
uint8_t number_of_tests = 3;
uint8_t pfxs_size = number_of_tests * number_of_tests;
struct pfx_record pfxs[pfxs_size];
int test_asn_index;
for (test_asn_index = 0; test_asn_index < number_of_tests; test_asn_index++) {
int test_pfx_index;
for (test_pfx_index = 0; test_pfx_index < number_of_tests;
test_pfx_index++) {
struct pfx_record pfx;
pfx.min_len = TEST_MIN_LEN - test_pfx_index;
pfx.max_len = TEST_MAX_LEN - test_pfx_index;
pfx.socket = TEST_SOCKET;
pfx.asn = TEST_ASN + test_asn_index;
char ip_address[INET_ADDRSTRLEN];
strcpy(ip_address, TEST_IP_ADDR);
lrtr_ip_str_to_addr(ip_address, &pfx.prefix);
CHECK("RTR: Add a valid pfx_record to pfx_table",
pfx_table_add(pfxt, &pfx) == PFX_SUCCESS);
pfxs[(test_asn_index * number_of_tests) + test_pfx_index] = pfx;
bgpstream_elem_get_rpki_validation_result(elem, ip_address, pfx.asn,
pfx.max_len);
}
}
bgpstream_rpki_validation_result_t val_table;
val_table = elem->annotations.rpki_validation_result;
int test_index;
for (test_index = 0; test_index < pfxs_size; test_index++) {
int asn_index;
for (asn_index = 0; asn_index < val_table.asn_used; asn_index++) {
if (val_table.asn_pfx[asn_index].asn == pfxs[test_index].asn) {
CHECK("RTR: Inspect result struct to find added asn", true);
int pfx_index;
for (pfx_index = 0; pfx_index < val_table.asn_pfx[asn_index].pfx_used;
pfx_index++) {
char pfx_string[INET6_ADDRSTRLEN];
lrtr_ip_addr_to_str(&pfxs[test_index].prefix, pfx_string,
INET6_ADDRSTRLEN);
if (inet_ntoa(val_table.asn_pfx[asn_index]
.pfxs[pfx_index]
.pfx.address.ipv4) == pfx_string) {
CHECK("RTR: Inspect result struct to find added pfx", true);
CHECK("RTR: Compare max len of prefix ",
val_table.asn_pfx[asn_index].pfxs[pfx_index].max_pfx_len ==
pfxs[test_index].max_len);
}
}
}
}
}
return 0;
}
