From 473cb091df7e45baa38bacfb4c74178f3c11ec44 Mon Sep 17 00:00:00 2001
From: Michael Tuexen <tuexen@fh-muenster.de>
Date: Sun, 6 May 2018 11:14:22 +0200
Subject: [PATCH] Add _ prefix to names of chunk structures.
This avoids conflics with definitions on Solaris 10.4.
---
gtests/net/packetdrill/parser.y | 12 +-
gtests/net/packetdrill/run_packet.c | 372 +++++++++---------
gtests/net/packetdrill/sctp.h | 42 +-
gtests/net/packetdrill/sctp_chunk_to_string.c | 146 +++----
gtests/net/packetdrill/sctp_packet.c | 126 +++---
gtests/net/packetdrill/socket.h | 4 +-
6 files changed, 351 insertions(+), 351 deletions(-)
diff --git a/gtests/net/packetdrill/parser.y b/gtests/net/packetdrill/parser.y
index d7bd9c1c..739184eb 100644
--- a/gtests/net/packetdrill/parser.y
+++ b/gtests/net/packetdrill/parser.y
@@ -1690,7 +1690,7 @@ sctp_generic_chunk_spec
sctp_data_chunk_spec
: DATA '[' opt_data_flags ',' opt_len ',' opt_tsn ',' opt_sid ',' opt_ssn ',' opt_ppid ']' {
if (($5 != -1) &&
- (!is_valid_u16($5) || ($5 < sizeof(struct sctp_data_chunk)))) {
+ (!is_valid_u16($5) || ($5 < sizeof(struct _sctp_data_chunk)))) {
semantic_error("length value out of range");
}
$$ = sctp_data_chunk_new($3, $5, $7, $9, $11, $13);
@@ -1750,11 +1750,11 @@ sctp_error_chunk_spec
sctp_cookie_echo_chunk_spec
: COOKIE_ECHO '[' opt_flags ',' opt_len ',' opt_val ']' {
if (($5 != -1) &&
- (!is_valid_u16($5) || ($5 < sizeof(struct sctp_cookie_echo_chunk)))) {
+ (!is_valid_u16($5) || ($5 < sizeof(struct _sctp_cookie_echo_chunk)))) {
semantic_error("length value out of range");
}
if (($5 != -1) && ($7 != NULL) &&
- ($5 != sizeof(struct sctp_cookie_echo_chunk) + $7->nr_entries)) {
+ ($5 != sizeof(struct _sctp_cookie_echo_chunk) + $7->nr_entries)) {
semantic_error("length value incompatible with val");
}
if (($5 == -1) && ($7 != NULL)) {
@@ -1786,14 +1786,14 @@ sctp_shutdown_complete_chunk_spec
sctp_i_data_chunk_spec
: I_DATA '[' opt_i_data_flags ',' opt_len ',' opt_tsn ',' opt_sid ',' opt_mid ',' opt_ppid ']' {
if (($5 != -1) &&
- (!is_valid_u16($5) || ($5 < sizeof(struct sctp_i_data_chunk)))) {
+ (!is_valid_u16($5) || ($5 < sizeof(struct _sctp_i_data_chunk)))) {
semantic_error("length value out of range");
}
$$ = sctp_i_data_chunk_new($3, $5, $7, $9, 0, $11, $13, -1);
}
| I_DATA '[' opt_i_data_flags ',' opt_len ',' opt_tsn ',' opt_sid ',' opt_mid ',' opt_fsn ']' {
if (($5 != -1) &&
- (!is_valid_u16($5) || ($5 < sizeof(struct sctp_i_data_chunk)))) {
+ (!is_valid_u16($5) || ($5 < sizeof(struct _sctp_i_data_chunk)))) {
semantic_error("length value out of range");
}
$$ = sctp_i_data_chunk_new($3, $5, $7, $9, 0, $11, -1, $13);
@@ -1802,7 +1802,7 @@ sctp_i_data_chunk_spec
sctp_pad_chunk_spec
: PAD '[' opt_flags ',' opt_len ',' VAL '=' ELLIPSIS ']' {
if (($5 != -1) &&
- (!is_valid_u16($5) || ($5 < sizeof(struct sctp_pad_chunk)))) {
+ (!is_valid_u16($5) || ($5 < sizeof(struct _sctp_pad_chunk)))) {
semantic_error("length value out of range");
}
$$ = sctp_pad_chunk_new($3, $5, NULL);
diff --git a/gtests/net/packetdrill/run_packet.c b/gtests/net/packetdrill/run_packet.c
index 8d3e6ac0..549dab7d 100644
--- a/gtests/net/packetdrill/run_packet.c
+++ b/gtests/net/packetdrill/run_packet.c
@@ -281,9 +281,9 @@ static struct socket *handle_listen_for_script_packet(
if (packet->sctp != NULL) {
if (sctp_is_init_packet(packet)) {
if (packet->chunk_list != NULL) {
- struct sctp_init_chunk *init;
+ struct _sctp_init_chunk *init;
item = packet->chunk_list->first;
- init = (struct sctp_init_chunk *) item->chunk;
+ init = (struct _sctp_init_chunk *) item->chunk;
sctp_socket_set_initiate_tag(socket, ntohl(init->initiate_tag));
sctp_socket_set_initial_tsn(socket, ntohl(init->initial_tsn));
@@ -304,13 +304,13 @@ static struct socket *handle_listen_for_script_packet(
assert(found != false);
chunk_length = sctp_header.total_bytes - sizeof(struct sctp_common_header);
- if (chunk_length < sizeof(struct sctp_init_chunk)) {
+ if (chunk_length < sizeof(struct _sctp_init_chunk)) {
fprintf(stderr, "length of init chunk too short. you must specify the whole init chunk.");
return NULL;
}
u8 *sctp_chunk_start = (u8 *) (packet->sctp + 1);
- struct sctp_init_chunk *init = (struct sctp_init_chunk *) sctp_chunk_start;
+ struct _sctp_init_chunk *init = (struct _sctp_init_chunk *) sctp_chunk_start;
sctp_socket_set_initiate_tag(socket, ntohl(init->initiate_tag));
sctp_socket_set_initial_tsn(socket, ntohl(init->initial_tsn));
@@ -365,7 +365,7 @@ static struct socket *handle_connect_for_script_packet(
*/
struct config *config = state->config;
struct socket *socket = state->socket_under_test; /* shortcut */
- struct sctp_init_chunk *init;
+ struct _sctp_init_chunk *init;
struct sctp_chunk_list_item *item;
bool match;
@@ -380,7 +380,7 @@ static struct socket *handle_connect_for_script_packet(
item = packet->chunk_list->first;
if ((item != NULL) &&
(item->chunk->type == SCTP_INIT_CHUNK_TYPE)) {
- init = (struct sctp_init_chunk *)item->chunk;
+ init = (struct _sctp_init_chunk *)item->chunk;
match = true;
} else {
init = NULL;
@@ -445,7 +445,7 @@ static struct socket *find_connect_for_live_packet(
{
struct sctp_chunks_iterator iter;
struct sctp_chunk *chunk;
- struct sctp_init_chunk *init;
+ struct _sctp_init_chunk *init;
struct tuple tuple;
char *error;
@@ -497,7 +497,7 @@ static struct socket *find_connect_for_live_packet(
if ((error == NULL) &&
(chunk != NULL) &&
(chunk->type == SCTP_INIT_CHUNK_TYPE)) {
- init = (struct sctp_init_chunk *)chunk;
+ init = (struct _sctp_init_chunk *)chunk;
socket->live.local_initiate_tag = ntohl(init->initiate_tag);
socket->live.local_initial_tsn = ntohl(init->initial_tsn);
}
@@ -658,20 +658,20 @@ static int map_inbound_sctp_packet(
{
struct sctp_chunks_iterator iter;
struct sctp_chunk *chunk;
- struct sctp_data_chunk *data;
- struct sctp_init_chunk *init;
- struct sctp_init_ack_chunk *init_ack;
- struct sctp_sack_chunk *sack;
- struct sctp_nr_sack_chunk *nr_sack;
- struct sctp_abort_chunk *abort;
- struct sctp_shutdown_chunk *shutdown;
- struct sctp_ecne_chunk *ecne;
- struct sctp_cwr_chunk *cwr;
- struct sctp_shutdown_complete_chunk *shutdown_complete;
- struct sctp_i_data_chunk *i_data;
- struct sctp_reconfig_chunk *reconfig;
- struct sctp_forward_tsn_chunk *forward_tsn;
- struct sctp_i_forward_tsn_chunk *i_forward_tsn;
+ struct _sctp_data_chunk *data;
+ struct _sctp_init_chunk *init;
+ struct _sctp_init_ack_chunk *init_ack;
+ struct _sctp_sack_chunk *sack;
+ struct _sctp_nr_sack_chunk *nr_sack;
+ struct _sctp_abort_chunk *abort;
+ struct _sctp_shutdown_chunk *shutdown;
+ struct _sctp_ecne_chunk *ecne;
+ struct _sctp_cwr_chunk *cwr;
+ struct _sctp_shutdown_complete_chunk *shutdown_complete;
+ struct _sctp_i_data_chunk *i_data;
+ struct _sctp_reconfig_chunk *reconfig;
+ struct _sctp_forward_tsn_chunk *forward_tsn;
+ struct _sctp_i_forward_tsn_chunk *i_forward_tsn;
u32 local_diff, remote_diff;
u32 v_tag;
@@ -701,11 +701,11 @@ static int map_inbound_sctp_packet(
local_diff = socket->live.local_initial_tsn - socket->script.local_initial_tsn;
switch (chunk->type) {
case SCTP_DATA_CHUNK_TYPE:
- data = (struct sctp_data_chunk *)chunk;
+ data = (struct _sctp_data_chunk *)chunk;
data->tsn = htonl(ntohl(data->tsn) + remote_diff);
break;
case SCTP_INIT_CHUNK_TYPE:
- init = (struct sctp_init_chunk *)chunk;
+ init = (struct _sctp_init_chunk *)chunk;
init->initial_tsn = htonl(ntohl(init->initial_tsn) + remote_diff);
/* XXX: Does this work in all cases? */
if (ntohl(init->initiate_tag) == socket->script.local_initiate_tag) {
@@ -714,7 +714,7 @@ static int map_inbound_sctp_packet(
contains_init_chunk = true;
break;
case SCTP_INIT_ACK_CHUNK_TYPE:
- init_ack = (struct sctp_init_ack_chunk *)chunk;
+ init_ack = (struct _sctp_init_ack_chunk *)chunk;
init_ack->initial_tsn = htonl(ntohl(init_ack->initial_tsn) + remote_diff);
/* XXX: Does this work in all cases? */
if (ntohl(init_ack->initiate_tag) == socket->script.local_initiate_tag) {
@@ -722,21 +722,21 @@ static int map_inbound_sctp_packet(
}
break;
case SCTP_SACK_CHUNK_TYPE:
- sack = (struct sctp_sack_chunk *)chunk;
+ sack = (struct _sctp_sack_chunk *)chunk;
DEBUGP("Old SACK cum TSN %d\n", ntohl(sack->cum_tsn));
sack->cum_tsn = htonl(ntohl(sack->cum_tsn) + local_diff);
DEBUGP("New SACK cum TSN %d\n", ntohl(sack->cum_tsn));
nr_gap_blocks = ntohs(sack->nr_gap_blocks);
nr_dup_tsns = ntohs(sack->nr_dup_tsns);
- if (ntohs(sack->length) == sizeof(struct sctp_sack_chunk) + sizeof(union sctp_sack_block) * (nr_dup_tsns+nr_gap_blocks)) {
+ if (ntohs(sack->length) == sizeof(struct _sctp_sack_chunk) + sizeof(union sctp_sack_block) * (nr_dup_tsns+nr_gap_blocks)) {
for (i = 0; i < nr_dup_tsns; i++) {
sack->block[i + nr_gap_blocks].tsn = htonl(ntohl(sack->block[i + nr_gap_blocks].tsn) + local_diff);
}
}
break;
case SCTP_NR_SACK_CHUNK_TYPE:
- nr_sack = (struct sctp_nr_sack_chunk *)chunk;
+ nr_sack = (struct _sctp_nr_sack_chunk *)chunk;
DEBUGP("Old SACK cum TSN %d\n", ntohl(nr_sack->cum_tsn));
nr_sack->cum_tsn = htonl(ntohl(nr_sack->cum_tsn) + local_diff);
DEBUGP("New SACK cum TSN %d\n", ntohl(nr_sack->cum_tsn));
@@ -744,7 +744,7 @@ static int map_inbound_sctp_packet(
number_of_nr_gap_blocks = ntohs(nr_sack->nr_of_nr_gap_blocks);
nr_dup_tsns = ntohs(nr_sack->nr_dup_tsns);
- if (ntohs(nr_sack->length) == sizeof(struct sctp_nr_sack_chunk) + sizeof(union sctp_nr_sack_block) * (nr_dup_tsns+nr_gap_blocks)) {
+ if (ntohs(nr_sack->length) == sizeof(struct _sctp_nr_sack_chunk) + sizeof(union sctp_nr_sack_block) * (nr_dup_tsns+nr_gap_blocks)) {
for (i = 0; i < nr_dup_tsns; i++) {
u16 offset = nr_gap_blocks + number_of_nr_gap_blocks;
nr_sack->block[i + offset].tsn = htonl(ntohl(nr_sack->block[i + offset].tsn) + local_diff);
@@ -752,47 +752,47 @@ static int map_inbound_sctp_packet(
}
break;
case SCTP_ABORT_CHUNK_TYPE:
- abort = (struct sctp_abort_chunk *)chunk;
+ abort = (struct _sctp_abort_chunk *)chunk;
if (abort->flags & SCTP_ABORT_CHUNK_T_BIT) {
reflect_v_tag = true;
}
break;
case SCTP_SHUTDOWN_CHUNK_TYPE:
- shutdown = (struct sctp_shutdown_chunk *)chunk;
+ shutdown = (struct _sctp_shutdown_chunk *)chunk;
shutdown->cum_tsn = htonl(ntohl(shutdown->cum_tsn) + local_diff);
break;
case SCTP_ECNE_CHUNK_TYPE:
- ecne = (struct sctp_ecne_chunk *)chunk;
+ ecne = (struct _sctp_ecne_chunk *)chunk;
ecne->lowest_tsn = htonl(ntohl(ecne->lowest_tsn) + local_diff);
break;
case SCTP_CWR_CHUNK_TYPE:
- cwr = (struct sctp_cwr_chunk *)chunk;
+ cwr = (struct _sctp_cwr_chunk *)chunk;
cwr->lowest_tsn = htonl(ntohl(cwr->lowest_tsn) + local_diff);
break;
case SCTP_SHUTDOWN_COMPLETE_CHUNK_TYPE:
- shutdown_complete = (struct sctp_shutdown_complete_chunk *)chunk;
+ shutdown_complete = (struct _sctp_shutdown_complete_chunk *)chunk;
if (shutdown_complete->flags & SCTP_SHUTDOWN_COMPLETE_CHUNK_T_BIT) {
reflect_v_tag = true;
}
break;
case SCTP_I_DATA_CHUNK_TYPE:
- i_data = (struct sctp_i_data_chunk *)chunk;
+ i_data = (struct _sctp_i_data_chunk *)chunk;
i_data->tsn = htonl(ntohl(i_data->tsn) + remote_diff);
break;
case SCTP_FORWARD_TSN_CHUNK_TYPE:
- forward_tsn = (struct sctp_forward_tsn_chunk *) chunk;
+ forward_tsn = (struct _sctp_forward_tsn_chunk *) chunk;
forward_tsn->cum_tsn = htonl(ntohl(forward_tsn->cum_tsn) + remote_diff);
break;
case SCTP_I_FORWARD_TSN_CHUNK_TYPE:
- i_forward_tsn = (struct sctp_i_forward_tsn_chunk *) chunk;
+ i_forward_tsn = (struct _sctp_i_forward_tsn_chunk *) chunk;
i_forward_tsn->cum_tsn = htonl(ntohl(i_forward_tsn->cum_tsn) + remote_diff);
break;
case SCTP_RECONFIG_CHUNK_TYPE:
- reconfig = (struct sctp_reconfig_chunk *)chunk;
- if (htons(reconfig->length) >= sizeof(struct sctp_reconfig_chunk) + 4) {
+ reconfig = (struct _sctp_reconfig_chunk *)chunk;
+ if (htons(reconfig->length) >= sizeof(struct _sctp_reconfig_chunk) + 4) {
struct sctp_parameter *parameter;
struct sctp_parameters_iterator iter;
- int parameters_length = ntohs(reconfig->length) - sizeof(struct sctp_reconfig_chunk);
+ int parameters_length = ntohs(reconfig->length) - sizeof(struct _sctp_reconfig_chunk);
for (parameter = sctp_parameters_begin(reconfig->parameter, parameters_length,
&iter, error);
parameter != NULL;
@@ -1002,18 +1002,18 @@ static int map_outbound_live_sctp_packet(
{
struct sctp_chunks_iterator iter;
struct sctp_chunk *chunk;
- struct sctp_data_chunk *data;
- struct sctp_init_chunk *init;
- struct sctp_init_ack_chunk *init_ack;
- struct sctp_sack_chunk *sack;
- struct sctp_nr_sack_chunk *nr_sack;
- struct sctp_shutdown_chunk *shutdown;
- struct sctp_ecne_chunk *ecne;
- struct sctp_cwr_chunk *cwr;
- struct sctp_i_data_chunk *i_data;
- struct sctp_reconfig_chunk *reconfig;
- struct sctp_forward_tsn_chunk *forward_tsn;
- struct sctp_i_forward_tsn_chunk *i_forward_tsn;
+ struct _sctp_data_chunk *data;
+ struct _sctp_init_chunk *init;
+ struct _sctp_init_ack_chunk *init_ack;
+ struct _sctp_sack_chunk *sack;
+ struct _sctp_nr_sack_chunk *nr_sack;
+ struct _sctp_shutdown_chunk *shutdown;
+ struct _sctp_ecne_chunk *ecne;
+ struct _sctp_cwr_chunk *cwr;
+ struct _sctp_i_data_chunk *i_data;
+ struct _sctp_reconfig_chunk *reconfig;
+ struct _sctp_forward_tsn_chunk *forward_tsn;
+ struct _sctp_i_forward_tsn_chunk *i_forward_tsn;
u32 local_diff, remote_diff;
u16 nr_gap_blocks, nr_dup_tsns, number_of_nr_gap_blocks, i;
@@ -1033,11 +1033,11 @@ static int map_outbound_live_sctp_packet(
DEBUGP("Chunk type: 0x%02x\n", chunk->type);
switch (chunk->type) {
case SCTP_DATA_CHUNK_TYPE:
- data = (struct sctp_data_chunk *)chunk;
+ data = (struct _sctp_data_chunk *)chunk;
data->tsn = htonl(ntohl(data->tsn) + local_diff);
break;
case SCTP_INIT_CHUNK_TYPE:
- init = (struct sctp_init_chunk *)chunk;
+ init = (struct _sctp_init_chunk *)chunk;
init->initial_tsn = htonl(ntohl(init->initial_tsn) + local_diff);
/* XXX: Does this work in all cases? */
if (ntohl(init->initiate_tag) == socket->live.local_initiate_tag) {
@@ -1045,7 +1045,7 @@ static int map_outbound_live_sctp_packet(
}
break;
case SCTP_INIT_ACK_CHUNK_TYPE:
- init_ack = (struct sctp_init_ack_chunk *)chunk;
+ init_ack = (struct _sctp_init_ack_chunk *)chunk;
init_ack->initial_tsn = htonl(ntohl(init_ack->initial_tsn) + local_diff);
/* XXX: Does this work in all cases? */
if (ntohl(init_ack->initiate_tag) == socket->live.local_initiate_tag) {
@@ -1053,7 +1053,7 @@ static int map_outbound_live_sctp_packet(
}
break;
case SCTP_SACK_CHUNK_TYPE:
- sack = (struct sctp_sack_chunk *)chunk;
+ sack = (struct _sctp_sack_chunk *)chunk;
sack->cum_tsn = htonl(ntohl(sack->cum_tsn) + remote_diff);
nr_gap_blocks = ntohs(sack->nr_gap_blocks);
nr_dup_tsns = ntohs(sack->nr_dup_tsns);
@@ -1062,7 +1062,7 @@ static int map_outbound_live_sctp_packet(
}
break;
case SCTP_NR_SACK_CHUNK_TYPE:
- nr_sack = (struct sctp_nr_sack_chunk *)chunk;
+ nr_sack = (struct _sctp_nr_sack_chunk *)chunk;
nr_sack->cum_tsn = htonl(ntohl(nr_sack->cum_tsn) + remote_diff);
nr_gap_blocks = ntohs(nr_sack->nr_gap_blocks);
number_of_nr_gap_blocks = ntohs(nr_sack->nr_of_nr_gap_blocks);
@@ -1073,35 +1073,35 @@ static int map_outbound_live_sctp_packet(
}
break;
case SCTP_SHUTDOWN_CHUNK_TYPE:
- shutdown = (struct sctp_shutdown_chunk *)chunk;
+ shutdown = (struct _sctp_shutdown_chunk *)chunk;
shutdown->cum_tsn = htonl(ntohl(shutdown->cum_tsn) + remote_diff);
break;
case SCTP_ECNE_CHUNK_TYPE:
- ecne = (struct sctp_ecne_chunk *)chunk;
+ ecne = (struct _sctp_ecne_chunk *)chunk;
ecne->lowest_tsn = htonl(ntohl(ecne->lowest_tsn) + remote_diff);
break;
case SCTP_CWR_CHUNK_TYPE:
- cwr = (struct sctp_cwr_chunk *)chunk;
+ cwr = (struct _sctp_cwr_chunk *)chunk;
cwr->lowest_tsn = htonl(ntohl(cwr->lowest_tsn) + remote_diff);
break;
case SCTP_I_DATA_CHUNK_TYPE:
- i_data = (struct sctp_i_data_chunk *)chunk;
+ i_data = (struct _sctp_i_data_chunk *)chunk;
i_data->tsn = htonl(ntohl(i_data->tsn) + local_diff);
break;
case SCTP_FORWARD_TSN_CHUNK_TYPE:
- forward_tsn = (struct sctp_forward_tsn_chunk *) chunk;
+ forward_tsn = (struct _sctp_forward_tsn_chunk *) chunk;
forward_tsn->cum_tsn = htonl(ntohl(forward_tsn->cum_tsn) + local_diff);
break;
case SCTP_I_FORWARD_TSN_CHUNK_TYPE:
- i_forward_tsn = (struct sctp_i_forward_tsn_chunk *) chunk;
+ i_forward_tsn = (struct _sctp_i_forward_tsn_chunk *) chunk;
i_forward_tsn->cum_tsn = htonl(ntohl(i_forward_tsn->cum_tsn) + local_diff);
break;
case SCTP_RECONFIG_CHUNK_TYPE:
- reconfig = (struct sctp_reconfig_chunk *)chunk;
- if (reconfig->length > sizeof(struct sctp_reconfig_chunk)) {
+ reconfig = (struct _sctp_reconfig_chunk *)chunk;
+ if (reconfig->length > sizeof(struct _sctp_reconfig_chunk)) {
struct sctp_parameter *parameter;
struct sctp_parameters_iterator iter;
- int parameters_length = ntohs(reconfig->length) - sizeof(struct sctp_reconfig_chunk);
+ int parameters_length = ntohs(reconfig->length) - sizeof(struct _sctp_reconfig_chunk);
for (parameter = sctp_parameters_begin(reconfig->parameter,
parameters_length,
&iter, error);
@@ -1747,8 +1747,8 @@ static int verify_sctp_causes(struct sctp_chunk *chunk, u16 offset,
return STATUS_OK;
}
-static int verify_data_chunk(struct sctp_data_chunk *actual_chunk,
- struct sctp_data_chunk *script_chunk,
+static int verify_data_chunk(struct _sctp_data_chunk *actual_chunk,
+ struct _sctp_data_chunk *script_chunk,
u32 flags, char **error)
{
if (check_field("sctp_data_chunk_tsn",
@@ -1775,18 +1775,18 @@ static int verify_data_chunk(struct sctp_data_chunk *actual_chunk,
return STATUS_OK;
}
-static int verify_init_chunk(struct sctp_init_chunk *actual_chunk,
+static int verify_init_chunk(struct _sctp_init_chunk *actual_chunk,
struct sctp_chunk_list_item *script_chunk_item,
char **error)
{
- struct sctp_init_chunk *script_chunk;
+ struct _sctp_init_chunk *script_chunk;
u32 flags;
u16 parameters_length;
- script_chunk = (struct sctp_init_chunk *)script_chunk_item->chunk;
+ script_chunk = (struct _sctp_init_chunk *)script_chunk_item->chunk;
flags = script_chunk_item->flags;
- assert(ntohs(actual_chunk->length) >= sizeof(struct sctp_init_chunk));
- parameters_length = ntohs(actual_chunk->length) - sizeof(struct sctp_init_chunk);
+ assert(ntohs(actual_chunk->length) >= sizeof(struct _sctp_init_chunk));
+ parameters_length = ntohs(actual_chunk->length) - sizeof(struct _sctp_init_chunk);
if ((flags & FLAG_INIT_CHUNK_TAG_NOCHECK ? STATUS_OK :
check_field("sctp_init_chunk_tag",
ntohl(script_chunk->initiate_tag),
@@ -1822,18 +1822,18 @@ static int verify_init_chunk(struct sctp_init_chunk *actual_chunk,
return STATUS_OK;
}
-static int verify_init_ack_chunk(struct sctp_init_ack_chunk *actual_chunk,
+static int verify_init_ack_chunk(struct _sctp_init_ack_chunk *actual_chunk,
struct sctp_chunk_list_item *script_chunk_item,
char **error)
{
- struct sctp_init_ack_chunk *script_chunk;
+ struct _sctp_init_ack_chunk *script_chunk;
u32 flags;
u16 parameters_length;
- script_chunk = (struct sctp_init_ack_chunk *)script_chunk_item->chunk;
+ script_chunk = (struct _sctp_init_ack_chunk *)script_chunk_item->chunk;
flags = script_chunk_item->flags;
- assert(ntohs(actual_chunk->length) >= sizeof(struct sctp_init_ack_chunk));
- parameters_length = ntohs(actual_chunk->length) - sizeof(struct sctp_init_ack_chunk);
+ assert(ntohs(actual_chunk->length) >= sizeof(struct _sctp_init_ack_chunk));
+ parameters_length = ntohs(actual_chunk->length) - sizeof(struct _sctp_init_ack_chunk);
if ((flags & FLAG_INIT_ACK_CHUNK_TAG_NOCHECK ? STATUS_OK :
check_field("sctp_init_ack_chunk_tag",
ntohl(script_chunk->initiate_tag),
@@ -1869,8 +1869,8 @@ static int verify_init_ack_chunk(struct sctp_init_ack_chunk *actual_chunk,
return STATUS_OK;
}
-static int verify_sack_chunk(struct sctp_sack_chunk *actual_chunk,
- struct sctp_sack_chunk *script_chunk,
+static int verify_sack_chunk(struct _sctp_sack_chunk *actual_chunk,
+ struct _sctp_sack_chunk *script_chunk,
u32 flags, char **error)
{
u16 actual_nr_gap_blocks, actual_nr_dup_tsns;
@@ -1938,9 +1938,9 @@ static int verify_sack_chunk(struct sctp_sack_chunk *actual_chunk,
return STATUS_OK;
}
-static int verify_nr_sack_chunk(struct sctp_nr_sack_chunk *actual_chunk,
- struct sctp_nr_sack_chunk *script_chunk,
- u32 flags, char **error)
+static int verify_nr_sack_chunk(struct _sctp_nr_sack_chunk *actual_chunk,
+ struct _sctp_nr_sack_chunk *script_chunk,
+ u32 flags, char **error)
{
u16 actual_nr_gap_blocks, actual_nr_of_nr_gap_blocks, actual_nr_dup_tsns;
u16 script_nr_gap_blocks, script_nr_of_nr_gap_blocks, script_nr_dup_tsns;
@@ -2031,8 +2031,8 @@ static int verify_nr_sack_chunk(struct sctp_nr_sack_chunk *actual_chunk,
return STATUS_OK;
}
-static int verify_heartbeat_chunk(struct sctp_heartbeat_chunk *actual_chunk,
- struct sctp_heartbeat_chunk *script_chunk,
+static int verify_heartbeat_chunk(struct _sctp_heartbeat_chunk *actual_chunk,
+ struct _sctp_heartbeat_chunk *script_chunk,
u32 flags, char **error)
{
u16 length;
@@ -2042,10 +2042,10 @@ static int verify_heartbeat_chunk(struct sctp_heartbeat_chunk *actual_chunk,
} else {
assert((flags & FLAG_CHUNK_LENGTH_NOCHECK) == 0);
length = ntohs(actual_chunk->length);
- assert(length >= sizeof(struct sctp_heartbeat_chunk));
+ assert(length >= sizeof(struct _sctp_heartbeat_chunk));
if (memcmp(actual_chunk->value,
script_chunk->value,
- length - sizeof(struct sctp_heartbeat_chunk)) == 0) {
+ length - sizeof(struct _sctp_heartbeat_chunk)) == 0) {
return STATUS_OK;
} else {
asprintf(error, "live packet heartbeat info not as expected");
@@ -2054,8 +2054,8 @@ static int verify_heartbeat_chunk(struct sctp_heartbeat_chunk *actual_chunk,
}
}
-static int verify_heartbeat_ack_chunk(struct sctp_heartbeat_ack_chunk *actual_chunk,
- struct sctp_heartbeat_ack_chunk *script_chunk,
+static int verify_heartbeat_ack_chunk(struct _sctp_heartbeat_ack_chunk *actual_chunk,
+ struct _sctp_heartbeat_ack_chunk *script_chunk,
u32 flags, char **error)
{
u16 length;
@@ -2065,10 +2065,10 @@ static int verify_heartbeat_ack_chunk(struct sctp_heartbeat_ack_chunk *actual_ch
} else {
assert((flags & FLAG_CHUNK_LENGTH_NOCHECK) == 0);
length = ntohs(actual_chunk->length);
- assert(length >= sizeof(struct sctp_heartbeat_ack_chunk));
+ assert(length >= sizeof(struct _sctp_heartbeat_ack_chunk));
if (memcmp(actual_chunk->value,
script_chunk->value,
- length - sizeof(struct sctp_heartbeat_ack_chunk)) == 0) {
+ length - sizeof(struct _sctp_heartbeat_ack_chunk)) == 0) {
return STATUS_OK;
} else {
asprintf(error, "live packet heartbeat info not as expected");
@@ -2077,22 +2077,22 @@ static int verify_heartbeat_ack_chunk(struct sctp_heartbeat_ack_chunk *actual_ch
}
}
-static int verify_abort_chunk(struct sctp_abort_chunk *actual_chunk,
+static int verify_abort_chunk(struct _sctp_abort_chunk *actual_chunk,
struct sctp_chunk_list_item *script_chunk_item,
char **error)
{
u32 flags;
- assert(ntohs(actual_chunk->length) >= sizeof(struct sctp_abort_chunk));
+ assert(ntohs(actual_chunk->length) >= sizeof(struct _sctp_abort_chunk));
flags = script_chunk_item->flags;
return (flags & FLAG_ABORT_CHUNK_OPT_CAUSES_NOCHECK ? STATUS_OK :
verify_sctp_causes((struct sctp_chunk *)actual_chunk,
- sizeof(struct sctp_error_chunk),
+ sizeof(struct _sctp_error_chunk),
script_chunk_item, error));
}
-static int verify_shutdown_chunk(struct sctp_shutdown_chunk *actual_chunk,
- struct sctp_shutdown_chunk *script_chunk,
+static int verify_shutdown_chunk(struct _sctp_shutdown_chunk *actual_chunk,
+ struct _sctp_shutdown_chunk *script_chunk,
u32 flags, char **error)
{
return (flags & FLAG_SHUTDOWN_CHUNK_CUM_TSN_NOCHECK) ? STATUS_OK :
@@ -2102,30 +2102,30 @@ static int verify_shutdown_chunk(struct sctp_shutdown_chunk *actual_chunk,
error);
}
-static int verify_shutdown_ack_chunk(struct sctp_shutdown_ack_chunk *actual_chunk,
- struct sctp_shutdown_ack_chunk *script_chunk,
+static int verify_shutdown_ack_chunk(struct _sctp_shutdown_ack_chunk *actual_chunk,
+ struct _sctp_shutdown_ack_chunk *script_chunk,
u32 flags, char **error)
{
/* Nothing to check */
return STATUS_OK;
}
-static int verify_error_chunk(struct sctp_error_chunk *actual_chunk,
+static int verify_error_chunk(struct _sctp_error_chunk *actual_chunk,
struct sctp_chunk_list_item *script_chunk_item,
char **error)
{
u32 flags;
- assert(ntohs(actual_chunk->length) >= sizeof(struct sctp_error_chunk));
+ assert(ntohs(actual_chunk->length) >= sizeof(struct _sctp_error_chunk));
flags = script_chunk_item->flags;
return (flags & FLAG_ERROR_CHUNK_OPT_CAUSES_NOCHECK ? STATUS_OK :
verify_sctp_causes((struct sctp_chunk *)actual_chunk,
- sizeof(struct sctp_error_chunk),
+ sizeof(struct _sctp_error_chunk),
script_chunk_item, error));
}
-static int verify_cookie_echo_chunk(struct sctp_cookie_echo_chunk *actual_chunk,
- struct sctp_cookie_echo_chunk *script_chunk,
+static int verify_cookie_echo_chunk(struct _sctp_cookie_echo_chunk *actual_chunk,
+ struct _sctp_cookie_echo_chunk *script_chunk,
u32 flags, char **error)
{
u16 length;
@@ -2135,10 +2135,10 @@ static int verify_cookie_echo_chunk(struct sctp_cookie_echo_chunk *actual_chunk,
} else {
assert((flags & FLAG_CHUNK_LENGTH_NOCHECK) == 0);
length = ntohs(actual_chunk->length);
- assert(length >= sizeof(struct sctp_cookie_echo_chunk));
+ assert(length >= sizeof(struct _sctp_cookie_echo_chunk));
if (memcmp(actual_chunk->cookie,
script_chunk->cookie,
- length - sizeof(struct sctp_cookie_echo_chunk)) == 0) {
+ length - sizeof(struct _sctp_cookie_echo_chunk)) == 0) {
return STATUS_OK;
} else {
return STATUS_ERR;
@@ -2146,16 +2146,16 @@ static int verify_cookie_echo_chunk(struct sctp_cookie_echo_chunk *actual_chunk,
}
}
-static int verify_cookie_ack_chunk(struct sctp_cookie_ack_chunk *actual_chunk,
- struct sctp_cookie_ack_chunk *script_chunk,
+static int verify_cookie_ack_chunk(struct _sctp_cookie_ack_chunk *actual_chunk,
+ struct _sctp_cookie_ack_chunk *script_chunk,
u32 flags, char **error)
{
/* Nothing to check */
return STATUS_OK;
}
-static int verify_ecne_chunk(struct sctp_ecne_chunk *actual_chunk,
- struct sctp_ecne_chunk *script_chunk,
+static int verify_ecne_chunk(struct _sctp_ecne_chunk *actual_chunk,
+ struct _sctp_ecne_chunk *script_chunk,
u32 flags, char **error)
{
return (flags & FLAG_ECNE_CHUNK_LOWEST_TSN_NOCHECK ? STATUS_OK :
@@ -2165,8 +2165,8 @@ static int verify_ecne_chunk(struct sctp_ecne_chunk *actual_chunk,
error));
}
-static int verify_cwr_chunk(struct sctp_cwr_chunk *actual_chunk,
- struct sctp_cwr_chunk *script_chunk,
+static int verify_cwr_chunk(struct _sctp_cwr_chunk *actual_chunk,
+ struct _sctp_cwr_chunk *script_chunk,
u32 flags, char **error)
{
return (flags & FLAG_CWR_CHUNK_LOWEST_TSN_NOCHECK ? STATUS_OK :
@@ -2176,16 +2176,16 @@ static int verify_cwr_chunk(struct sctp_cwr_chunk *actual_chunk,
error));
}
-static int verify_shutdown_complete_chunk(struct sctp_shutdown_complete_chunk *actual_chunk,
- struct sctp_shutdown_complete_chunk *script_chunk,
+static int verify_shutdown_complete_chunk(struct _sctp_shutdown_complete_chunk *actual_chunk,
+ struct _sctp_shutdown_complete_chunk *script_chunk,
u32 flags, char **error)
{
/* Nothing to check */
return STATUS_OK;
}
-static int verify_i_data_chunk(struct sctp_i_data_chunk *actual_chunk,
- struct sctp_i_data_chunk *script_chunk,
+static int verify_i_data_chunk(struct _sctp_i_data_chunk *actual_chunk,
+ struct _sctp_i_data_chunk *script_chunk,
u32 flags, char **error)
{
if (check_field("sctp_i_data_chunk_tsn",
@@ -2222,23 +2222,23 @@ static int verify_i_data_chunk(struct sctp_i_data_chunk *actual_chunk,
return STATUS_OK;
}
-static int verify_pad_chunk(struct sctp_pad_chunk *actual_chunk,
- struct sctp_pad_chunk *script_chunk,
+static int verify_pad_chunk(struct _sctp_pad_chunk *actual_chunk,
+ struct _sctp_pad_chunk *script_chunk,
u32 flags, char **error)
{
/* Nothing to check */
return STATUS_OK;
}
-static int verify_reconfig_chunk(struct sctp_reconfig_chunk *actual_chunk,
+static int verify_reconfig_chunk(struct _sctp_reconfig_chunk *actual_chunk,
struct sctp_chunk_list_item *script_chunk_item,
u32 flags, char **error)
{
- struct sctp_init_chunk *script_chunk;
- int parameter_length;
+ struct _sctp_init_chunk *script_chunk;
+ int parameter_length;
- script_chunk = (struct sctp_init_chunk *)script_chunk_item->chunk;
- parameter_length = ntohs(actual_chunk->length) - sizeof(struct sctp_reconfig_chunk);
+ script_chunk = (struct _sctp_init_chunk *)script_chunk_item->chunk;
+ parameter_length = ntohs(actual_chunk->length) - sizeof(struct _sctp_reconfig_chunk);
if ((flags & FLAG_CHUNK_FLAGS_NOCHECK ? STATUS_OK :
check_field("sctp_reconfig_flags",
ntohl(script_chunk->flags),
@@ -2254,12 +2254,12 @@ static int verify_reconfig_chunk(struct sctp_reconfig_chunk *actual_chunk,
}
static u16 get_num_id_blocks (u16 packet_length) {
- return (packet_length - sizeof(struct sctp_forward_tsn_chunk)) / sizeof(struct sctp_stream_identifier_block);
+ return (packet_length - sizeof(struct _sctp_forward_tsn_chunk)) / sizeof(struct sctp_stream_identifier_block);
}
-static int verify_forward_tsn_chunk(struct sctp_forward_tsn_chunk *actual_chunk,
- struct sctp_forward_tsn_chunk *script_chunk,
- u32 flags, char **error) {
+static int verify_forward_tsn_chunk(struct _sctp_forward_tsn_chunk *actual_chunk,
+ struct _sctp_forward_tsn_chunk *script_chunk,
+ u32 flags, char **error) {
u16 actual_packet_length = ntohs(script_chunk->length);
u16 script_packet_length = ntohs(script_chunk->length);
u16 actual_nr_id_blocks = get_num_id_blocks(actual_packet_length);
@@ -2301,12 +2301,12 @@ static int verify_forward_tsn_chunk(struct sctp_forward_tsn_chunk *actual_chunk,
}
static u16 get_num_id_blocks_for_i_forward_tsn (u16 packet_length) {
- return (packet_length - sizeof(struct sctp_i_forward_tsn_chunk)) / sizeof(struct sctp_i_forward_tsn_identifier_block);
+ return (packet_length - sizeof(struct _sctp_i_forward_tsn_chunk)) / sizeof(struct sctp_i_forward_tsn_identifier_block);
}
-static int verify_i_forward_tsn_chunk(struct sctp_i_forward_tsn_chunk *actual_chunk,
- struct sctp_i_forward_tsn_chunk *script_chunk,
- u32 flags, char **error) {
+static int verify_i_forward_tsn_chunk(struct _sctp_i_forward_tsn_chunk *actual_chunk,
+ struct _sctp_i_forward_tsn_chunk *script_chunk,
+ u32 flags, char **error) {
u16 actual_packet_length = ntohs(script_chunk->length);
u16 script_packet_length = ntohs(script_chunk->length);
u16 actual_nr_id_blocks = get_num_id_blocks_for_i_forward_tsn(actual_packet_length);
@@ -2412,105 +2412,105 @@ static int verify_sctp(
}
switch (actual_chunk->type) {
case SCTP_DATA_CHUNK_TYPE:
- result = verify_data_chunk((struct sctp_data_chunk *)actual_chunk,
- (struct sctp_data_chunk *)script_chunk,
+ result = verify_data_chunk((struct _sctp_data_chunk *)actual_chunk,
+ (struct _sctp_data_chunk *)script_chunk,
flags, error);
break;
case SCTP_INIT_CHUNK_TYPE:
- result = verify_init_chunk((struct sctp_init_chunk *)actual_chunk,
+ result = verify_init_chunk((struct _sctp_init_chunk *)actual_chunk,
script_chunk_item, error);
break;
case SCTP_INIT_ACK_CHUNK_TYPE:
- result = verify_init_ack_chunk((struct sctp_init_ack_chunk *)actual_chunk,
+ result = verify_init_ack_chunk((struct _sctp_init_ack_chunk *)actual_chunk,
script_chunk_item, error);
break;
case SCTP_SACK_CHUNK_TYPE:
- result = verify_sack_chunk((struct sctp_sack_chunk *)actual_chunk,
- (struct sctp_sack_chunk *)script_chunk,
+ result = verify_sack_chunk((struct _sctp_sack_chunk *)actual_chunk,
+ (struct _sctp_sack_chunk *)script_chunk,
flags, error);
break;
case SCTP_NR_SACK_CHUNK_TYPE:
- result = verify_nr_sack_chunk((struct sctp_nr_sack_chunk *)actual_chunk,
- (struct sctp_nr_sack_chunk *)script_chunk,
- flags, error);
+ result = verify_nr_sack_chunk((struct _sctp_nr_sack_chunk *)actual_chunk,
+ (struct _sctp_nr_sack_chunk *)script_chunk,
+ flags, error);
break;
case SCTP_HEARTBEAT_CHUNK_TYPE:
- result = verify_heartbeat_chunk((struct sctp_heartbeat_chunk *)actual_chunk,
- (struct sctp_heartbeat_chunk *)script_chunk,
+ result = verify_heartbeat_chunk((struct _sctp_heartbeat_chunk *)actual_chunk,
+ (struct _sctp_heartbeat_chunk *)script_chunk,
flags, error);
break;
case SCTP_HEARTBEAT_ACK_CHUNK_TYPE:
- result = verify_heartbeat_ack_chunk((struct sctp_heartbeat_ack_chunk *)actual_chunk,
- (struct sctp_heartbeat_ack_chunk *)script_chunk,
+ result = verify_heartbeat_ack_chunk((struct _sctp_heartbeat_ack_chunk *)actual_chunk,
+ (struct _sctp_heartbeat_ack_chunk *)script_chunk,
flags, error);
break;
case SCTP_ABORT_CHUNK_TYPE:
- result = verify_abort_chunk((struct sctp_abort_chunk *)actual_chunk,
+ result = verify_abort_chunk((struct _sctp_abort_chunk *)actual_chunk,
script_chunk_item, error);
break;
case SCTP_SHUTDOWN_CHUNK_TYPE:
- result = verify_shutdown_chunk((struct sctp_shutdown_chunk *)actual_chunk,
- (struct sctp_shutdown_chunk *)script_chunk,
+ result = verify_shutdown_chunk((struct _sctp_shutdown_chunk *)actual_chunk,
+ (struct _sctp_shutdown_chunk *)script_chunk,
flags, error);
break;
case SCTP_SHUTDOWN_ACK_CHUNK_TYPE:
- result = verify_shutdown_ack_chunk((struct sctp_shutdown_ack_chunk *)actual_chunk,
- (struct sctp_shutdown_ack_chunk *)script_chunk,
+ result = verify_shutdown_ack_chunk((struct _sctp_shutdown_ack_chunk *)actual_chunk,
+ (struct _sctp_shutdown_ack_chunk *)script_chunk,
flags, error);
break;
case SCTP_ERROR_CHUNK_TYPE:
- result = verify_error_chunk((struct sctp_error_chunk *)actual_chunk,
+ result = verify_error_chunk((struct _sctp_error_chunk *)actual_chunk,
script_chunk_item, error);
break;
case SCTP_COOKIE_ECHO_CHUNK_TYPE:
- result = verify_cookie_echo_chunk((struct sctp_cookie_echo_chunk *)actual_chunk,
- (struct sctp_cookie_echo_chunk *)script_chunk,
+ result = verify_cookie_echo_chunk((struct _sctp_cookie_echo_chunk *)actual_chunk,
+ (struct _sctp_cookie_echo_chunk *)script_chunk,
flags, error);
break;
case SCTP_COOKIE_ACK_CHUNK_TYPE:
- result = verify_cookie_ack_chunk((struct sctp_cookie_ack_chunk *)actual_chunk,
- (struct sctp_cookie_ack_chunk *)script_chunk,
+ result = verify_cookie_ack_chunk((struct _sctp_cookie_ack_chunk *)actual_chunk,
+ (struct _sctp_cookie_ack_chunk *)script_chunk,
flags, error);
break;
case SCTP_ECNE_CHUNK_TYPE:
- result = verify_ecne_chunk((struct sctp_ecne_chunk *)actual_chunk,
- (struct sctp_ecne_chunk *)script_chunk,
+ result = verify_ecne_chunk((struct _sctp_ecne_chunk *)actual_chunk,
+ (struct _sctp_ecne_chunk *)script_chunk,
flags, error);
break;
case SCTP_CWR_CHUNK_TYPE:
- result = verify_cwr_chunk((struct sctp_cwr_chunk *)actual_chunk,
- (struct sctp_cwr_chunk *)script_chunk,
+ result = verify_cwr_chunk((struct _sctp_cwr_chunk *)actual_chunk,
+ (struct _sctp_cwr_chunk *)script_chunk,
flags, error);
break;
case SCTP_SHUTDOWN_COMPLETE_CHUNK_TYPE:
- result = verify_shutdown_complete_chunk((struct sctp_shutdown_complete_chunk *)actual_chunk,
- (struct sctp_shutdown_complete_chunk *)script_chunk,
+ result = verify_shutdown_complete_chunk((struct _sctp_shutdown_complete_chunk *)actual_chunk,
+ (struct _sctp_shutdown_complete_chunk *)script_chunk,
flags, error);
break;
case SCTP_I_DATA_CHUNK_TYPE:
- result = verify_i_data_chunk((struct sctp_i_data_chunk *)actual_chunk,
- (struct sctp_i_data_chunk *)script_chunk,
+ result = verify_i_data_chunk((struct _sctp_i_data_chunk *)actual_chunk,
+ (struct _sctp_i_data_chunk *)script_chunk,
flags, error);
break;
case SCTP_PAD_CHUNK_TYPE:
- result = verify_pad_chunk((struct sctp_pad_chunk *)actual_chunk,
- (struct sctp_pad_chunk *)script_chunk,
+ result = verify_pad_chunk((struct _sctp_pad_chunk *)actual_chunk,
+ (struct _sctp_pad_chunk *)script_chunk,
flags, error);
break;
case SCTP_RECONFIG_CHUNK_TYPE:
- result = verify_reconfig_chunk((struct sctp_reconfig_chunk *)actual_chunk,
+ result = verify_reconfig_chunk((struct _sctp_reconfig_chunk *)actual_chunk,
script_chunk_item,
flags, error);
break;
case SCTP_FORWARD_TSN_CHUNK_TYPE:
- result = verify_forward_tsn_chunk((struct sctp_forward_tsn_chunk *)actual_chunk,
- (struct sctp_forward_tsn_chunk *)script_chunk,
- flags, error);
+ result = verify_forward_tsn_chunk((struct _sctp_forward_tsn_chunk *)actual_chunk,
+ (struct _sctp_forward_tsn_chunk *)script_chunk,
+ flags, error);
break;
case SCTP_I_FORWARD_TSN_CHUNK_TYPE:
- result = verify_i_forward_tsn_chunk((struct sctp_i_forward_tsn_chunk *)actual_chunk,
- (struct sctp_i_forward_tsn_chunk *)script_chunk,
- flags, error);
+ result = verify_i_forward_tsn_chunk((struct _sctp_i_forward_tsn_chunk *)actual_chunk,
+ (struct _sctp_i_forward_tsn_chunk *)script_chunk,
+ flags, error);
break;
default:
result = STATUS_ERR;
@@ -3044,10 +3044,10 @@ static int do_outbound_script_packet(
struct sctp_chunks_iterator chunk_iter;
struct sctp_parameters_iterator param_iter;
struct sctp_chunk *chunk;
- struct sctp_init_ack_chunk *init_ack;
- struct sctp_cookie_echo_chunk *cookie_echo;
- struct sctp_heartbeat_chunk *heartbeat;
- struct sctp_heartbeat_ack_chunk *heartbeat_ack;
+ struct _sctp_init_ack_chunk *init_ack;
+ struct _sctp_cookie_echo_chunk *cookie_echo;
+ struct _sctp_heartbeat_chunk *heartbeat;
+ struct _sctp_heartbeat_ack_chunk *heartbeat_ack;
struct sctp_parameter *parameter;
struct sctp_state_cookie_parameter *state_cookie;
int result = STATUS_ERR; /* return value */
@@ -3073,7 +3073,7 @@ static int do_outbound_script_packet(
item = packet->chunk_list->first;
if ((item != NULL) &&
(item->chunk->type == SCTP_INIT_ACK_CHUNK_TYPE)) {
- init_ack = (struct sctp_init_ack_chunk *)item->chunk;
+ init_ack = (struct _sctp_init_ack_chunk *)item->chunk;
socket->script.local_initiate_tag = ntohl(init_ack->initiate_tag);
socket->script.local_initial_tsn = ntohl(init_ack->initial_tsn);
DEBUGP("INIT_ACK: script.local_initiate_tag: %u\n",
@@ -3109,12 +3109,12 @@ static int do_outbound_script_packet(
if ((socket->state == SOCKET_PASSIVE_PACKET_RECEIVED) &&
(chunk->type == SCTP_INIT_ACK_CHUNK_TYPE)) {
chunk_length = ntohs(chunk->length);
- if (chunk_length < sizeof(struct sctp_init_ack_chunk)) {
+ if (chunk_length < sizeof(struct _sctp_init_ack_chunk)) {
asprintf(error, "INIT chunk too short (length=%u)", chunk_length);
goto out;
}
- parameters_length = chunk_length - sizeof(struct sctp_init_chunk);
- init_ack = (struct sctp_init_ack_chunk *)chunk;
+ parameters_length = chunk_length - sizeof(struct _sctp_init_chunk);
+ init_ack = (struct _sctp_init_ack_chunk *)chunk;
for (parameter = sctp_parameters_begin(init_ack->parameter,
parameters_length,
@@ -3138,8 +3138,8 @@ static int do_outbound_script_packet(
if (padding_length > 0) {
padding_length = 4 - padding_length;
}
- chunk_length = sizeof(struct sctp_cookie_echo_chunk) + cookie_length;
- cookie_echo = (struct sctp_cookie_echo_chunk *)malloc(chunk_length + padding_length);
+ chunk_length = sizeof(struct _sctp_cookie_echo_chunk) + cookie_length;
+ cookie_echo = (struct _sctp_cookie_echo_chunk *)malloc(chunk_length + padding_length);
cookie_echo->type = SCTP_COOKIE_ECHO_CHUNK_TYPE;
cookie_echo->flags = 0;
cookie_echo->length = htons(chunk_length);
@@ -3170,18 +3170,18 @@ static int do_outbound_script_packet(
socket->live.local_initial_tsn);
}
if (chunk->type == SCTP_HEARTBEAT_CHUNK_TYPE) {
- heartbeat = (struct sctp_heartbeat_chunk *)chunk;
+ heartbeat = (struct _sctp_heartbeat_chunk *)chunk;
chunk_length = ntohs(heartbeat->length);
- if (chunk_length < sizeof(struct sctp_heartbeat_chunk)) {
+ if (chunk_length < sizeof(struct _sctp_heartbeat_chunk)) {
asprintf(error, "HEARTBEAT chunk too short (length=%u)", chunk_length);
goto out;
}
- value_length = chunk_length - sizeof(struct sctp_heartbeat_chunk);
+ value_length = chunk_length - sizeof(struct _sctp_heartbeat_chunk);
padding_length = chunk_length % 4;
if (padding_length > 0) {
padding_length = 4 - padding_length;
}
- heartbeat_ack = (struct sctp_heartbeat_ack_chunk *)malloc(chunk_length + padding_length);
+ heartbeat_ack = (struct _sctp_heartbeat_ack_chunk *)malloc(chunk_length + padding_length);
heartbeat_ack->type = SCTP_HEARTBEAT_ACK_CHUNK_TYPE;
heartbeat_ack->flags = 0;
heartbeat_ack->length = htons(chunk_length);
@@ -3260,7 +3260,7 @@ static int do_inbound_script_packet(
struct state *state, struct packet *packet,
struct socket *socket, char **error)
{
- struct sctp_init_ack_chunk *init_ack;
+ struct _sctp_init_ack_chunk *init_ack;
struct sctp_chunk_list_item *item;
int result = STATUS_ERR; /* return value */
u16 offset = 0, temp_offset;
@@ -3288,7 +3288,7 @@ static int do_inbound_script_packet(
switch (item->chunk->type) {
case SCTP_INIT_ACK_CHUNK_TYPE:
if (socket->state == SOCKET_ACTIVE_INIT_SENT) {
- init_ack = (struct sctp_init_ack_chunk *)item->chunk;
+ init_ack = (struct _sctp_init_ack_chunk *)item->chunk;
DEBUGP("Moving socket in SOCKET_ACTIVE_INIT_ACK_RECEIVED\n");
socket->state = SOCKET_ACTIVE_INIT_ACK_RECEIVED;
socket->script.remote_initiate_tag = ntohl(init_ack->initiate_tag);
diff --git a/gtests/net/packetdrill/sctp.h b/gtests/net/packetdrill/sctp.h
index d9bf706e..2cffd95a 100644
--- a/gtests/net/packetdrill/sctp.h
+++ b/gtests/net/packetdrill/sctp.h
@@ -77,7 +77,7 @@ struct sctp_chunk {
#define SCTP_DATA_CHUNK_B_BIT 0x02
#define SCTP_DATA_CHUNK_E_BIT 0x01
-struct sctp_data_chunk {
+struct _sctp_data_chunk {
__u8 type;
__u8 flags;
__be16 length;
@@ -90,7 +90,7 @@ struct sctp_data_chunk {
#define SCTP_INIT_CHUNK_PARAMETER_OFFSET 20
-struct sctp_init_chunk {
+struct _sctp_init_chunk {
__u8 type;
__u8 flags;
__be16 length;
@@ -102,7 +102,7 @@ struct sctp_init_chunk {
__u8 parameter[];
} __packed;
-struct sctp_init_ack_chunk {
+struct _sctp_init_ack_chunk {
__u8 type;
__u8 flags;
__be16 length;
@@ -122,7 +122,7 @@ union sctp_sack_block {
u32 tsn;
} __packed;
-struct sctp_sack_chunk {
+struct _sctp_sack_chunk {
__u8 type;
__u8 flags;
__be16 length;
@@ -145,7 +145,7 @@ union sctp_nr_sack_block {
u32 tsn;
} __packed;
-struct sctp_nr_sack_chunk {
+struct _sctp_nr_sack_chunk {
__u8 type;
__u8 flags;
__be16 length;
@@ -158,14 +158,14 @@ struct sctp_nr_sack_chunk {
union sctp_nr_sack_block block[];
} __packed;
-struct sctp_heartbeat_chunk {
+struct _sctp_heartbeat_chunk {
__u8 type;
__u8 flags;
__be16 length;
__u8 value[];
} __packed;
-struct sctp_heartbeat_ack_chunk {
+struct _sctp_heartbeat_ack_chunk {
__u8 type;
__u8 flags;
__be16 length;
@@ -175,21 +175,21 @@ struct sctp_heartbeat_ack_chunk {
#define SCTP_ABORT_CHUNK_T_BIT 0x01
#define SCTP_ABORT_CHUNK_CAUSE_OFFSET 4
-struct sctp_abort_chunk {
+struct _sctp_abort_chunk {
__u8 type;
__u8 flags;
__be16 length;
__u8 cause[];
} __packed;
-struct sctp_shutdown_chunk {
+struct _sctp_shutdown_chunk {
__u8 type;
__u8 flags;
__be16 length;
__be32 cum_tsn;
} __packed;
-struct sctp_shutdown_ack_chunk {
+struct _sctp_shutdown_ack_chunk {
__u8 type;
__u8 flags;
__be16 length;
@@ -197,34 +197,34 @@ struct sctp_shutdown_ack_chunk {
#define SCTP_ERROR_CHUNK_CAUSE_OFFSET 4
-struct sctp_error_chunk {
+struct _sctp_error_chunk {
__u8 type;
__u8 flags;
__be16 length;
__u8 cause[];
} __packed;
-struct sctp_cookie_echo_chunk {
+struct _sctp_cookie_echo_chunk {
__u8 type;
__u8 flags;
__be16 length;
__u8 cookie[];
} __packed;
-struct sctp_cookie_ack_chunk {
+struct _sctp_cookie_ack_chunk {
__u8 type;
__u8 flags;
__be16 length;
} __packed;
-struct sctp_ecne_chunk {
+struct _sctp_ecne_chunk {
__u8 type;
__u8 flags;
__be16 length;
__be32 lowest_tsn;
} __packed;
-struct sctp_cwr_chunk {
+struct _sctp_cwr_chunk {
__u8 type;
__u8 flags;
__be16 length;
@@ -233,7 +233,7 @@ struct sctp_cwr_chunk {
#define SCTP_SHUTDOWN_COMPLETE_CHUNK_T_BIT 0x01
-struct sctp_shutdown_complete_chunk {
+struct _sctp_shutdown_complete_chunk {
__u8 type;
__u8 flags;
__be16 length;
@@ -244,7 +244,7 @@ struct sctp_shutdown_complete_chunk {
#define SCTP_I_DATA_CHUNK_B_BIT 0x02
#define SCTP_I_DATA_CHUNK_E_BIT 0x01
-struct sctp_i_data_chunk {
+struct _sctp_i_data_chunk {
__u8 type;
__u8 flags;
__be16 length;
@@ -259,14 +259,14 @@ struct sctp_i_data_chunk {
__u8 data[];
} __packed;
-struct sctp_pad_chunk {
+struct _sctp_pad_chunk {
__u8 type;
__u8 flags;
__be16 length;
__u8 padding_data[];
} __packed;
-struct sctp_reconfig_chunk {
+struct _sctp_reconfig_chunk {
__u8 type;
__u8 flags;
__be16 length;
@@ -278,7 +278,7 @@ struct sctp_stream_identifier_block {
__u16 stream_sequence;
} __packed;
-struct sctp_forward_tsn_chunk {
+struct _sctp_forward_tsn_chunk {
__u8 type;
__u8 flags;
__be16 length;
@@ -292,7 +292,7 @@ struct sctp_i_forward_tsn_identifier_block {
__u32 message_identifier;
};
-struct sctp_i_forward_tsn_chunk {
+struct _sctp_i_forward_tsn_chunk {
__u8 type;
__u8 flags;
__be16 length;
diff --git a/gtests/net/packetdrill/sctp_chunk_to_string.c b/gtests/net/packetdrill/sctp_chunk_to_string.c
index fa809a80..b47a55b6 100644
--- a/gtests/net/packetdrill/sctp_chunk_to_string.c
+++ b/gtests/net/packetdrill/sctp_chunk_to_string.c
@@ -1131,7 +1131,7 @@ static int sctp_cause_to_string(FILE *s, struct sctp_cause *cause, char **error)
}
static int sctp_data_chunk_to_string(FILE *s,
- struct sctp_data_chunk *chunk,
+ struct _sctp_data_chunk *chunk,
char **error)
{
u16 length;
@@ -1139,7 +1139,7 @@ static int sctp_data_chunk_to_string(FILE *s,
flags = chunk->flags;
length = ntohs(chunk->length);
- if (length < sizeof(struct sctp_data_chunk)) {
+ if (length < sizeof(struct _sctp_data_chunk)) {
asprintf(error, "DATA chunk too short (length=%u)", length);
return STATUS_ERR;
}
@@ -1170,7 +1170,7 @@ static int sctp_data_chunk_to_string(FILE *s,
}
static int sctp_init_chunk_to_string(FILE *s,
- struct sctp_init_chunk *chunk,
+ struct _sctp_init_chunk *chunk,
char **error)
{
struct sctp_parameters_iterator iter;
@@ -1180,11 +1180,11 @@ static int sctp_init_chunk_to_string(FILE *s,
assert(*error == NULL);
length = ntohs(chunk->length);
- if (length < sizeof(struct sctp_init_chunk)) {
+ if (length < sizeof(struct _sctp_init_chunk)) {
asprintf(error, "INIT chunk too short (length=%u)", length);
return STATUS_ERR;
}
- parameters_length = length - sizeof(struct sctp_init_chunk);
+ parameters_length = length - sizeof(struct _sctp_init_chunk);
fputs("INIT[", s);
fprintf(s, "flgs=0x%02x, ", chunk->flags);
fprintf(s, "tag=%u, ", ntohl(chunk->initiate_tag));
@@ -1215,7 +1215,7 @@ static int sctp_init_chunk_to_string(FILE *s,
}
static int sctp_init_ack_chunk_to_string(FILE *s,
- struct sctp_init_ack_chunk *chunk,
+ struct _sctp_init_ack_chunk *chunk,
char **error)
{
struct sctp_parameters_iterator iter;
@@ -1225,11 +1225,11 @@ static int sctp_init_ack_chunk_to_string(FILE *s,
assert(*error == NULL);
length = ntohs(chunk->length);
- if (length < sizeof(struct sctp_init_ack_chunk)) {
+ if (length < sizeof(struct _sctp_init_ack_chunk)) {
asprintf(error, "INIT_ACK chunk too short (length=%u)", length);
return STATUS_ERR;
}
- parameters_length = length - sizeof(struct sctp_init_ack_chunk);
+ parameters_length = length - sizeof(struct _sctp_init_ack_chunk);
fputs("INIT_ACK[", s);
fprintf(s, "flgs=0x%02x, ", chunk->flags);
fprintf(s, "tag=%u, ", ntohl(chunk->initiate_tag));
@@ -1260,7 +1260,7 @@ static int sctp_init_ack_chunk_to_string(FILE *s,
}
static int sctp_sack_chunk_to_string(FILE *s,
- struct sctp_sack_chunk *chunk,
+ struct _sctp_sack_chunk *chunk,
char **error)
{
u16 length;
@@ -1268,13 +1268,13 @@ static int sctp_sack_chunk_to_string(FILE *s,
u16 i;
length = ntohs(chunk->length);
- if (length < sizeof(struct sctp_sack_chunk)) {
+ if (length < sizeof(struct _sctp_sack_chunk)) {
asprintf(error, "SACK chunk too short (length=%u)", length);
return STATUS_ERR;
}
nr_gaps = ntohs(chunk->nr_gap_blocks);
nr_dups = ntohs(chunk->nr_dup_tsns);
- if (length != sizeof(struct sctp_sack_chunk) +
+ if (length != sizeof(struct _sctp_sack_chunk) +
(nr_gaps + nr_dups) * sizeof(u32)) {
asprintf(error, "SACK chunk length inconsistent");
return STATUS_ERR;
@@ -1299,7 +1299,7 @@ static int sctp_sack_chunk_to_string(FILE *s,
}
static int sctp_nr_sack_chunk_to_string(FILE *s,
- struct sctp_nr_sack_chunk *chunk,
+ struct _sctp_nr_sack_chunk *chunk,
char **error)
{
u16 length;
@@ -1307,14 +1307,14 @@ static int sctp_nr_sack_chunk_to_string(FILE *s,
u16 i;
length = ntohs(chunk->length);
- if (length < sizeof(struct sctp_nr_sack_chunk)) {
+ if (length < sizeof(struct _sctp_nr_sack_chunk)) {
asprintf(error, "NR-SACK chunk too short (length=%u)", length);
return STATUS_ERR;
}
nr_gaps = ntohs(chunk->nr_gap_blocks);
nr_of_nr_gaps = ntohs(chunk->nr_of_nr_gap_blocks);
nr_dups = ntohs(chunk->nr_dup_tsns);
- if (length != sizeof(struct sctp_nr_sack_chunk) +
+ if (length != sizeof(struct _sctp_nr_sack_chunk) +
(nr_gaps + nr_of_nr_gaps + nr_dups) * sizeof(u32)) {
asprintf(error, "NR-SACK chunk length inconsistent");
return STATUS_ERR;
@@ -1345,7 +1345,7 @@ static int sctp_nr_sack_chunk_to_string(FILE *s,
}
static int sctp_heartbeat_chunk_to_string(FILE *s,
- struct sctp_heartbeat_chunk *chunk,
+ struct _sctp_heartbeat_chunk *chunk,
char **error)
{
u16 chunk_length, parameter_length, chunk_padding, parameter_padding;
@@ -1353,7 +1353,7 @@ static int sctp_heartbeat_chunk_to_string(FILE *s,
int result;
chunk_length = ntohs(chunk->length);
- if (chunk_length < sizeof(struct sctp_heartbeat_chunk) +
+ if (chunk_length < sizeof(struct _sctp_heartbeat_chunk) +
sizeof(struct sctp_heartbeat_information_parameter)) {
asprintf(error, "HEARTBEAT chunk too short");
return STATUS_ERR;
@@ -1367,7 +1367,7 @@ static int sctp_heartbeat_chunk_to_string(FILE *s,
if (parameter_padding != 0)
parameter_padding = 4 - parameter_padding;
if (chunk_length + chunk_padding !=
- sizeof(struct sctp_heartbeat_chunk) +
+ sizeof(struct _sctp_heartbeat_chunk) +
parameter_length + parameter_padding) {
asprintf(error, "HEARTBEAT chunk inconsistent");
return STATUS_ERR;
@@ -1381,7 +1381,7 @@ static int sctp_heartbeat_chunk_to_string(FILE *s,
static int sctp_heartbeat_ack_chunk_to_string(
FILE *s,
- struct sctp_heartbeat_ack_chunk *chunk,
+ struct _sctp_heartbeat_ack_chunk *chunk,
char **error)
{
u16 chunk_length, parameter_length, chunk_padding, parameter_padding;
@@ -1389,7 +1389,7 @@ static int sctp_heartbeat_ack_chunk_to_string(
int result;
chunk_length = ntohs(chunk->length);
- if (chunk_length < sizeof(struct sctp_heartbeat_ack_chunk) +
+ if (chunk_length < sizeof(struct _sctp_heartbeat_ack_chunk) +
sizeof(struct sctp_heartbeat_information_parameter)) {
asprintf(error, "HEARTBEAT_ACK chunk too short");
return STATUS_ERR;
@@ -1403,7 +1403,7 @@ static int sctp_heartbeat_ack_chunk_to_string(
if (parameter_padding != 0)
parameter_padding = 4 - parameter_padding;
if (chunk_length + chunk_padding !=
- sizeof(struct sctp_heartbeat_chunk) +
+ sizeof(struct _sctp_heartbeat_chunk) +
parameter_length + parameter_padding) {
asprintf(error, "HEARTBEAT_ACK chunk inconsistent");
return STATUS_ERR;
@@ -1416,7 +1416,7 @@ static int sctp_heartbeat_ack_chunk_to_string(
}
static int sctp_abort_chunk_to_string(FILE *s,
- struct sctp_abort_chunk *chunk,
+ struct _sctp_abort_chunk *chunk,
char **error)
{
struct sctp_causes_iterator iter;
@@ -1427,7 +1427,7 @@ static int sctp_abort_chunk_to_string(FILE *s,
flags = chunk->flags;
length = ntohs(chunk->length);
- if (length < sizeof(struct sctp_abort_chunk)) {
+ if (length < sizeof(struct _sctp_abort_chunk)) {
asprintf(error, "ABORT chunk too short (length=%u)", length);
return STATUS_ERR;
}
@@ -1461,13 +1461,13 @@ static int sctp_abort_chunk_to_string(FILE *s,
}
static int sctp_shutdown_chunk_to_string(FILE *s,
- struct sctp_shutdown_chunk *chunk,
+ struct _sctp_shutdown_chunk *chunk,
char **error)
{
u16 length;
length = ntohs(chunk->length);
- if (length != sizeof(struct sctp_shutdown_chunk)) {
+ if (length != sizeof(struct _sctp_shutdown_chunk)) {
asprintf(error, "SHUTDOWN chunk illegal (length=%u)", length);
return STATUS_ERR;
}
@@ -1480,13 +1480,13 @@ static int sctp_shutdown_chunk_to_string(FILE *s,
static int sctp_shutdown_ack_chunk_to_string(
FILE *s,
- struct sctp_shutdown_ack_chunk *chunk,
+ struct _sctp_shutdown_ack_chunk *chunk,
char **error)
{
u16 length;
length = ntohs(chunk->length);
- if (length != sizeof(struct sctp_shutdown_ack_chunk)) {
+ if (length != sizeof(struct _sctp_shutdown_ack_chunk)) {
asprintf(error, "SHUTDOWN_ACK chunk too long (length=%u)",
length);
return STATUS_ERR;
@@ -1498,7 +1498,7 @@ static int sctp_shutdown_ack_chunk_to_string(
}
static int sctp_error_chunk_to_string(FILE *s,
- struct sctp_error_chunk *chunk,
+ struct _sctp_error_chunk *chunk,
char **error)
{
struct sctp_causes_iterator iter;
@@ -1507,7 +1507,7 @@ static int sctp_error_chunk_to_string(FILE *s,
int result = STATUS_OK;
length = ntohs(chunk->length);
- if (length < sizeof(struct sctp_abort_chunk)) {
+ if (length < sizeof(struct _sctp_abort_chunk)) {
asprintf(error, "ERROR chunk too short (length=%u)", length);
return STATUS_ERR;
}
@@ -1537,7 +1537,7 @@ static int sctp_error_chunk_to_string(FILE *s,
static int sctp_cookie_echo_chunk_to_string(
FILE *s,
- struct sctp_cookie_echo_chunk *chunk,
+ struct _sctp_cookie_echo_chunk *chunk,
char **error)
{
u16 length;
@@ -1551,13 +1551,13 @@ static int sctp_cookie_echo_chunk_to_string(
}
static int sctp_cookie_ack_chunk_to_string(FILE *s,
- struct sctp_cookie_ack_chunk *chunk,
+ struct _sctp_cookie_ack_chunk *chunk,
char **error)
{
u16 length;
length = ntohs(chunk->length);
- if (length != sizeof(struct sctp_cookie_ack_chunk)) {
+ if (length != sizeof(struct _sctp_cookie_ack_chunk)) {
asprintf(error, "COOKIE_ACK chunk too long (length=%u)",
length);
return STATUS_ERR;
@@ -1569,13 +1569,13 @@ static int sctp_cookie_ack_chunk_to_string(FILE *s,
}
static int sctp_ecne_chunk_to_string(FILE *s,
- struct sctp_ecne_chunk *chunk,
+ struct _sctp_ecne_chunk *chunk,
char **error)
{
u16 length;
length = ntohs(chunk->length);
- if (length != sizeof(struct sctp_ecne_chunk)) {
+ if (length != sizeof(struct _sctp_ecne_chunk)) {
asprintf(error, "ECNE chunk illegal (length=%u)", length);
return STATUS_ERR;
}
@@ -1587,13 +1587,13 @@ static int sctp_ecne_chunk_to_string(FILE *s,
}
static int sctp_cwr_chunk_to_string(FILE *s,
- struct sctp_cwr_chunk *chunk,
+ struct _sctp_cwr_chunk *chunk,
char **error)
{
u16 length;
length = ntohs(chunk->length);
- if (length != sizeof(struct sctp_cwr_chunk)) {
+ if (length != sizeof(struct _sctp_cwr_chunk)) {
asprintf(error, "CWR chunk illegal (length=%u)", length);
return STATUS_ERR;
}
@@ -1606,7 +1606,7 @@ static int sctp_cwr_chunk_to_string(FILE *s,
static int sctp_shutdown_complete_chunk_to_string(
FILE *s,
- struct sctp_shutdown_complete_chunk *chunk,
+ struct _sctp_shutdown_complete_chunk *chunk,
char **error)
{
u8 flags;
@@ -1614,7 +1614,7 @@ static int sctp_shutdown_complete_chunk_to_string(
flags = chunk->flags;
length = ntohs(chunk->length);
- if (length != sizeof(struct sctp_shutdown_complete_chunk)) {
+ if (length != sizeof(struct _sctp_shutdown_complete_chunk)) {
asprintf(error, "SHUTDOWN_COMPLETE chunk too long (length=%u)",
length);
return STATUS_ERR;
@@ -1631,7 +1631,7 @@ static int sctp_shutdown_complete_chunk_to_string(
}
static int sctp_i_data_chunk_to_string(FILE *s,
- struct sctp_i_data_chunk *chunk,
+ struct _sctp_i_data_chunk *chunk,
char **error)
{
u16 length;
@@ -1639,7 +1639,7 @@ static int sctp_i_data_chunk_to_string(FILE *s,
flags = chunk->flags;
length = ntohs(chunk->length);
- if (length < sizeof(struct sctp_i_data_chunk)) {
+ if (length < sizeof(struct _sctp_i_data_chunk)) {
asprintf(error, "I-DATA chunk too short (length=%u)", length);
return STATUS_ERR;
}
@@ -1675,7 +1675,7 @@ static int sctp_i_data_chunk_to_string(FILE *s,
static int sctp_pad_chunk_to_string(
FILE *s,
- struct sctp_pad_chunk *chunk,
+ struct _sctp_pad_chunk *chunk,
char **error)
{
u16 length;
@@ -1690,7 +1690,7 @@ static int sctp_pad_chunk_to_string(
static int sctp_reconfig_chunk_to_string(
FILE *s,
- struct sctp_reconfig_chunk *chunk,
+ struct _sctp_reconfig_chunk *chunk,
char **error)
{
u16 length;
@@ -1700,18 +1700,18 @@ static int sctp_reconfig_chunk_to_string(
struct sctp_parameters_iterator iter;
length = ntohs(chunk->length);
- if (length < sizeof(struct sctp_reconfig_chunk) ||
- (length > sizeof(struct sctp_reconfig_chunk) &&
- length < sizeof(struct sctp_reconfig_chunk) + 4)) {
+ if (length < sizeof(struct _sctp_reconfig_chunk) ||
+ (length > sizeof(struct _sctp_reconfig_chunk) &&
+ length < sizeof(struct _sctp_reconfig_chunk) + 4)) {
asprintf(error, "RECONFIG chunk too short (length=%u)", length);
return STATUS_ERR;
}
- parameters_length = length - sizeof(struct sctp_reconfig_chunk);
+ parameters_length = length - sizeof(struct _sctp_reconfig_chunk);
fputs("RECONFIG[", s);
fprintf(s, "flgs=0x%02x, ", chunk->flags);
fprintf(s, "len=%u", length);
- if (length >= sizeof(struct sctp_reconfig_chunk) + 4) {
+ if (length >= sizeof(struct _sctp_reconfig_chunk) + 4) {
for (parameter = sctp_parameters_begin(chunk->parameter,
parameters_length,
&iter, error);
@@ -1734,19 +1734,19 @@ static int sctp_reconfig_chunk_to_string(
}
static u16 get_num_id_blocks (u16 packet_length) {
- return (packet_length - sizeof(struct sctp_forward_tsn_chunk)) / sizeof(struct sctp_stream_identifier_block);
+ return (packet_length - sizeof(struct _sctp_forward_tsn_chunk)) / sizeof(struct sctp_stream_identifier_block);
}
static int sctp_forward_tsn_chunk_to_string(
FILE *s,
- struct sctp_forward_tsn_chunk *chunk,
+ struct _sctp_forward_tsn_chunk *chunk,
char **error)
{
u16 length, i;
length = ntohs(chunk->length);
u16 num_id_blocks = get_num_id_blocks(length);
- if (length < sizeof(struct sctp_forward_tsn_chunk)) {
+ if (length < sizeof(struct _sctp_forward_tsn_chunk)) {
asprintf(error, "FORWARD_TSN chunk too short (length=%u)", length);
return STATUS_ERR;
}
@@ -1773,19 +1773,19 @@ static int sctp_forward_tsn_chunk_to_string(
}
static u16 get_num_id_blocks_for_i_forward_tsn (u16 packet_length) {
- return (packet_length - sizeof(struct sctp_i_forward_tsn_chunk)) / sizeof(struct sctp_i_forward_tsn_identifier_block);
+ return (packet_length - sizeof(struct _sctp_i_forward_tsn_chunk)) / sizeof(struct sctp_i_forward_tsn_identifier_block);
}
static int sctp_i_forward_tsn_chunk_to_string(
FILE *s,
- struct sctp_i_forward_tsn_chunk *chunk,
+ struct _sctp_i_forward_tsn_chunk *chunk,
char **error)
{
u16 length, i;
length = ntohs(chunk->length);
u16 num_id_blocks = get_num_id_blocks_for_i_forward_tsn(length);
- if (length < sizeof(struct sctp_i_forward_tsn_chunk)) {
+ if (length < sizeof(struct _sctp_i_forward_tsn_chunk)) {
asprintf(error, "I_FORWARD_TSN chunk too short (length=%u)", length);
return STATUS_ERR;
}
@@ -1838,87 +1838,87 @@ int sctp_chunk_to_string(FILE *s, struct sctp_chunk *chunk, char **error)
switch (chunk->type) {
case SCTP_DATA_CHUNK_TYPE:
result = sctp_data_chunk_to_string(s,
- (struct sctp_data_chunk *)chunk, error);
+ (struct _sctp_data_chunk *)chunk, error);
break;
case SCTP_INIT_CHUNK_TYPE:
result = sctp_init_chunk_to_string(s,
- (struct sctp_init_chunk *)chunk, error);
+ (struct _sctp_init_chunk *)chunk, error);
break;
case SCTP_INIT_ACK_CHUNK_TYPE:
result = sctp_init_ack_chunk_to_string(s,
- (struct sctp_init_ack_chunk *)chunk, error);
+ (struct _sctp_init_ack_chunk *)chunk, error);
break;
case SCTP_SACK_CHUNK_TYPE:
result = sctp_sack_chunk_to_string(s,
- (struct sctp_sack_chunk *)chunk, error);
+ (struct _sctp_sack_chunk *)chunk, error);
break;
case SCTP_NR_SACK_CHUNK_TYPE:
result = sctp_nr_sack_chunk_to_string(s,
- (struct sctp_nr_sack_chunk *)chunk, error);
+ (struct _sctp_nr_sack_chunk *)chunk, error);
break;
case SCTP_HEARTBEAT_CHUNK_TYPE:
result = sctp_heartbeat_chunk_to_string(s,
- (struct sctp_heartbeat_chunk *)chunk, error);
+ (struct _sctp_heartbeat_chunk *)chunk, error);
break;
case SCTP_HEARTBEAT_ACK_CHUNK_TYPE:
result = sctp_heartbeat_ack_chunk_to_string(s,
- (struct sctp_heartbeat_ack_chunk *)chunk, error);
+ (struct _sctp_heartbeat_ack_chunk *)chunk, error);
break;
case SCTP_ABORT_CHUNK_TYPE:
result = sctp_abort_chunk_to_string(s,
- (struct sctp_abort_chunk *)chunk, error);
+ (struct _sctp_abort_chunk *)chunk, error);
break;
case SCTP_SHUTDOWN_CHUNK_TYPE:
result = sctp_shutdown_chunk_to_string(s,
- (struct sctp_shutdown_chunk *)chunk, error);
+ (struct _sctp_shutdown_chunk *)chunk, error);
break;
case SCTP_SHUTDOWN_ACK_CHUNK_TYPE:
result = sctp_shutdown_ack_chunk_to_string(s,
- (struct sctp_shutdown_ack_chunk *)chunk, error);
+ (struct _sctp_shutdown_ack_chunk *)chunk, error);
break;
case SCTP_ERROR_CHUNK_TYPE:
result = sctp_error_chunk_to_string(s,
- (struct sctp_error_chunk *)chunk, error);
+ (struct _sctp_error_chunk *)chunk, error);
break;
case SCTP_COOKIE_ECHO_CHUNK_TYPE:
result = sctp_cookie_echo_chunk_to_string(s,
- (struct sctp_cookie_echo_chunk *)chunk, error);
+ (struct _sctp_cookie_echo_chunk *)chunk, error);
break;
case SCTP_COOKIE_ACK_CHUNK_TYPE:
result = sctp_cookie_ack_chunk_to_string(s,
- (struct sctp_cookie_ack_chunk *)chunk, error);
+ (struct _sctp_cookie_ack_chunk *)chunk, error);
break;
case SCTP_ECNE_CHUNK_TYPE:
result = sctp_ecne_chunk_to_string(s,
- (struct sctp_ecne_chunk *)chunk, error);
+ (struct _sctp_ecne_chunk *)chunk, error);
break;
case SCTP_CWR_CHUNK_TYPE:
result = sctp_cwr_chunk_to_string(s,
- (struct sctp_cwr_chunk *)chunk, error);
+ (struct _sctp_cwr_chunk *)chunk, error);
break;
case SCTP_SHUTDOWN_COMPLETE_CHUNK_TYPE:
result = sctp_shutdown_complete_chunk_to_string(s,
- (struct sctp_shutdown_complete_chunk *)chunk, error);
+ (struct _sctp_shutdown_complete_chunk *)chunk, error);
break;
case SCTP_I_DATA_CHUNK_TYPE:
result = sctp_i_data_chunk_to_string(s,
- (struct sctp_i_data_chunk *)chunk, error);
+ (struct _sctp_i_data_chunk *)chunk, error);
break;
case SCTP_PAD_CHUNK_TYPE:
result = sctp_pad_chunk_to_string(s,
- (struct sctp_pad_chunk *)chunk, error);
+ (struct _sctp_pad_chunk *)chunk, error);
break;
case SCTP_RECONFIG_CHUNK_TYPE:
result = sctp_reconfig_chunk_to_string(s,
- (struct sctp_reconfig_chunk *)chunk, error);
+ (struct _sctp_reconfig_chunk *)chunk, error);
break;
case SCTP_FORWARD_TSN_CHUNK_TYPE:
result = sctp_forward_tsn_chunk_to_string(s,
- (struct sctp_forward_tsn_chunk *)chunk, error);
+ (struct _sctp_forward_tsn_chunk *)chunk, error);
break;
case SCTP_I_FORWARD_TSN_CHUNK_TYPE:
result = sctp_i_forward_tsn_chunk_to_string(s,
- (struct sctp_i_forward_tsn_chunk *)chunk, error);
+ (struct _sctp_i_forward_tsn_chunk *)chunk, error);
break;
default:
result = sctp_unknown_chunk_to_string(s, chunk, error);
diff --git a/gtests/net/packetdrill/sctp_packet.c b/gtests/net/packetdrill/sctp_packet.c
index d74d0dbb..b1bcf961 100644
--- a/gtests/net/packetdrill/sctp_packet.c
+++ b/gtests/net/packetdrill/sctp_packet.c
@@ -562,13 +562,13 @@ sctp_generic_chunk_new(s64 type, s64 flgs, s64 len,
struct sctp_chunk_list_item *
sctp_data_chunk_new(s64 flgs, s64 len, s64 tsn, s64 sid, s64 ssn, s64 ppid)
{
- struct sctp_data_chunk *chunk;
+ struct _sctp_data_chunk *chunk;
u32 flags;
u16 length, padding_length;
flags = 0;
if (len == -1) {
- length = (u16)sizeof(struct sctp_data_chunk);
+ length = (u16)sizeof(struct _sctp_data_chunk);
} else {
length = (u16)len;
}
@@ -615,7 +615,7 @@ sctp_data_chunk_new(s64 flgs, s64 len, s64 tsn, s64 sid, s64 ssn, s64 ppid)
chunk->ppid = htonl((u32)ppid);
}
memset(chunk->data, 0,
- length + padding_length - sizeof(struct sctp_data_chunk));
+ length + padding_length - sizeof(struct _sctp_data_chunk));
return sctp_chunk_list_item_new((struct sctp_chunk *)chunk,
length + padding_length, flags,
sctp_parameter_list_new(),
@@ -626,13 +626,13 @@ struct sctp_chunk_list_item *
sctp_init_chunk_new(s64 flgs, s64 tag, s64 a_rwnd, s64 os, s64 is, s64 tsn,
struct sctp_parameter_list *list)
{
- struct sctp_init_chunk *chunk;
+ struct _sctp_init_chunk *chunk;
struct sctp_parameter_list_item *item;
u32 flags;
u16 offset, chunk_length, chunk_padding_length, parameter_padding_length;
flags = 0;
- chunk_length = sizeof(struct sctp_init_chunk);
+ chunk_length = sizeof(struct _sctp_init_chunk);
if (list != NULL) {
chunk_length += list->length;
} else {
@@ -709,13 +709,13 @@ struct sctp_chunk_list_item *
sctp_init_ack_chunk_new(s64 flgs, s64 tag, s64 a_rwnd, s64 os, s64 is, s64 tsn,
struct sctp_parameter_list *list)
{
- struct sctp_init_ack_chunk *chunk;
+ struct _sctp_init_ack_chunk *chunk;
struct sctp_parameter_list_item *item;
u32 flags;
u16 offset, chunk_length, chunk_padding_length, parameter_padding_length;
flags = 0;
- chunk_length = sizeof(struct sctp_init_ack_chunk);
+ chunk_length = sizeof(struct _sctp_init_ack_chunk);
if (list != NULL) {
chunk_length += list->length;
} else {
@@ -793,14 +793,14 @@ sctp_sack_chunk_new(s64 flgs, s64 cum_tsn, s64 a_rwnd,
struct sctp_sack_block_list *gaps,
struct sctp_sack_block_list *dups)
{
- struct sctp_sack_chunk *chunk;
+ struct _sctp_sack_chunk *chunk;
struct sctp_sack_block_list_item *item;
u32 flags;
u32 length;
u16 i, nr_gaps, nr_dups;
flags = 0;
- length = sizeof(struct sctp_sack_chunk);
+ length = sizeof(struct _sctp_sack_chunk);
if (gaps == NULL) {
nr_gaps = 0;
flags |= FLAG_CHUNK_LENGTH_NOCHECK;
@@ -875,14 +875,14 @@ sctp_nr_sack_chunk_new(s64 flgs, s64 cum_tsn, s64 a_rwnd,
struct sctp_sack_block_list *gaps,
struct sctp_sack_block_list *nr_gaps_list,
struct sctp_sack_block_list *dups) {
- struct sctp_nr_sack_chunk *chunk;
+ struct _sctp_nr_sack_chunk *chunk;
struct sctp_sack_block_list_item *item;
u32 flags;
u32 length;
u16 i, nr_gaps, nr_dups, number_of_nr_gaps;
flags = 0;
- length = sizeof(struct sctp_nr_sack_chunk);
+ length = sizeof(struct _sctp_nr_sack_chunk);
if (gaps == NULL) {
nr_gaps = 0;
flags |= FLAG_CHUNK_LENGTH_NOCHECK;
@@ -973,14 +973,14 @@ sctp_nr_sack_chunk_new(s64 flgs, s64 cum_tsn, s64 a_rwnd,
struct sctp_chunk_list_item *
sctp_heartbeat_chunk_new(s64 flgs, struct sctp_parameter_list_item *info)
{
- struct sctp_heartbeat_chunk *chunk;
+ struct _sctp_heartbeat_chunk *chunk;
u32 flags;
u16 chunk_length, padding_length;
flags = 0;
assert(info == NULL ||
- info->length + sizeof(struct sctp_heartbeat_chunk) <= MAX_SCTP_CHUNK_BYTES);
- chunk_length = sizeof(struct sctp_heartbeat_chunk);
+ info->length + sizeof(struct _sctp_heartbeat_chunk) <= MAX_SCTP_CHUNK_BYTES);
+ chunk_length = sizeof(struct _sctp_heartbeat_chunk);
if (info != NULL) {
chunk_length += info->length;
if (info->flags & FLAG_PARAMETER_LENGTH_NOCHECK) {
@@ -1022,14 +1022,14 @@ sctp_heartbeat_chunk_new(s64 flgs, struct sctp_parameter_list_item *info)
struct sctp_chunk_list_item *
sctp_heartbeat_ack_chunk_new(s64 flgs, struct sctp_parameter_list_item *info)
{
- struct sctp_heartbeat_ack_chunk *chunk;
+ struct _sctp_heartbeat_ack_chunk *chunk;
u32 flags;
u16 chunk_length, padding_length;
flags = 0;
assert(info == NULL ||
- info->length + sizeof(struct sctp_heartbeat_ack_chunk) <= MAX_SCTP_CHUNK_BYTES);
- chunk_length = sizeof(struct sctp_heartbeat_ack_chunk);
+ info->length + sizeof(struct _sctp_heartbeat_ack_chunk) <= MAX_SCTP_CHUNK_BYTES);
+ chunk_length = sizeof(struct _sctp_heartbeat_ack_chunk);
if (info != NULL) {
chunk_length += info->length;
if (info->flags & FLAG_PARAMETER_LENGTH_NOCHECK) {
@@ -1071,13 +1071,13 @@ sctp_heartbeat_ack_chunk_new(s64 flgs, struct sctp_parameter_list_item *info)
struct sctp_chunk_list_item *
sctp_abort_chunk_new(s64 flgs, struct sctp_cause_list *list)
{
- struct sctp_abort_chunk *chunk;
+ struct _sctp_abort_chunk *chunk;
struct sctp_cause_list_item *item;
u32 flags;
u16 offset, chunk_length, chunk_padding_length, cause_padding_length;
flags = 0;
- chunk_length = sizeof(struct sctp_abort_chunk);
+ chunk_length = sizeof(struct _sctp_abort_chunk);
if (list != NULL) {
chunk_length += list->length;
} else {
@@ -1127,11 +1127,11 @@ sctp_abort_chunk_new(s64 flgs, struct sctp_cause_list *list)
struct sctp_chunk_list_item *
sctp_shutdown_chunk_new(s64 flgs, s64 cum_tsn)
{
- struct sctp_shutdown_chunk *chunk;
+ struct _sctp_shutdown_chunk *chunk;
u32 flags;
flags = 0;
- chunk = malloc(sizeof(struct sctp_shutdown_chunk));
+ chunk = malloc(sizeof(struct _sctp_shutdown_chunk));
assert(chunk != NULL);
chunk->type = SCTP_SHUTDOWN_CHUNK_TYPE;
if (flgs == -1) {
@@ -1140,7 +1140,7 @@ sctp_shutdown_chunk_new(s64 flgs, s64 cum_tsn)
} else {
chunk->flags = (u8)flgs;
}
- chunk->length = htons(sizeof(struct sctp_shutdown_chunk));
+ chunk->length = htons(sizeof(struct _sctp_shutdown_chunk));
if (cum_tsn == -1) {
chunk->cum_tsn = htonl(0);
flags |= FLAG_SHUTDOWN_CHUNK_CUM_TSN_NOCHECK;
@@ -1149,7 +1149,7 @@ sctp_shutdown_chunk_new(s64 flgs, s64 cum_tsn)
}
return sctp_chunk_list_item_new((struct sctp_chunk *)chunk,
- (u32)sizeof(struct sctp_shutdown_chunk),
+ (u32)sizeof(struct _sctp_shutdown_chunk),
flags, sctp_parameter_list_new(),
sctp_cause_list_new());
}
@@ -1157,11 +1157,11 @@ sctp_shutdown_chunk_new(s64 flgs, s64 cum_tsn)
struct sctp_chunk_list_item *
sctp_shutdown_ack_chunk_new(s64 flgs)
{
- struct sctp_shutdown_ack_chunk *chunk;
+ struct _sctp_shutdown_ack_chunk *chunk;
u32 flags;
flags = 0;
- chunk = malloc(sizeof(struct sctp_shutdown_ack_chunk));
+ chunk = malloc(sizeof(struct _sctp_shutdown_ack_chunk));
assert(chunk != NULL);
chunk->type = SCTP_SHUTDOWN_ACK_CHUNK_TYPE;
if (flgs == -1) {
@@ -1170,9 +1170,9 @@ sctp_shutdown_ack_chunk_new(s64 flgs)
} else {
chunk->flags = (u8)flgs;
}
- chunk->length = htons(sizeof(struct sctp_shutdown_ack_chunk));
+ chunk->length = htons(sizeof(struct _sctp_shutdown_ack_chunk));
return sctp_chunk_list_item_new((struct sctp_chunk *)chunk,
- (u32)sizeof(struct sctp_shutdown_ack_chunk),
+ (u32)sizeof(struct _sctp_shutdown_ack_chunk),
flags, sctp_parameter_list_new(),
sctp_cause_list_new());
}
@@ -1180,13 +1180,13 @@ sctp_shutdown_ack_chunk_new(s64 flgs)
struct sctp_chunk_list_item *
sctp_error_chunk_new(s64 flgs, struct sctp_cause_list *list)
{
- struct sctp_error_chunk *chunk;
+ struct _sctp_error_chunk *chunk;
struct sctp_cause_list_item *item;
u32 flags;
u16 offset, chunk_length, chunk_padding_length, cause_padding_length;
flags = 0;
- chunk_length = sizeof(struct sctp_error_chunk);
+ chunk_length = sizeof(struct _sctp_error_chunk);
if (list != NULL) {
chunk_length += list->length;
} else {
@@ -1236,24 +1236,24 @@ sctp_error_chunk_new(s64 flgs, struct sctp_cause_list *list)
struct sctp_chunk_list_item *
sctp_cookie_echo_chunk_new(s64 flgs, s64 len, struct sctp_byte_list *cookie)
{
- struct sctp_cookie_echo_chunk *chunk;
+ struct _sctp_cookie_echo_chunk *chunk;
struct sctp_byte_list_item *item;
u32 flags;
u16 chunk_length, cookie_length, padding_length, i;
assert((len == -1) ||
(is_valid_u16(len) &&
- len >= sizeof(struct sctp_cookie_echo_chunk)));
+ len >= sizeof(struct _sctp_cookie_echo_chunk)));
assert((len != -1) || (cookie == NULL));
flags = 0;
if (len == -1) {
cookie_length = 0;
flags |= FLAG_CHUNK_LENGTH_NOCHECK;
} else {
- assert(len <= MAX_SCTP_CHUNK_BYTES - sizeof(struct sctp_cookie_echo_chunk));
- cookie_length = len - sizeof(struct sctp_cookie_echo_chunk);
+ assert(len <= MAX_SCTP_CHUNK_BYTES - sizeof(struct _sctp_cookie_echo_chunk));
+ cookie_length = len - sizeof(struct _sctp_cookie_echo_chunk);
}
- chunk_length = cookie_length + sizeof(struct sctp_cookie_echo_chunk);
+ chunk_length = cookie_length + sizeof(struct _sctp_cookie_echo_chunk);
padding_length = chunk_length % 4;
if (padding_length > 0) {
padding_length = 4 - padding_length;
@@ -1289,11 +1289,11 @@ sctp_cookie_echo_chunk_new(s64 flgs, s64 len, struct sctp_byte_list *cookie)
struct sctp_chunk_list_item *
sctp_cookie_ack_chunk_new(s64 flgs)
{
- struct sctp_cookie_ack_chunk *chunk;
+ struct _sctp_cookie_ack_chunk *chunk;
u32 flags;
flags = 0;
- chunk = malloc(sizeof(struct sctp_cookie_ack_chunk));
+ chunk = malloc(sizeof(struct _sctp_cookie_ack_chunk));
assert(chunk != NULL);
chunk->type = SCTP_COOKIE_ACK_CHUNK_TYPE;
if (flgs == -1) {
@@ -1302,9 +1302,9 @@ sctp_cookie_ack_chunk_new(s64 flgs)
} else {
chunk->flags = (u8)flgs;
}
- chunk->length = htons(sizeof(struct sctp_cookie_ack_chunk));
+ chunk->length = htons(sizeof(struct _sctp_cookie_ack_chunk));
return sctp_chunk_list_item_new((struct sctp_chunk *)chunk,
- (u32)sizeof(struct sctp_cookie_ack_chunk),
+ (u32)sizeof(struct _sctp_cookie_ack_chunk),
flags, sctp_parameter_list_new(),
sctp_cause_list_new());
}
@@ -1312,11 +1312,11 @@ sctp_cookie_ack_chunk_new(s64 flgs)
struct sctp_chunk_list_item *
sctp_ecne_chunk_new(s64 flgs, s64 lowest_tsn)
{
- struct sctp_ecne_chunk *chunk;
+ struct _sctp_ecne_chunk *chunk;
u32 flags;
flags = 0;
- chunk = malloc(sizeof(struct sctp_ecne_chunk));
+ chunk = malloc(sizeof(struct _sctp_ecne_chunk));
assert(chunk != NULL);
chunk->type = SCTP_ECNE_CHUNK_TYPE;
if (flgs == -1) {
@@ -1325,7 +1325,7 @@ sctp_ecne_chunk_new(s64 flgs, s64 lowest_tsn)
} else {
chunk->flags = (u8)flgs;
}
- chunk->length = htons(sizeof(struct sctp_ecne_chunk));
+ chunk->length = htons(sizeof(struct _sctp_ecne_chunk));
if (lowest_tsn == -1) {
chunk->lowest_tsn = htonl(0);
flags |= FLAG_ECNE_CHUNK_LOWEST_TSN_NOCHECK;
@@ -1334,7 +1334,7 @@ sctp_ecne_chunk_new(s64 flgs, s64 lowest_tsn)
}
return sctp_chunk_list_item_new((struct sctp_chunk *)chunk,
- (u32)sizeof(struct sctp_ecne_chunk),
+ (u32)sizeof(struct _sctp_ecne_chunk),
flags, sctp_parameter_list_new(),
sctp_cause_list_new());
}
@@ -1342,11 +1342,11 @@ sctp_ecne_chunk_new(s64 flgs, s64 lowest_tsn)
struct sctp_chunk_list_item *
sctp_cwr_chunk_new(s64 flgs, s64 lowest_tsn)
{
- struct sctp_cwr_chunk *chunk;
+ struct _sctp_cwr_chunk *chunk;
u32 flags;
flags = 0;
- chunk = malloc(sizeof(struct sctp_cwr_chunk));
+ chunk = malloc(sizeof(struct _sctp_cwr_chunk));
assert(chunk != NULL);
chunk->type = SCTP_CWR_CHUNK_TYPE;
if (flgs == -1) {
@@ -1355,7 +1355,7 @@ sctp_cwr_chunk_new(s64 flgs, s64 lowest_tsn)
} else {
chunk->flags = (u8)flgs;
}
- chunk->length = htons(sizeof(struct sctp_cwr_chunk));
+ chunk->length = htons(sizeof(struct _sctp_cwr_chunk));
if (lowest_tsn == -1) {
chunk->lowest_tsn = htonl(0);
flags |= FLAG_CWR_CHUNK_LOWEST_TSN_NOCHECK;
@@ -1364,7 +1364,7 @@ sctp_cwr_chunk_new(s64 flgs, s64 lowest_tsn)
}
return sctp_chunk_list_item_new((struct sctp_chunk *)chunk,
- (u32)sizeof(struct sctp_cwr_chunk),
+ (u32)sizeof(struct _sctp_cwr_chunk),
flags, sctp_parameter_list_new(),
sctp_cause_list_new());
}
@@ -1372,11 +1372,11 @@ sctp_cwr_chunk_new(s64 flgs, s64 lowest_tsn)
struct sctp_chunk_list_item *
sctp_shutdown_complete_chunk_new(s64 flgs)
{
- struct sctp_shutdown_complete_chunk *chunk;
+ struct _sctp_shutdown_complete_chunk *chunk;
u32 flags;
flags = 0;
- chunk = malloc(sizeof(struct sctp_shutdown_complete_chunk));
+ chunk = malloc(sizeof(struct _sctp_shutdown_complete_chunk));
assert(chunk != NULL);
chunk->type = SCTP_SHUTDOWN_COMPLETE_CHUNK_TYPE;
if (flgs == -1) {
@@ -1385,9 +1385,9 @@ sctp_shutdown_complete_chunk_new(s64 flgs)
} else {
chunk->flags = (u8)flgs;
}
- chunk->length = htons(sizeof(struct sctp_shutdown_complete_chunk));
+ chunk->length = htons(sizeof(struct _sctp_shutdown_complete_chunk));
return sctp_chunk_list_item_new((struct sctp_chunk *)chunk,
- (u32)sizeof(struct sctp_shutdown_complete_chunk),
+ (u32)sizeof(struct _sctp_shutdown_complete_chunk),
flags, sctp_parameter_list_new(),
sctp_cause_list_new());
}
@@ -1396,13 +1396,13 @@ struct sctp_chunk_list_item *
sctp_i_data_chunk_new(s64 flgs, s64 len, s64 tsn, s64 sid, s64 res, s64 mid,
s64 ppid, s64 fsn)
{
- struct sctp_i_data_chunk *chunk;
+ struct _sctp_i_data_chunk *chunk;
u32 flags;
u16 length, padding_length;
flags = 0;
if (len == -1) {
- length = (u16)sizeof(struct sctp_i_data_chunk);
+ length = (u16)sizeof(struct _sctp_i_data_chunk);
} else {
length = (u16)len;
}
@@ -1462,7 +1462,7 @@ sctp_i_data_chunk_new(s64 flgs, s64 len, s64 tsn, s64 sid, s64 res, s64 mid,
chunk->field.ppid = htonl(0);
}
memset(chunk->data, 0,
- length + padding_length - sizeof(struct sctp_i_data_chunk));
+ length + padding_length - sizeof(struct _sctp_i_data_chunk));
return sctp_chunk_list_item_new((struct sctp_chunk *)chunk,
length + padding_length, flags,
sctp_parameter_list_new(),
@@ -1472,7 +1472,7 @@ sctp_i_data_chunk_new(s64 flgs, s64 len, s64 tsn, s64 sid, s64 res, s64 mid,
struct sctp_chunk_list_item *
sctp_pad_chunk_new(s64 flgs, s64 len, u8* padding)
{
- struct sctp_pad_chunk *chunk;
+ struct _sctp_pad_chunk *chunk;
u32 flags;
u16 chunk_length, padding_length, chunk_padding_length;
@@ -1483,10 +1483,10 @@ sctp_pad_chunk_new(s64 flgs, s64 len, u8* padding)
padding_length = 0;
flags |= FLAG_CHUNK_LENGTH_NOCHECK;
} else {
- assert(len <= MAX_SCTP_CHUNK_BYTES - sizeof(struct sctp_pad_chunk));
- padding_length = len - sizeof(struct sctp_pad_chunk);
+ assert(len <= MAX_SCTP_CHUNK_BYTES - sizeof(struct _sctp_pad_chunk));
+ padding_length = len - sizeof(struct _sctp_pad_chunk);
}
- chunk_length = padding_length + sizeof(struct sctp_pad_chunk);
+ chunk_length = padding_length + sizeof(struct _sctp_pad_chunk);
chunk_padding_length = chunk_length % 4;
if (chunk_padding_length > 0) {
chunk_padding_length = 4 - chunk_padding_length;
@@ -1517,7 +1517,7 @@ sctp_pad_chunk_new(s64 flgs, s64 len, u8* padding)
struct sctp_chunk_list_item *
sctp_forward_tsn_chunk_new(u32 cum_tsn, struct sctp_forward_tsn_ids_list *ids_list) {
- struct sctp_forward_tsn_chunk *chunk;
+ struct _sctp_forward_tsn_chunk *chunk;
struct sctp_forward_tsn_ids_list_item *item;
DEBUGP("sctp_forward_tsn_chunk_new called with cum_tsn = %d and sids_list = %p", cum_tsn, ids_list);
@@ -1527,7 +1527,7 @@ sctp_forward_tsn_chunk_new(u32 cum_tsn, struct sctp_forward_tsn_ids_list *ids_li
u16 i, nr_sids;
flags = 0;
- length = sizeof(struct sctp_forward_tsn_chunk);
+ length = sizeof(struct _sctp_forward_tsn_chunk);
if (ids_list == NULL) {
nr_sids = 0;
flags |= FLAG_CHUNK_LENGTH_NOCHECK;
@@ -1575,7 +1575,7 @@ sctp_forward_tsn_chunk_new(u32 cum_tsn, struct sctp_forward_tsn_ids_list *ids_li
struct sctp_chunk_list_item *
sctp_i_forward_tsn_chunk_new(u32 cum_tsn, struct sctp_i_forward_tsn_ids_list *ids_list) {
- struct sctp_i_forward_tsn_chunk *chunk;
+ struct _sctp_i_forward_tsn_chunk *chunk;
struct sctp_i_forward_tsn_ids_list_item *item;
DEBUGP("sctp_i_forward_tsn_chunk_new called with cum_tsn = %d and sids_list = %p", cum_tsn, ids_list);
@@ -1585,7 +1585,7 @@ sctp_i_forward_tsn_chunk_new(u32 cum_tsn, struct sctp_i_forward_tsn_ids_list *id
u16 i, nr_ids;
flags = 0;
- length = sizeof(struct sctp_i_forward_tsn_chunk);
+ length = sizeof(struct _sctp_i_forward_tsn_chunk);
if (ids_list == NULL) {
nr_ids = 0;
flags |= FLAG_CHUNK_LENGTH_NOCHECK;
@@ -1635,13 +1635,13 @@ sctp_i_forward_tsn_chunk_new(u32 cum_tsn, struct sctp_i_forward_tsn_ids_list *id
struct sctp_chunk_list_item *
sctp_reconfig_chunk_new(s64 flgs, struct sctp_parameter_list *parameters)
{
- struct sctp_reconfig_chunk *chunk;
+ struct _sctp_reconfig_chunk *chunk;
struct sctp_parameter_list_item *item;
u32 flags;
u16 offset, chunk_length, padding_length, parameter_padding_length;
flags = 0;
- chunk_length = (u16)sizeof(struct sctp_reconfig_chunk);
+ chunk_length = (u16)sizeof(struct _sctp_reconfig_chunk);
if (parameters != NULL) {
chunk_length += parameters->length;
} else {
diff --git a/gtests/net/packetdrill/socket.h b/gtests/net/packetdrill/socket.h
index 07fc1336..0012903d 100644
--- a/gtests/net/packetdrill/socket.h
+++ b/gtests/net/packetdrill/socket.h
@@ -121,9 +121,9 @@ struct socket {
u16 last_injected_udp_encaps_src_port;
u16 last_injected_udp_encaps_dst_port;
- struct sctp_cookie_echo_chunk *prepared_cookie_echo;
+ struct _sctp_cookie_echo_chunk *prepared_cookie_echo;
u16 prepared_cookie_echo_length;
- struct sctp_heartbeat_ack_chunk *prepared_heartbeat_ack;
+ struct _sctp_heartbeat_ack_chunk *prepared_heartbeat_ack;
u16 prepared_heartbeat_ack_length;
struct socket *next; /* next in linked list of sockets */
--
GitLab