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