static bool test_get_any_aux(u_int8_t l4protocol, u32 port_min, u32 port_max, u32 step, char *test_name)
{
u32 addr_ctr, port_ctr;
struct ipv4_tuple_address result;
bool success = true;
for (addr_ctr = 0; addr_ctr < ARRAY_SIZE(expected_ips); addr_ctr++) {
for (port_ctr = port_min; port_ctr <= port_max; port_ctr += step) {
success &= assert_true(pool4_get_any(l4protocol, port_ctr, &result), test_name);
success &= assert_equals_ipv4(&expected_ips[addr_ctr], &result.address, test_name);
success &= assert_false(ports[addr_ctr][result.l4_id], test_name);
ports[addr_ctr][result.l4_id] = true;
}
}
success &= assert_false(pool4_get_any(l4protocol, 0, &result), test_name);
return success;
}
static bool test_range(__u32 port_range_min, __u32 port_range_max, char *test_name)
{
__u32 addr_ctr, port_ctr;
struct ipv4_tuple_address result;
bool success = true;
for (addr_ctr = 0; addr_ctr < ARRAY_SIZE(expected_ips); addr_ctr++) {
for (port_ctr = port_range_min; port_ctr <= port_range_max; port_ctr += 2) {
success &= assert_true(pool4_get_any(IPPROTO_UDP, port_range_min, &result), test_name);
success &= assert_tuple_addr(&expected_ips[addr_ctr], port_ctr, &result, test_name);
// if (!success && (port_ctr % 20 == 0 || (port_ctr + 1) % 20 == 0))
// return false;
}
}
success &= assert_false(pool4_get_any(IPPROTO_UDP, port_range_min, &result), test_name);
success &= assert_false(pool4_get_any(IPPROTO_UDP, port_range_min, &result), test_name);
return success;
}
/**
* The return function cannot be tested on its own, so here's also the rest of the get_any test.
*
* Purpose is to test get returns address/ports in the expected order, given different combinations
* of return calls.
* We only use the lower even range of ports, since the rest was tested during
* test_get_any_function().
*/
static bool test_return_function(void)
{
bool success = true;
int i;
memset(&results1, 0, sizeof(results1));
memset(&results2, 0, sizeof(results2));
// Borrow the entire first address.
for (i = 0; i < 1024; i += 2) {
success &= assert_true(pool4_get_any(IPPROTO_UDP, i, &results1[i]), "Borrow Addr1-res");
success &= assert_tuple_addr(&expected_ips[0], i, &results1[i], "Borrow Addr1-out");
}
// Borrow the first port of the second address.
success &= assert_true(pool4_get_any(IPPROTO_UDP, 0, &results2[0]), "Borrow Addr2-res-port0");
success &= assert_tuple_addr(&expected_ips[1], 0, &results2[0], "Borrow Addr2-out-port0");
// Return the last one.
success &= assert_true(pool4_return(IPPROTO_UDP, &results2[0]), "Return Addr2-port0");
if (!success)
return success;
// Reborrow it.
success &= assert_true(pool4_get_any(IPPROTO_UDP, 0, &results2[0]), "Reborrow Addr2-res-port0");
success &= assert_tuple_addr(&expected_ips[1], 0, &results2[0], "Reborrow Addr2-out-port0");
if (!success)
return success;
// Return some more stuff.
success &= assert_true(pool4_return(IPPROTO_UDP, &results1[46]), "Return Addr1-port46");
success &= assert_true(pool4_return(IPPROTO_UDP, &results1[1000]), "Return Addr1-port1000");
success &= assert_true(pool4_return(IPPROTO_UDP, &results2[0]), "ReReturn Addr2-port0");
if (!success)
return success;
// Reborrow it.
success &= assert_true(pool4_get_any(IPPROTO_UDP, 24, &results1[46]),
"Reborrow Addr1-res-port46");
success &= assert_true(pool4_get_any(IPPROTO_UDP, 1010, &results1[1000]),
"Reborrow Addr1-res-port1000");
success &= assert_true(pool4_get_any(IPPROTO_UDP, 56, &results2[0]),
"ReReborrow Addr2-res-port0");
success &= assert_tuple_addr(&expected_ips[0], 46, &results1[46],
"Reborrow Addr1-out-port46");
success &= assert_tuple_addr(&expected_ips[0], 1000, &results1[1000],
"Reborrow Addr1-out-port1000");
success &= assert_tuple_addr(&expected_ips[1], 0, &results2[0],
"ReReborrow Addr2-out-port0");
return success;
}
/**
* Only UDP and its lower even range of ports is tested here.
*/
static bool test_return_function(void)
{
struct ipv4_tuple_address query, result;
bool success = true;
int addr_ctr, port_ctr;
/* Try to return the entire pool, even though we haven't borrowed anything. */
for (addr_ctr = 0; addr_ctr < ARRAY_SIZE(expected_ips); addr_ctr++) {
result.address = expected_ips[addr_ctr];
for (port_ctr = 0; port_ctr < 1024; port_ctr += 2) {
result.l4_id = port_ctr;
success &= assert_false(pool4_return(IPPROTO_UDP, &result), "");
}
}
/* Borrow the entire pool. */
for (addr_ctr = 0; addr_ctr < ARRAY_SIZE(expected_ips); addr_ctr++) {
for (port_ctr = 0; port_ctr < 1024; port_ctr += 2) {
success &= assert_true(pool4_get_any(IPPROTO_UDP, port_ctr, &result), "Borrow-result");
success &= assert_equals_ipv4(&expected_ips[addr_ctr], &result.address, "Borrow-addr");
success &= assert_false(ports[addr_ctr][result.l4_id], "Borrow-port");
ports[addr_ctr][result.l4_id] = true;
}
}
success &= assert_false(pool4_get_any(IPPROTO_UDP, 0, &result), "Pool should be exhausted.");
if (!success)
return success;
/* Return something from the first address. */
result.address = expected_ips[0];
result.l4_id = 1000;
success &= assert_true(pool4_return(IPPROTO_UDP, &result), "Return");
ports[0][result.l4_id] = false;
if (!success)
return success;
/* Re-borrow it, assert it's the same one. */
success &= assert_true(pool4_get_any(IPPROTO_UDP, 0, &result), "");
success &= assert_equals_ipv4(&expected_ips[0], &result.address, "");
success &= assert_false(ports[0][result.l4_id], "");
ports[0][result.l4_id] = true;
success &= assert_false(pool4_get_any(IPPROTO_UDP, 0, &result), "");
if (!success)
return success;
/*
* Do the same to the second address. Use get_similar() instead of get_any() to add some quick
* noise.
*/
result.address = expected_ips[1];
result.l4_id = 1000;
success &= assert_true(pool4_return(IPPROTO_UDP, &result), "Return");
ports[1][result.l4_id] = false;
if (!success)
return success;
query.address = expected_ips[1];
query.l4_id = 0;
success &= assert_true(pool4_get_similar(IPPROTO_UDP, &query, &result), "");
success &= assert_equals_ipv4(&expected_ips[1], &result.address, "");
success &= assert_false(ports[1][result.l4_id], "");
ports[1][result.l4_id] = true;
success &= assert_false(pool4_get_similar(IPPROTO_UDP, &query, &result), "");
if (!success)
return success;
/* Return some more stuff at once. */
result.address = expected_ips[0];
result.l4_id = 46;
success &= assert_true(pool4_return(IPPROTO_UDP, &result), "Return Addr1-port46");
ports[0][46] = false;
result.l4_id = 1000;
success &= assert_true(pool4_return(IPPROTO_UDP, &result), "Return Addr1-port1000");
ports[0][1000] = false;
result.address = expected_ips[1];
result.l4_id = 0;
success &= assert_true(pool4_return(IPPROTO_UDP, &result), "ReReturn Addr2-port0");
ports[1][0] = false;
if (!success)
return success;
/* Reborrow it. */
success &= assert_true(pool4_get_any(IPPROTO_UDP, 24, &result), "Reborrow Addr1-res-port24");
success &= assert_equals_ipv4(&expected_ips[0], &result.address, "");
success &= assert_false(ports[0][result.l4_id], "");
ports[0][result.l4_id] = true;
query.address = expected_ips[0];
query.l4_id = 100;
success &= assert_true(pool4_get_similar(IPPROTO_UDP, &query, &result), "Reborrow Addr1-res-port100");
success &= assert_equals_ipv4(&expected_ips[0], &result.address, "");
success &= assert_false(ports[0][result.l4_id], "");
ports[0][result.l4_id] = true;
success &= assert_true(pool4_get_any(IPPROTO_UDP, 56, &result), "ReReborrow Addr2-res-port56");
success &= assert_equals_ipv4(&expected_ips[1], &result.address, "");
success &= assert_false(ports[1][result.l4_id], "");
ports[1][result.l4_id] = true;
success &= assert_false(pool4_get_any(IPPROTO_UDP, 12, &result), "");
if (!success)
return success;
/* Now return everything. */
for (addr_ctr = 0; addr_ctr < ARRAY_SIZE(expected_ips); addr_ctr++) {
result.address = expected_ips[addr_ctr];
for (port_ctr = 0; port_ctr < 1024; port_ctr += 2) {
result.l4_id = port_ctr;
success &= assert_true(pool4_return(IPPROTO_UDP, &result), "");
ports[addr_ctr][port_ctr] = false;
}
}
success &= assert_false(pool4_return(IPPROTO_UDP, &result), "");
return success;
}
