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; }