static bool test_get_similar_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 query, result;
bool success = true;
for (addr_ctr = 0; addr_ctr < ARRAY_SIZE(expected_ips); addr_ctr++) {
query.address = expected_ips[addr_ctr];
for (port_ctr = port_min; port_ctr <= port_max; port_ctr += step) {
query.l4_id = port_ctr;
success &= assert_true(pool4_get_similar(l4protocol, &query, &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;
}
query.l4_id = port_min;
success &= assert_false(pool4_get_similar(l4protocol, &query, &result), test_name);
}
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;
}
static bool test_get_similar_function(void)
{
struct ipv4_tuple_address query;
struct ipv4_tuple_address null_result;
bool success = true;
int i;
memset(&results1, 0, sizeof(results1));
memset(&results2, 0, sizeof(results2));
// Borrow the entire first address.
query.address = expected_ips[0];
query.l4_id = 24;
for (i = 0; i < 1024; i += 2) {
success &= assert_true(pool4_get_similar(IPPROTO_UDP, &query, &results1[i]),
"Borrow Addr1-res");
success &= assert_tuple_addr(&expected_ips[0], i, &results1[i], "Borrow Addr1-out");
}
success &= assert_false(pool4_get_similar(IPPROTO_UDP, &query, &null_result),
"Borrow Addr1-Exhausted (1)");
success &= assert_false(pool4_get_similar(IPPROTO_UDP, &query, &null_result),
"Borrow Addr1-Exhausted (2)");
if (!success)
return success;
// Borrow some from the second address.
query.address = expected_ips[1];
query.l4_id = 888;
for (i = 0; i < 512; i += 2) {
success &= assert_true(pool4_get_similar(IPPROTO_UDP, &query, &results2[i]),
"Borrow Addr2-res");
success &= assert_tuple_addr(&expected_ips[1], i, &results2[i], "Borrow Addr2-out");
}
if (!success)
return success;
// Now return stuff in some disorganized manner.
success &= assert_true(pool4_return(IPPROTO_UDP, &results2[64]), "Return Addr2-port64");
success &= assert_true(pool4_return(IPPROTO_UDP, &results1[128]), "Return Addr1-port128");
success &= assert_true(pool4_return(IPPROTO_UDP, &results1[32]), "Return Addr2-port32");
success &= assert_true(pool4_return(IPPROTO_UDP, &results2[256]), "Return Addr1-port256");
// Reborrow it.
query.l4_id = 334;
query.address = expected_ips[0];
success &= assert_true(pool4_get_similar(IPPROTO_UDP, &query, &results1[128]),
"Get-Return mix (res), 128");
query.address = expected_ips[1];
success &= assert_true(pool4_get_similar(IPPROTO_UDP, &query, &results2[64]),
"Get-Return mix, (res) 64");
query.address = expected_ips[0];
success &= assert_true(pool4_get_similar(IPPROTO_UDP, &query, &results1[32]),
"Get-Return mix, (res) 32");
query.address = expected_ips[1];
success &= assert_true(pool4_get_similar(IPPROTO_UDP, &query, &results2[256]),
"Get-Return mix, (res) 256");
query.address = expected_ips[0];
success &= assert_false(pool4_get_similar(IPPROTO_UDP, &query, &null_result),
"Borrow Addr1-Exhausted (3)");
success &= assert_tuple_addr(&expected_ips[0], 128, &results1[128],
"Get-Return mix (out), 128");
success &= assert_tuple_addr(&expected_ips[1], 64, &results2[64],
"Get-Return mix (out), 64");
success &= assert_tuple_addr(&expected_ips[0], 32, &results1[32],
"Get-Return mix (out), 32");
success &= assert_tuple_addr(&expected_ips[1], 256, &results2[256],
"Get-Return mix (out), 256");
return success;
}
