static bool test_get_ext_function_subheaders(void)
{
bool success = true;
/* Init */
struct ipv6hdr *ip6_header;
struct frag_hdr *fragment_hdr;
struct ipv6_opt_hdr *hop_by_hop_hdr;
struct ipv6_opt_hdr *routing_hdr;
unsigned char *payload;
ip6_header = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTING_HDR_LEN + 4, NEXTHDR_FRAGMENT);
if (!ip6_header)
return false;
fragment_hdr = add_frag_hdr(ip6_header, sizeof(struct ipv6hdr), NEXTHDR_HOP);
hop_by_hop_hdr = add_opt_hdr(fragment_hdr, FRAG_HDR_LEN, NEXTHDR_ROUTING);
routing_hdr = add_opt_hdr(hop_by_hop_hdr, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(routing_hdr, ROUTING_HDR_LEN);
/* Test */
success &= assert_equals_ptr(fragment_hdr, get_extension_header(ip6_header, NEXTHDR_FRAGMENT),
"Frag hdr");
success &= assert_equals_ptr(hop_by_hop_hdr, get_extension_header(ip6_header, NEXTHDR_HOP),
"Hop-by-hop hdr");
success &= assert_equals_ptr(NULL, get_extension_header(ip6_header, NEXTHDR_ESP),
"ESP header");
success &= assert_equals_ptr(NULL, get_extension_header(ip6_header, NEXTHDR_UDP),
"Payload"); /* The UDP header is not an extension header. */
/* End */
kfree(ip6_header);
return success;
}
static bool test_get_ext_function_unsupported(void)
{
bool success = true;
/* Init */
struct ipv6hdr *ip6_header;
struct frag_hdr *fragment_hdr;
struct ipv6_opt_hdr *esp_hdr, *routing_hdr;
unsigned char *payload;
ip6_header = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTING_HDR_LEN + 4, NEXTHDR_FRAGMENT);
if (!ip6_header)
return false;
fragment_hdr = add_frag_hdr(ip6_header, sizeof(struct ipv6hdr), NEXTHDR_ESP);
esp_hdr = add_opt_hdr(fragment_hdr, FRAG_HDR_LEN, FRAG_HDR_LEN);
routing_hdr = add_routing_hdr(esp_hdr, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(routing_hdr, ROUTING_HDR_LEN);
/* Test */
success &= assert_equals_ptr(fragment_hdr, get_extension_header(ip6_header, NEXTHDR_FRAGMENT),
"Frag hdr");
success &= assert_equals_ptr(esp_hdr, get_extension_header(ip6_header, NEXTHDR_ESP),
"ESP header");
success &= assert_equals_ptr(NULL, get_extension_header(ip6_header, NEXTHDR_ROUTING),
"Routing header"); /* The ESP header is in the way. */
success &= assert_equals_ptr(NULL, get_extension_header(ip6_header, NEXTHDR_UDP),
"Payload"); /* Same, but that isn't an extension header anyway. */
/* End */
kfree(ip6_header);
return success;
}
static bool test_last_unsupported(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *hdr6;
struct frag_hdr *hdr_frag;
struct ipv6_opt_hdr *hdr_esp;
struct ipv6_opt_hdr *hdr_route;
unsigned char *payload;
hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4,
NEXTHDR_FRAGMENT);
if (!hdr6)
return false;
hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_ESP);
hdr_esp = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, FRAG_HDR_LEN);
hdr_route = add_route_hdr(hdr_esp, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(hdr_route, ROUTE_HDR_LEN);
/* Test */
hdr_iterator_init(&iterator, hdr6);
hdr_iterator_last(&iterator);
success &= ASSERT_PTR(hdr_esp, iterator.data, "Last:data");
success &= ASSERT_UINT(NEXTHDR_ESP, iterator.hdr_type, "Last:type");
/* End */
kfree(hdr6);
return success;
}
static bool test_last_function_unsupported(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *ip6_header;
struct frag_hdr *fragment_hdr;
struct ipv6_opt_hdr *esp_hdr;
struct ipv6_opt_hdr *routing_hdr;
unsigned char *payload;
ip6_header = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTING_HDR_LEN + 4, NEXTHDR_FRAGMENT);
if (!ip6_header)
return false;
fragment_hdr = add_frag_hdr(ip6_header, sizeof(struct ipv6hdr), NEXTHDR_ESP);
esp_hdr = add_opt_hdr(fragment_hdr, FRAG_HDR_LEN, FRAG_HDR_LEN);
routing_hdr = add_routing_hdr(esp_hdr, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(routing_hdr, ROUTING_HDR_LEN);
/* Test */
hdr_iterator_init(&iterator, ip6_header);
success &= assert_equals_int(HDR_ITERATOR_UNSUPPORTED, hdr_iterator_last(&iterator), "Result");
success &= assert_equals_ptr(esp_hdr, iterator.data, "Last function, data");
success &= assert_equals_u8(NEXTHDR_ESP, iterator.hdr_type, "Last function, type");
/* End */
kfree(ip6_header);
return success;
}
static bool test_next_subheaders(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *hdr6;
struct frag_hdr *hdr_frag;
struct ipv6_opt_hdr *hdr_hop;
struct ipv6_opt_hdr *hdr_route;
unsigned char *payload;
hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4,
NEXTHDR_FRAGMENT);
if (!hdr6)
return false;
hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_HOP);
hdr_hop = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, NEXTHDR_ROUTING);
hdr_route = add_route_hdr(hdr_hop, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(hdr_route, ROUTE_HDR_LEN);
/* Test */
hdr_iterator_init(&iterator, hdr6);
success &= ASSERT_PTR(hdr_frag, iterator.data, "Frag:data");
success &= ASSERT_UINT(NEXTHDR_FRAGMENT, iterator.hdr_type,
"Frag:type");
if (!success)
goto end;
success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 1");
success &= ASSERT_PTR(hdr_hop, iterator.data, "Hop:data");
success &= ASSERT_UINT(NEXTHDR_HOP, iterator.hdr_type, "Hop:type");
if (!success)
goto end;
success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 2");
success &= ASSERT_PTR(hdr_route, iterator.data, "Routing:data");
success &= ASSERT_UINT(NEXTHDR_ROUTING, iterator.hdr_type,
"Routing:type");
if (!success)
goto end;
success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 3");
success &= ASSERT_PTR(payload, iterator.data, "Payload1:data");
success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload1:type");
if (!success)
goto end;
success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Next 4");
success &= ASSERT_PTR(payload, iterator.data, "Payload2:data");
success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload2:type");
/* Fall through. */
end:
kfree(hdr6);
return success;
}
static bool test_next_function_subheaders(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *ip6_header;
struct frag_hdr *fragment_hdr;
struct ipv6_opt_hdr *hop_by_hop_hdr;
struct ipv6_opt_hdr *routing_hdr;
unsigned char *payload;
ip6_header = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTING_HDR_LEN + 4, NEXTHDR_FRAGMENT);
if (!ip6_header)
return false;
fragment_hdr = add_frag_hdr(ip6_header, sizeof(struct ipv6hdr), NEXTHDR_HOP);
hop_by_hop_hdr = add_opt_hdr(fragment_hdr, FRAG_HDR_LEN, NEXTHDR_ROUTING);
routing_hdr = add_routing_hdr(hop_by_hop_hdr, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(routing_hdr, ROUTING_HDR_LEN);
/* Test */
hdr_iterator_init(&iterator, ip6_header);
success &= assert_equals_ptr(fragment_hdr, iterator.data, "Frag hdr, data");
success &= assert_equals_u8(NEXTHDR_FRAGMENT, iterator.hdr_type, "Frag hdr, type");
if (!success)
goto end;
success &= assert_equals_int(HDR_ITERATOR_SUCCESS, hdr_iterator_next(&iterator), "Next 1");
success &= assert_equals_ptr(hop_by_hop_hdr, iterator.data, "Hop-by-hop hdr, data");
success &= assert_equals_u8(NEXTHDR_HOP, iterator.hdr_type, "Hop-by-hop hdr, type");
if (!success)
goto end;
success &= assert_equals_int(HDR_ITERATOR_SUCCESS, hdr_iterator_next(&iterator), "Next 2");
success &= assert_equals_ptr(routing_hdr, iterator.data, "Routing hdr, data");
success &= assert_equals_u8(NEXTHDR_ROUTING, iterator.hdr_type, "Routing hdr, type");
if (!success)
goto end;
success &= assert_equals_int(HDR_ITERATOR_SUCCESS, hdr_iterator_next(&iterator), "Next 3");
success &= assert_equals_ptr(payload, iterator.data, "Payload 1, data");
success &= assert_equals_u8(NEXTHDR_UDP, iterator.hdr_type, "Payload 1, type");
if (!success)
goto end;
success &= assert_equals_int(HDR_ITERATOR_END, hdr_iterator_next(&iterator), "Next 4");
success &= assert_equals_ptr(payload, iterator.data, "Payload 2, data");
success &= assert_equals_u8(NEXTHDR_UDP, iterator.hdr_type, "Payload 2, type");
/* Fall through. */
end:
kfree(ip6_header);
return success;
}
static bool test_next_unsupported(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *hdr6;
struct frag_hdr *hdr_frag;
struct ipv6_opt_hdr *hdr_esp;
struct ipv6_opt_hdr *hdr_route;
unsigned char *payload;
hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4,
NEXTHDR_FRAGMENT);
if (!hdr6)
return false;
hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_ESP);
hdr_esp = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, FRAG_HDR_LEN);
hdr_route = add_route_hdr(hdr_esp, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(hdr_route, ROUTE_HDR_LEN);
/* Test */
hdr_iterator_init(&iterator, hdr6);
success &= ASSERT_PTR(hdr_frag, iterator.data, "Frag:pointer");
success &= ASSERT_UINT(NEXTHDR_FRAGMENT, iterator.hdr_type,
"Frag:type");
if (!success)
goto end;
success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 1");
success &= ASSERT_PTR(hdr_esp, iterator.data, "ESP1:pointer");
success &= ASSERT_UINT(NEXTHDR_ESP, iterator.hdr_type, "ESP1:type");
if (!success)
goto end;
success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Next 2");
success &= ASSERT_PTR(hdr_esp, iterator.data, "ESP2:pointer");
success &= ASSERT_UINT(NEXTHDR_ESP, iterator.hdr_type, "ESP2:type");
/* Fall through. */
end:
kfree(hdr6);
return success;
}
static bool test_next_function_unsupported(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *ip6_header;
struct frag_hdr *fragment_hdr;
struct ipv6_opt_hdr *esp_hdr;
struct ipv6_opt_hdr *routing_hdr;
unsigned char *payload;
ip6_header = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTING_HDR_LEN + 4, NEXTHDR_FRAGMENT);
if (!ip6_header)
return false;
fragment_hdr = add_frag_hdr(ip6_header, sizeof(struct ipv6hdr), NEXTHDR_ESP);
esp_hdr = add_opt_hdr(fragment_hdr, FRAG_HDR_LEN, FRAG_HDR_LEN);
routing_hdr = add_routing_hdr(esp_hdr, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(routing_hdr, ROUTING_HDR_LEN);
/* Test */
hdr_iterator_init(&iterator, ip6_header);
success &= assert_equals_ptr(fragment_hdr, iterator.data, "Frag hdr, pointer");
success &= assert_equals_u8(NEXTHDR_FRAGMENT, iterator.hdr_type, "Frag hdr, type");
if (!success)
goto end;
success &= assert_equals_int(HDR_ITERATOR_SUCCESS, hdr_iterator_next(&iterator), "Next 1");
success &= assert_equals_ptr(esp_hdr, iterator.data, "ESP hdr, pointer");
success &= assert_equals_u8(NEXTHDR_ESP, iterator.hdr_type, "ESP hdr, type");
if (!success)
goto end;
success &= assert_equals_int(HDR_ITERATOR_UNSUPPORTED, hdr_iterator_next(&iterator), "Next 2");
success &= assert_equals_ptr(esp_hdr, iterator.data, "Still ESP header, pointer");
success &= assert_equals_u8(NEXTHDR_ESP, iterator.hdr_type, "Still ESP header, type");
/* Fall through. */
end:
kfree(ip6_header);
return success;
}
static bool test_find_subheaders(void)
{
bool success = true;
/* Init */
struct ipv6hdr *hdr6;
struct frag_hdr *hdr_frag;
struct ipv6_opt_hdr *hdr_hop;
struct ipv6_opt_hdr *hdr_route;
unsigned char *payload;
hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4,
NEXTHDR_FRAGMENT);
if (!hdr6)
return false;
hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_HOP);
hdr_hop = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, NEXTHDR_ROUTING);
hdr_route = add_route_hdr(hdr_hop, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(hdr_route, ROUTE_HDR_LEN);
/* Test */
success &= ASSERT_PTR(hdr_frag,
hdr_iterator_find(hdr6, NEXTHDR_FRAGMENT),
"Frag hdr");
success &= ASSERT_PTR(hdr_hop, hdr_iterator_find(hdr6, NEXTHDR_HOP),
"Hop-by-hop hdr");
success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_ESP),
"ESP hdr");
success &= ASSERT_PTR(hdr_route,
hdr_iterator_find(hdr6, NEXTHDR_ROUTING),
"Routing hdr");
success &= ASSERT_PTR(payload, hdr_iterator_find(hdr6, NEXTHDR_UDP),
"Payload");
/* End */
kfree(hdr6);
return success;
}
static bool test_find_unsupported(void)
{
bool success = true;
/* Init */
struct ipv6hdr *hdr6;
struct frag_hdr *hdr_frag;
struct ipv6_opt_hdr *hdr_esp;
struct ipv6_opt_hdr *hdr_route;
unsigned char *payload;
hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4,
NEXTHDR_FRAGMENT);
if (!hdr6)
return false;
hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_ESP);
hdr_esp = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, FRAG_HDR_LEN);
hdr_route = add_route_hdr(hdr_esp, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(hdr_route, ROUTE_HDR_LEN);
/* Test */
success &= ASSERT_PTR(hdr_frag,
hdr_iterator_find(hdr6, NEXTHDR_FRAGMENT),
"Frag hdr");
success &= ASSERT_PTR(hdr_esp, hdr_iterator_find(hdr6, NEXTHDR_ESP),
"ESP header");
/* The ESP header is in the way. */
success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_ROUTING),
"Routing header");
/* Same, but that isn't an extension header anyway. */
success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_UDP),
"Payload");
/* End */
kfree(hdr6);
return success;
}
static bool test_last_function_overflow(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *ip6_header;
struct frag_hdr *fragment_hdr;
struct ipv6_opt_hdr *hop_by_hop_hdr;
ip6_header = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN, NEXTHDR_FRAGMENT);
if (!ip6_header)
return false;
fragment_hdr = add_frag_hdr(ip6_header, sizeof(struct ipv6hdr), NEXTHDR_HOP);
hop_by_hop_hdr = add_opt_hdr(fragment_hdr, NEXTHDR_FRAGMENT, NEXTHDR_ROUTING);
/* Test */
hdr_iterator_init(&iterator, ip6_header);
success &= assert_equals_int(HDR_ITERATOR_OVERFLOW, hdr_iterator_last(&iterator), "Result");
/* End */
kfree(ip6_header);
return success;
}
static bool test_next_function_overflow(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *ip6_header;
struct frag_hdr *fragment_hdr;
struct ipv6_opt_hdr *hop_by_hop_hdr;
ip6_header = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN, NEXTHDR_FRAGMENT);
if (!ip6_header)
return false;
fragment_hdr = add_frag_hdr(ip6_header, sizeof(struct ipv6hdr), NEXTHDR_HOP);
hop_by_hop_hdr = add_opt_hdr(fragment_hdr, FRAG_HDR_LEN, NEXTHDR_ROUTING);
/* Test */
hdr_iterator_init(&iterator, ip6_header);
success &= assert_equals_ptr(fragment_hdr, iterator.data, "Frag hdr, data");
success &= assert_equals_u8(NEXTHDR_FRAGMENT, iterator.hdr_type, "Frag hdr, type");
if (!success)
goto end;
success &= assert_equals_int(HDR_ITERATOR_SUCCESS, hdr_iterator_next(&iterator), "Next 1");
success &= assert_equals_ptr(hop_by_hop_hdr, iterator.data, "Hop-by-hop hdr, data");
success &= assert_equals_u8(NEXTHDR_HOP, iterator.hdr_type, "Hop-by-hop hdr, type");
if (!success)
goto end;
success &= assert_equals_int(HDR_ITERATOR_OVERFLOW, hdr_iterator_next(&iterator), "Next 2");
/* Fall through. */
end:
kfree(ip6_header);
return success;
}
