static bool test_no_subheaders(void) { // Init. struct ipv6hdr *ip6_header; unsigned char *payload; ip6_header = kmalloc(sizeof(struct ipv6hdr) + 4, GFP_ATOMIC); if (!ip6_header) { log_warning("Unable to allocate a test header."); return false; } ip6_header->nexthdr = NEXTHDR_UDP; payload = (unsigned char *) (ip6_header + 1); // Test next function. { struct hdr_iterator iterator = HDR_ITERATOR_INIT(ip6_header); ASSERT_EQUALS_PTR(ip6_header, iterator.data, "First header, data"); ASSERT_EQUALS(-1, iterator.hdr_type, "First header, hdr type"); hdr_iterator_next(&iterator); ASSERT_EQUALS_PTR(payload, iterator.data, "Payload 1st, data"); ASSERT_EQUALS(NEXTHDR_UDP, iterator.hdr_type, "Payload 1st, hdr type"); hdr_iterator_next(&iterator); ASSERT_EQUALS_PTR(payload, iterator.data, "Payload 2nd, data"); ASSERT_EQUALS(NEXTHDR_UDP, iterator.hdr_type, "Payload 2nd, hdr type"); hdr_iterator_next(&iterator); hdr_iterator_next(&iterator); hdr_iterator_next(&iterator); ASSERT_EQUALS_PTR(payload, iterator.data, "Payload 3rd, data"); ASSERT_EQUALS(NEXTHDR_UDP, iterator.hdr_type, "Payload 3rd, hdr type"); } // Test last function. { struct hdr_iterator iterator = HDR_ITERATOR_INIT(ip6_header); hdr_iterator_last(&iterator); ASSERT_EQUALS_PTR(payload, iterator.data, "Last function, data"); ASSERT_EQUALS(NEXTHDR_UDP, iterator.hdr_type, "Last function, hdr type"); } // Test get extension header function. { void *frag_hdr_computed = get_extension_header(ip6_header, NEXTHDR_FRAGMENT); void *hop_by_hop_hdr_computed = get_extension_header(ip6_header, NEXTHDR_HOP); void *udp_hdr_computed = get_extension_header(ip6_header, NEXTHDR_UDP); ASSERT_EQUALS_PTR(NULL, frag_hdr_computed, "Get function, frag hdr"); ASSERT_EQUALS_PTR(NULL, hop_by_hop_hdr_computed, "Get function, hop-by-hop hdr"); // Cause the UDP header is not an extension header. ASSERT_EQUALS_PTR(NULL, udp_hdr_computed, "Get function, payload"); } return true; }
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; }
enum hdr_iterator_result hdr_iterator_last(struct hdr_iterator *iterator) { enum hdr_iterator_result result; while ((result = hdr_iterator_next(iterator)) == HDR_ITERATOR_SUCCESS) /* Void on purpose. */; return result; }
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_next_function_no_subheaders(void) { bool success = true; struct hdr_iterator iterator; /* Init */ struct ipv6hdr *ip6_header; unsigned char *payload; ip6_header = kmalloc_packet(4, NEXTHDR_UDP); if (!ip6_header) return false; payload = add_payload(ip6_header, sizeof(struct ipv6hdr)); /* Test */ hdr_iterator_init(&iterator, ip6_header); 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), "Result 1"); success &= assert_equals_ptr(payload, iterator.data, "Payload 2, data"); success &= assert_equals_u8(NEXTHDR_UDP, iterator.hdr_type, "Payload 2, type"); if (!success) goto end; success &= assert_equals_int(HDR_ITERATOR_END, hdr_iterator_next(&iterator), "Result 2"); success &= assert_equals_int(HDR_ITERATOR_END, hdr_iterator_next(&iterator), "Result 3"); success &= assert_equals_int(HDR_ITERATOR_END, hdr_iterator_next(&iterator), "Result 4"); success &= assert_equals_ptr(payload, iterator.data, "Payload 3, data"); success &= assert_equals_u8(NEXTHDR_UDP, iterator.hdr_type, "Payload 3, type"); /* Fall through. */ end: kfree(ip6_header); return success; }
static bool test_next_no_subheaders(void) { bool success = true; struct hdr_iterator iterator; /* Init */ struct ipv6hdr *hdr6; unsigned char *payload; hdr6 = kmalloc_packet(4, NEXTHDR_UDP); if (!hdr6) return false; payload = add_payload(hdr6, HDR6_LEN); /* Test */ hdr_iterator_init(&iterator, hdr6); 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), "Result1"); success &= ASSERT_PTR(payload, iterator.data, "Payload2:data"); success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload2:type"); if (!success) goto end; success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Result2"); success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Result3"); success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Result4"); success &= ASSERT_PTR(payload, iterator.data, "Payload3:data"); success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload3:type"); /* Fall through. */ end: kfree(hdr6); return success; }
void *get_extension_header(struct ipv6hdr *ip6_hdr, __u8 hdr_id) { struct hdr_iterator iterator = HDR_ITERATOR_INIT(ip6_hdr); if (!is_extension_hdr(hdr_id)) return NULL; do { if (iterator.hdr_type == hdr_id) return iterator.data; } while (hdr_iterator_next(&iterator) == HDR_ITERATOR_SUCCESS); return NULL; }
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; }
static bool test_subheaders(void) { // Init. const __u16 HOP_BY_HOP_HDR_LEN = 32; const __u16 ROUTING_HDR_LEN = 40; 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(sizeof(struct ipv6hdr) + sizeof(struct frag_hdr) + HOP_BY_HOP_HDR_LEN + ROUTING_HDR_LEN + 4, // (payload.) GFP_ATOMIC); if (!ip6_header) { log_warning("Unable to allocate a test header."); return false; } ip6_header->nexthdr = NEXTHDR_FRAGMENT; fragment_hdr = (struct frag_hdr *) (ip6_header + 1); fragment_hdr->nexthdr = NEXTHDR_HOP; hop_by_hop_hdr = (struct ipv6_opt_hdr *) (fragment_hdr + 1); hop_by_hop_hdr->nexthdr = NEXTHDR_ROUTING; hop_by_hop_hdr->hdrlen = (HOP_BY_HOP_HDR_LEN / 8) - 1; routing_hdr = ((void *) hop_by_hop_hdr) + HOP_BY_HOP_HDR_LEN; routing_hdr->nexthdr = NEXTHDR_UDP; routing_hdr->hdrlen = (ROUTING_HDR_LEN / 8) - 1; payload = ((void *) routing_hdr) + ROUTING_HDR_LEN; // Test next function. { struct hdr_iterator next_iterator = HDR_ITERATOR_INIT(ip6_header); ASSERT_EQUALS_PTR(ip6_header, next_iterator.data, "First (main) header, data"); ASSERT_EQUALS(-1, next_iterator.hdr_type, "First (main) header, hdr type"); hdr_iterator_next(&next_iterator); ASSERT_EQUALS_PTR(fragment_hdr, next_iterator.data, "Second (frag) header, data"); ASSERT_EQUALS(NEXTHDR_FRAGMENT, next_iterator.hdr_type, "Second (frag) header, hdr type"); hdr_iterator_next(&next_iterator); ASSERT_EQUALS_PTR(hop_by_hop_hdr, next_iterator.data, "Third (hop-by-hop) header, data"); ASSERT_EQUALS(NEXTHDR_HOP, next_iterator.hdr_type, "Third (hop-by-hop) header, hdr type"); hdr_iterator_next(&next_iterator); ASSERT_EQUALS_PTR(routing_hdr, next_iterator.data, "Fourth (Routing) header, data"); ASSERT_EQUALS(NEXTHDR_ROUTING, next_iterator.hdr_type, "Fourth (Routing) header, hdr type"); hdr_iterator_next(&next_iterator); ASSERT_EQUALS_PTR(payload, next_iterator.data, "Payload 1st, data"); ASSERT_EQUALS(NEXTHDR_UDP, next_iterator.hdr_type, "Payload 1st, hdr type"); hdr_iterator_next(&next_iterator); ASSERT_EQUALS_PTR(payload, next_iterator.data, "Payload 2nd, data"); ASSERT_EQUALS(NEXTHDR_UDP, next_iterator.hdr_type, "Payload 2nd, hdr type"); } // Test last function. { struct hdr_iterator last_iterator = HDR_ITERATOR_INIT(ip6_header); hdr_iterator_init(&last_iterator, ip6_header); hdr_iterator_last(&last_iterator); ASSERT_EQUALS_PTR(payload, last_iterator.data, "Last function, data"); ASSERT_EQUALS(NEXTHDR_UDP, last_iterator.hdr_type, "Last function, hdr type"); } // Test get extension header function. { void *frag_hdr_computed = get_extension_header(ip6_header, NEXTHDR_FRAGMENT); void *hop_by_hop_hdr_computed = get_extension_header(ip6_header, NEXTHDR_HOP); void *udp_hdr_computed = get_extension_header(ip6_header, NEXTHDR_UDP); ASSERT_EQUALS_PTR(fragment_hdr, frag_hdr_computed, "Get function, frag hdr"); ASSERT_EQUALS_PTR(hop_by_hop_hdr, hop_by_hop_hdr_computed, "Get function, hop-by-hop hdr"); // Cause the UDP header is not an extension header. ASSERT_EQUALS_PTR(NULL, udp_hdr_computed, "Get function, payload"); } return true; }