static bool test_get_ext_function_no_subheaders(void)
{
bool success = true;
/* 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 */
success &= assert_equals_ptr(NULL, get_extension_header(ip6_header, NEXTHDR_FRAGMENT),
"Frag hdr");
success &= assert_equals_ptr(NULL, get_extension_header(ip6_header, NEXTHDR_HOP),
"Hop-by-hop hdr");
success &= assert_equals_ptr(NULL, get_extension_header(ip6_header, NEXTHDR_ESP),
"ESP hdr");
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_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_find_no_subheaders(void)
{
bool success = true;
/* Init */
struct ipv6hdr *hdr6;
unsigned char *payload;
hdr6 = kmalloc_packet(4, NEXTHDR_UDP);
if (!hdr6)
return false;
payload = add_payload(hdr6, HDR6_LEN);
/* Test */
success &= ASSERT_PTR(NULL, hdr_iterator_find(hdr6, NEXTHDR_FRAGMENT),
"Frag hdr");
success &= ASSERT_PTR(NULL, 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(hdr6 + 1, hdr_iterator_find(hdr6, NEXTHDR_UDP),
"Payload");
/* End */
kfree(hdr6);
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;
}
void add_addr(struct nftnl_rule *r, int offset,
void *data, void *mask, size_t len, uint32_t op)
{
add_payload(r, offset, len, NFT_PAYLOAD_NETWORK_HEADER);
add_bitwise(r, mask, len);
add_cmp_ptr(r, op, data, len);
}
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_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_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_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;
}
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_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);
hdr_iterator_last(&iterator);
success &= ASSERT_PTR(payload, iterator.data, "Last:data");
success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Last:type");
/* End */
kfree(hdr6);
return success;
}
static bool test_last_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_int(HDR_ITERATOR_END, hdr_iterator_last(&iterator), "Result");
success &= assert_equals_ptr(payload, iterator.data, "Last function, data");
success &= assert_equals_u8(NEXTHDR_UDP, iterator.hdr_type, "Last function, type");
/* End */
kfree(ip6_header);
return success;
}
void add_proto(struct nftnl_rule *r, int offset, size_t len,
uint8_t proto, uint32_t op)
{
add_payload(r, offset, len, NFT_PAYLOAD_NETWORK_HEADER);
add_cmp_u8(r, proto, op);
}
static void add_line(sdp_message_t *msg, int lineno, const SalStreamDescription *desc){
const char *mt=NULL;
const MSList *elem;
const char *addr;
const char *dir="sendrecv";
int port;
bool_t strip_well_known_rtpmaps;
switch (desc->type) {
case SalAudio:
mt="audio";
break;
case SalVideo:
mt="video";
break;
case SalOther:
mt=desc->typeother;
break;
}
if (desc->candidates[0].addr[0]!='\0'){
addr=desc->candidates[0].addr;
port=desc->candidates[0].port;
}else{
addr=desc->addr;
port=desc->port;
}
/*only add a c= line within the stream description if address are differents*/
if (strcmp(addr,sdp_message_c_addr_get(msg, -1, 0))!=0){
bool_t inet6;
if (strchr(addr,':')!=NULL){
inet6=TRUE;
}else inet6=FALSE;
sdp_message_c_connection_add (msg, lineno,
osip_strdup ("IN"), inet6 ? osip_strdup ("IP6") : osip_strdup ("IP4"),
osip_strdup (addr), NULL, NULL);
}
sdp_message_m_media_add (msg, osip_strdup (mt),
int_2char (port), NULL,
osip_strdup ("RTP/AVP"));
if (desc->bandwidth>0) sdp_message_b_bandwidth_add (msg, lineno, osip_strdup ("AS"),
int_2char(desc->bandwidth));
if (desc->ptime>0) sdp_message_a_attribute_add(msg,lineno,osip_strdup("ptime"),
int_2char(desc->ptime));
strip_well_known_rtpmaps=ms_list_size(desc->payloads)>5;
if (desc->payloads){
for(elem=desc->payloads;elem!=NULL;elem=elem->next){
add_payload(msg, lineno, (PayloadType*)elem->data,strip_well_known_rtpmaps);
}
}else{
/* to comply with SDP we cannot have an empty payload type number list */
/* as it happens only when mline is declined with a zero port, it does not matter to put whatever codec*/
sdp_message_m_payload_add (msg,lineno, int_2char (0));
}
switch(desc->dir){
case SalStreamSendRecv:
/*dir="sendrecv";*/
dir=NULL;
break;
case SalStreamRecvOnly:
dir="recvonly";
break;
case SalStreamSendOnly:
dir="sendonly";
break;
case SalStreamInactive:
dir="inactive";
break;
}
if (dir) sdp_message_a_attribute_add (msg, lineno, osip_strdup (dir),NULL);
}
