Merge pull request #62 from hoelscher/sctp_events

Add support for the SCTP_EVENTS socket option.

gtests/net/packetdrill/lexer.l

@@ -245,6 +245,16 @@ spp_ipv6_flowlabel		return SPP_IPV6_FLOWLABEL_; /* avoid name clash */
 spp_dscp			return SPP_DSCP_; /* avoid name clash */
 se_type				return SE_TYPE;
 se_on				return SE_ON;
+sctp_data_io_event              return _SCTP_DATA_IO_EVENT_;
+sctp_association_event          return _SCTP_ASSOCIATION_EVENT_;
+sctp_address_event              return _SCTP_ADDRESS_EVENT_;
+sctp_send_failure_event         return _SCTP_SEND_FAILURE_EVENT_;
+sctp_peer_error_event           return _SCTP_PEER_ERROR_EVENT_;
+sctp_shutdown_event             return _SCTP_SHUTDOWN_EVENT_;
+sctp_partial_delivery_event     return _SCTP_PARTIAL_DELIVERY_EVENT_;
+sctp_adaptation_layer_event     return _SCTP_ADAPTATION_LAYER_EVENT_;
+sctp_authentication_event       return _SCTP_AUTHENTICATION_EVENT_;
+sctp_sender_dry_event           return _SCTP_SENDER_DRY_EVENT_;
 snd_sid				return SND_SID;
 snd_flags			return SND_FLAGS;
 snd_ppid			return SND_PPID;

gtests/net/packetdrill/parser.y

@@ -548,6 +548,10 @@ static struct tcp_option *new_tcp_fast_open_option(const char *cookie_string,
 %token <reserved> NXT_SID NXT_FLAGS NXT_PPID NXT_LENGTH
 %token <reserved> RECVV_RCVINFO RECVV_NXTINFO
 %token <reserved> SSE_TYPE SSE_FLAGS SSE_LENGTH
+%token <rexerved> _SCTP_DATA_IO_EVENT_ _SCTP_ASSOCIATION_EVENT_ _SCTP_ADDRESS_EVENT_
+%token <reserved> _SCTP_SEND_FAILURE_EVENT_ _SCTP_PEER_ERROR_EVENT_ _SCTP_SHUTDOWN_EVENT_
+%token <reserved> _SCTP_PARTIAL_DELIVERY_EVENT_ _SCTP_ADAPTATION_LAYER_EVENT_
+%token <reserved> _SCTP_AUTHENTICATION_EVENT_ _SCTP_SENDER_DRY_EVENT_
 %token <floating> FLOAT
 %token <integer> INTEGER HEX_INTEGER
 %token <string> WORD STRING BACK_QUOTED CODE IPV4_ADDR IPV6_ADDR
@@ -604,6 +608,7 @@ static struct tcp_option *new_tcp_fast_open_option(const char *cookie_string,
 %type <expression> sctp_rcvinfo rcv_sid rcv_ssn rcv_flags rcv_ppid rcv_tsn rcv_cumtsn rcv_context
 %type <expression> sctp_nxtinfo nxt_sid nxt_flags nxt_ppid nxt_length sctp_recvv_rn
 %type <expression> sctp_shutdown_event sse_type sse_flags sse_length
+%type <expression> sctp_event_subscribe
 %type <errno_info> opt_errno
 %type <chunk_list> sctp_chunk_list_spec
 %type <chunk_list_item> sctp_chunk_spec
@@ -2461,6 +2466,9 @@ expression
 | sctp_event        {
 	$$ = $1;
 }
+| sctp_event_subscribe {
+	$$ = $1;
+}
 | sctp_sndinfo      {
 	$$ = $1;
 }
@@ -3116,6 +3124,57 @@ sctp_event
 }
 ;
 
+sctp_event_subscribe
+: '{' _SCTP_DATA_IO_EVENT_          '=' INTEGER ',' _SCTP_ASSOCIATION_EVENT_      '=' INTEGER ','
+      _SCTP_ADDRESS_EVENT_          '=' INTEGER ',' _SCTP_SEND_FAILURE_EVENT_     '=' INTEGER ','
+      _SCTP_PEER_ERROR_EVENT_       '=' INTEGER ',' _SCTP_SHUTDOWN_EVENT_         '=' INTEGER ','
+      _SCTP_PARTIAL_DELIVERY_EVENT_ '=' INTEGER ',' _SCTP_ADAPTATION_LAYER_EVENT_ '=' INTEGER ','
+      _SCTP_AUTHENTICATION_EVENT_   '=' INTEGER ',' _SCTP_SENDER_DRY_EVENT_       '=' INTEGER '}' {
+	$$ = new_expression(EXPR_SCTP_EVENT_SUBSCRIBE);
+	$$->value.sctp_event_subscribe = calloc(1, sizeof(struct sctp_event_subscribe_expr));
+	if (!is_valid_u8($4)) {
+		semantic_error("sctp_data_io_event out of range");
+	}
+	$$->value.sctp_event_subscribe->sctp_data_io_event =  new_integer_expression($4, "%hhu");
+	if (!is_valid_u8($8)) {
+		semantic_error("sctp_association_event out of range");
+	}
+	$$->value.sctp_event_subscribe->sctp_association_event =  new_integer_expression($8, "%hhu");
+	if (!is_valid_u8($12)) {
+		semantic_error("sctp_address_event out of range");
+	}
+	$$->value.sctp_event_subscribe->sctp_address_event =  new_integer_expression($12, "%hhu");
+	if (!is_valid_u8($16)) {
+		semantic_error("sctp_send_failure_event out of range");
+	}
+	$$->value.sctp_event_subscribe->sctp_send_failure_event =  new_integer_expression($16, "%hhu");
+	if (!is_valid_u8($20)) {
+		semantic_error("sctp_peer_error_event out of range");
+	}
+	$$->value.sctp_event_subscribe->sctp_peer_error_event =  new_integer_expression($20, "%hhu");
+	if (!is_valid_u8($24)) {
+		semantic_error("sctp_shutdown_event out of range");
+	}
+	$$->value.sctp_event_subscribe->sctp_shutdown_event =  new_integer_expression($24, "%hhu");
+	if (!is_valid_u8($28)) {
+		semantic_error("sctp_partial_delivery_event out of range");
+	}
+	$$->value.sctp_event_subscribe->sctp_partial_delivery_event =  new_integer_expression($28, "%hhu");
+	if (!is_valid_u8($32)) {
+		semantic_error("sctp_adaptation_layer_event out of range");
+	}
+	$$->value.sctp_event_subscribe->sctp_adaptation_layer_event =  new_integer_expression($32, "%hhu");
+	if (!is_valid_u8($36)) {
+		semantic_error("sctp_authentication_event out of range");
+	}
+	$$->value.sctp_event_subscribe->sctp_authentication_event =  new_integer_expression($36, "%hhu");
+	if (!is_valid_u8($40)) {
+		semantic_error("sctp_sender_dry_event out of range");
+	}
+	$$->value.sctp_event_subscribe->sctp_sender_dry_event =  new_integer_expression($40, "%hhu");
+}
+;
+
 snd_sid
 : SND_SID '=' INTEGER {
 	if (!is_valid_u16($3)) {

gtests/net/packetdrill/run_system_call.c

@@ -2318,6 +2318,135 @@ static int check_sctp_event(struct sctp_event_expr *expr,
 }
 #endif
 
+#ifdef SCTP_EVENT
+static int check_sctp_event_subscribe(struct sctp_event_subscribe_expr *expr,
+				      struct sctp_event_subscribe *sctp_events,
+				      char **error)
+{
+	if (expr->sctp_data_io_event->type != EXPR_ELLIPSIS) {
+		u8 sctp_data_io_event;
+
+		if (get_u8(expr->sctp_data_io_event, &sctp_data_io_event, error)) {
+			return STATUS_ERR;
+		}
+		if (sctp_events->sctp_data_io_event != sctp_data_io_event) {
+			asprintf(error, "sctp_event_subscribe.sctp_data_io_event: expected: %hhu actual: %hhu",
+				 sctp_data_io_event, sctp_events->sctp_data_io_event);
+			return STATUS_ERR;
+		}
+	}
+	if (expr->sctp_association_event->type != EXPR_ELLIPSIS) {
+		u8 sctp_association_event;
+
+		if (get_u8(expr->sctp_association_event, &sctp_association_event, error)) {
+			return STATUS_ERR;
+		}
+		if (sctp_events->sctp_association_event != sctp_association_event) {
+			asprintf(error, "sctp_event_subscribe.sctp_association_event: expected: %hhu actual: %hhu",
+				 sctp_association_event, sctp_events->sctp_association_event);
+			return STATUS_ERR;
+		}
+	}
+	if (expr->sctp_address_event->type != EXPR_ELLIPSIS) {
+		u8 sctp_address_event;
+
+		if (get_u8(expr->sctp_address_event, &sctp_address_event, error)) {
+			return STATUS_ERR;
+		}
+		if (sctp_events->sctp_address_event != sctp_address_event) {
+			asprintf(error, "sctp_event_subscribe.sctp_address_event: expected: %hhu actual: %hhu",
+				 sctp_address_event, sctp_events->sctp_address_event);
+			return STATUS_ERR;
+		}
+	}
+	if (expr->sctp_send_failure_event->type != EXPR_ELLIPSIS) {
+		u8 sctp_send_failure_event;
+
+		if (get_u8(expr->sctp_send_failure_event, &sctp_send_failure_event, error)) {
+			return STATUS_ERR;
+		}
+		if (sctp_events->sctp_send_failure_event != sctp_send_failure_event) {
+			asprintf(error, "sctp_event_subscribe.sctp_send_failure_event: expected: %hhu actual: %hhu",
+				 sctp_send_failure_event, sctp_events->sctp_send_failure_event);
+			return STATUS_ERR;
+		}
+	}
+	if (expr->sctp_peer_error_event->type != EXPR_ELLIPSIS) {
+		u8 sctp_peer_error_event;
+
+		if (get_u8(expr->sctp_peer_error_event, &sctp_peer_error_event, error)) {
+			return STATUS_ERR;
+		}
+		if (sctp_events->sctp_peer_error_event != sctp_peer_error_event) {
+			asprintf(error, "sctp_event_subscribe.sctp_peer_error_event: expected: %hhu actual: %hhu",
+				 sctp_peer_error_event, sctp_events->sctp_peer_error_event);
+			return STATUS_ERR;
+		}
+	}
+	if (expr->sctp_shutdown_event->type != EXPR_ELLIPSIS) {
+		u8 sctp_shutdown_event;
+
+		if (get_u8(expr->sctp_shutdown_event, &sctp_shutdown_event, error)) {
+			return STATUS_ERR;
+		}
+		if (sctp_events->sctp_shutdown_event != sctp_shutdown_event) {
+			asprintf(error, "sctp_event_subscribe.sctp_shutdown_event: expected: %hhu actual: %hhu",
+				 sctp_shutdown_event, sctp_events->sctp_shutdown_event);
+			return STATUS_ERR;
+		}
+	}
+	if (expr->sctp_partial_delivery_event->type != EXPR_ELLIPSIS) {
+		u8 sctp_partial_delivery_event;
+
+		if (get_u8(expr->sctp_partial_delivery_event, &sctp_partial_delivery_event, error)) {
+			return STATUS_ERR;
+		}
+		if (sctp_events->sctp_partial_delivery_event != sctp_partial_delivery_event) {
+			asprintf(error, "sctp_event_subscribe.sctp_partial_delivery_event: expected: %hhu actual: %hhu",
+				 sctp_partial_delivery_event, sctp_events->sctp_partial_delivery_event);
+			return STATUS_ERR;
+		}
+	}
+	if (expr->sctp_adaptation_layer_event->type != EXPR_ELLIPSIS) {
+		u8 sctp_adaptation_layer_event;
+
+		if (get_u8(expr->sctp_adaptation_layer_event, &sctp_adaptation_layer_event, error)) {
+			return STATUS_ERR;
+		}
+		if (sctp_events->sctp_adaptation_layer_event != sctp_adaptation_layer_event) {
+			asprintf(error, "sctp_event_subscribe.sctp_adaptation_layer_event: expected: %hhu actual: %hhu",
+				 sctp_adaptation_layer_event, sctp_events->sctp_adaptation_layer_event);
+			return STATUS_ERR;
+		}
+	}
+	if (expr->sctp_authentication_event->type != EXPR_ELLIPSIS) {
+		u8 sctp_authentication_event;
+
+		if (get_u8(expr->sctp_authentication_event, &sctp_authentication_event, error)) {
+			return STATUS_ERR;
+		}
+		if (sctp_events->sctp_authentication_event != sctp_authentication_event) {
+			asprintf(error, "sctp_event_subscribe.sctp_authentication_event: expected: %hhu actual: %hhu",
+				 sctp_authentication_event, sctp_events->sctp_authentication_event);
+			return STATUS_ERR;
+		}
+	}
+	if (expr->sctp_sender_dry_event->type != EXPR_ELLIPSIS) {
+		u8 sctp_sender_dry_event;
+
+		if (get_u8(expr->sctp_sender_dry_event, &sctp_sender_dry_event, error)) {
+			return STATUS_ERR;
+		}
+		if (sctp_events->sctp_sender_dry_event != sctp_sender_dry_event) {
+			asprintf(error, "sctp_event_subscribe.sctp_sender_dry_event: expected: %hhu actual: %hhu",
+				 sctp_sender_dry_event, sctp_events->sctp_sender_dry_event);
+			return STATUS_ERR;
+		}
+	}
+
+	return STATUS_OK;
+}
+#endif
 #ifdef SCTP_DEFAULT_SNDINFO
 static int check_sctp_sndinfo(struct sctp_sndinfo_expr *expr,
 			      struct sctp_sndinfo *sctp_sndinfo,
@@ -2529,6 +2658,12 @@ static int syscall_getsockopt(struct state *state, struct syscall_spec *syscall,
 		}
 		break;
 #endif
+#ifdef SCTP_EVENTS
+	case EXPR_SCTP_EVENT_SUBSCRIBE:
+		live_optval = malloc(sizeof(struct sctp_event_subscribe));
+		live_optlen = sizeof(struct sctp_event_subscribe);
+		break;
+#endif
 #ifdef SCTP_DEFAULT_SNDINFO
 	case EXPR_SCTP_SNDINFO:
 		live_optval = malloc(sizeof(struct sctp_sndinfo));
@@ -2623,6 +2758,11 @@ static int syscall_getsockopt(struct state *state, struct syscall_spec *syscall,
 		result = check_sctp_event(val_expression->value.sctp_event, live_optval, error);
 		break;
 #endif
+#ifdef SCTP_EVENTS
+	case EXPR_SCTP_EVENT_SUBSCRIBE:
+		result = check_sctp_event_subscribe(val_expression->value.sctp_event_subscribe, live_optval, error);
+		break;
+#endif
 #ifdef SCTP_DEFAULT_SNDINFO
 	case EXPR_SCTP_SNDINFO:
 		result = check_sctp_sndinfo(val_expression->value.sctp_sndinfo, live_optval, error);
@@ -2683,6 +2823,9 @@ static int syscall_setsockopt(struct state *state, struct syscall_spec *syscall,
 #ifdef SCTP_EVENT
 	struct sctp_event event;
 #endif
+#ifdef SCTP_EVENTS
+	struct sctp_event_subscribe event_subscribe;
+#endif
 #ifdef SCTP_DEFAULT_SNDINFO
 	struct sctp_sndinfo sndinfo;
 #endif
@@ -2696,7 +2839,6 @@ static int syscall_setsockopt(struct state *state, struct syscall_spec *syscall,
 	u8 spp_dscp;
 #endif
 #endif
-
 	if (check_arg_count(args, 5, error))
 		return STATUS_ERR;
 	if (s32_arg(args, 0, &script_fd, error))
@@ -2863,6 +3005,51 @@ static int syscall_setsockopt(struct state *state, struct syscall_spec *syscall,
 		optval = &event;
 		break;
 #endif
+#ifdef SCTP_EVENTS
+	case EXPR_SCTP_EVENT_SUBSCRIBE:
+		if (get_u8(val_expression->value.sctp_event_subscribe->sctp_data_io_event,
+			    &event_subscribe.sctp_data_io_event, error)) {
+			return STATUS_ERR;
+		}
+		if (get_u8(val_expression->value.sctp_event_subscribe->sctp_association_event,
+			    &event_subscribe.sctp_association_event, error)) {
+			return STATUS_ERR;
+		}
+		if (get_u8(val_expression->value.sctp_event_subscribe->sctp_address_event,
+			    &event_subscribe.sctp_address_event, error)) {
+			return STATUS_ERR;
+		}
+		if (get_u8(val_expression->value.sctp_event_subscribe->sctp_send_failure_event,
+			    &event_subscribe.sctp_send_failure_event, error)) {
+			return STATUS_ERR;
+		}
+		if (get_u8(val_expression->value.sctp_event_subscribe->sctp_peer_error_event,
+			    &event_subscribe.sctp_peer_error_event, error)) {
+			return STATUS_ERR;
+		}
+		if (get_u8(val_expression->value.sctp_event_subscribe->sctp_shutdown_event,
+			    &event_subscribe.sctp_shutdown_event, error)) {
+			return STATUS_ERR;
+		}
+		if (get_u8(val_expression->value.sctp_event_subscribe->sctp_partial_delivery_event,
+			    &event_subscribe.sctp_partial_delivery_event, error)) {
+			return STATUS_ERR;
+		}
+		if (get_u8(val_expression->value.sctp_event_subscribe->sctp_adaptation_layer_event,
+			    &event_subscribe.sctp_adaptation_layer_event, error)) {
+			return STATUS_ERR;
+		}
+		if (get_u8(val_expression->value.sctp_event_subscribe->sctp_authentication_event,
+			    &event_subscribe.sctp_authentication_event, error)) {
+			return STATUS_ERR;
+		}
+		if (get_u8(val_expression->value.sctp_event_subscribe->sctp_sender_dry_event,
+			    &event_subscribe.sctp_sender_dry_event, error)) {
+			return STATUS_ERR;
+		}
+		optval = &event_subscribe;
+		break;
+#endif
 #ifdef SCTP_DEFAULT_SNDINFO
 	case EXPR_SCTP_SNDINFO:
 		sndinfo.snd_assoc_id = 0;
@@ -3761,6 +3948,9 @@ static int check_sctp_notification(struct iovec *iov,
 		case EXPR_ELLIPSIS:
 			break;
 		default:
+			asprintf(error, "Bad type for iov_base. Can't check type %s", 
+				expression_type_to_string(script_iov_base->type));
+			return STATUS_ERR;
 			break;
 		}
 		i++;

gtests/net/packetdrill/script.c

@@ -76,6 +76,7 @@ struct expression_type_entry expression_type_table[] = {
 	{ EXPR_SCTP_STREAM_VALUE,    "sctp_stream_value"},
 	{ EXPR_SCTP_ASSOCPARAMS,     "sctp_assocparams"},
 	{ EXPR_SCTP_EVENT,	     "sctp_event"      },
+	{ EXPR_SCTP_EVENT_SUBSCRIBE, "sctp_event_subscribe"},
 	{ EXPR_SCTP_SNDINFO,         "sctp_sndinfo"    },
 	{ EXPR_SCTP_SETADAPTATION,   "sctp_setadaptation"},
 	{ EXPR_SCTP_SNDRCVINFO,      "sctp_sndrcvinfo" },
@@ -366,6 +367,18 @@ void free_expression(struct expression *expression)
 		free_expression(expression->value.sctp_event->se_type);
 		free_expression(expression->value.sctp_event->se_on);
 		break;
+	case EXPR_SCTP_EVENT_SUBSCRIBE:
+		free_expression(expression->value.sctp_event_subscribe->sctp_data_io_event);
+		free_expression(expression->value.sctp_event_subscribe->sctp_association_event);
+		free_expression(expression->value.sctp_event_subscribe->sctp_address_event);
+		free_expression(expression->value.sctp_event_subscribe->sctp_send_failure_event);
+		free_expression(expression->value.sctp_event_subscribe->sctp_peer_error_event);
+		free_expression(expression->value.sctp_event_subscribe->sctp_shutdown_event);
+		free_expression(expression->value.sctp_event_subscribe->sctp_partial_delivery_event);
+		free_expression(expression->value.sctp_event_subscribe->sctp_adaptation_layer_event);
+		free_expression(expression->value.sctp_event_subscribe->sctp_authentication_event);
+		free_expression(expression->value.sctp_event_subscribe->sctp_sender_dry_event);
+		break;		
 	case EXPR_SCTP_SNDINFO:
 		free_expression(expression->value.sctp_sndinfo->snd_sid);
 		free_expression(expression->value.sctp_sndinfo->snd_flags);
@@ -924,6 +937,66 @@ static int evaluate_sctp_event_expression(struct expression *in,
 	return STATUS_OK; 
 }
 
+static int evaluate_sctp_event_subscribe_expression(struct expression *in,
+						    struct expression *out,
+						    char **error)
+{
+	struct sctp_event_subscribe_expr *in_event;
+	struct sctp_event_subscribe_expr *out_event;
+
+	assert(in->type == EXPR_SCTP_EVENT_SUBSCRIBE);
+	assert(in->value.sctp_event_subscribe);
+	assert(out->type == EXPR_SCTP_EVENT_SUBSCRIBE);
+
+	out->value.sctp_event_subscribe = calloc(1, sizeof(struct sctp_event_subscribe_expr));
+
+	in_event = in->value.sctp_event_subscribe;
+	out_event = out->value.sctp_event_subscribe;
+
+	if (evaluate(in_event->sctp_data_io_event,
+		    &out_event->sctp_data_io_event,
+		    error))
+		return STATUS_ERR;
+	if (evaluate(in_event->sctp_association_event,
+		    &out_event->sctp_association_event,
+		    error))
+		return STATUS_ERR;
+	if (evaluate(in_event->sctp_address_event,
+		    &out_event->sctp_address_event,
+		    error))
+		return STATUS_ERR;
+	if (evaluate(in_event->sctp_send_failure_event,
+		    &out_event->sctp_send_failure_event,
+		    error))
+		return STATUS_ERR;
+	if (evaluate(in_event->sctp_peer_error_event,
+		    &out_event->sctp_peer_error_event,
+		    error))
+		return STATUS_ERR;
+	if (evaluate(in_event->sctp_shutdown_event,
+		    &out_event->sctp_shutdown_event,
+		    error))
+		return STATUS_ERR;
+	if (evaluate(in_event->sctp_partial_delivery_event,
+		    &out_event->sctp_partial_delivery_event,
+		    error))
+		return STATUS_ERR;
+	if (evaluate(in_event->sctp_adaptation_layer_event,
+		    &out_event->sctp_adaptation_layer_event,
+		    error))
+		return STATUS_ERR;
+	if (evaluate(in_event->sctp_authentication_event,
+		    &out_event->sctp_authentication_event,
+		    error))
+		return STATUS_ERR;
+	if (evaluate(in_event->sctp_sender_dry_event,
+		    &out_event->sctp_sender_dry_event,
+		    error))
+		return STATUS_ERR;
+
+	return STATUS_OK;
+}
+
 static int evaluate_sctp_accocparams_expression(struct expression *in,
 						struct expression *out,
 						char **error)
@@ -1360,6 +1433,9 @@ static int evaluate(struct expression *in,
 	case EXPR_SCTP_EVENT:
 		result = evaluate_sctp_event_expression(in, out, error);
 		break;
+	case EXPR_SCTP_EVENT_SUBSCRIBE:
+		result = evaluate_sctp_event_subscribe_expression(in, out, error);
+		break;
 	case EXPR_SCTP_SNDINFO:
 		result = evaluate_sctp_sndinfo_expression(in, out, error);
 		break;

gtests/net/packetdrill/script.h

@@ -56,6 +56,7 @@ enum expression_t {
 	EXPR_SCTP_PEER_ADDR_PARAMS,	 /* struct for sctp_paddrparams for SCTP_PEER_ADDR_PARAMS */
 	EXPR_SCTP_ASSOCPARAMS,    /* struct sctp_assocparams for SCTP_ASSOCINFO */
 	EXPR_SCTP_EVENT,	  /* struct sctp_event for SCTP_EVENT */
+	EXPR_SCTP_EVENT_SUBSCRIBE,/* struct sctp_event_subscribe for SCTP_EVENTS */
 	EXPR_SCTP_SNDINFO,	  /* struct sctp_sndinfo for SCTP_DEFAULT_SNDINFO */
 	EXPR_SCTP_SETADAPTATION,  /* struct sctp_setadaptation for SCTP_ADATTATION_LAYER */
 	EXPR_SCTP_SNDRCVINFO,     /* struct sctp_sndrcvinfo for syscall sctp_recvmsg */
@@ -95,6 +96,7 @@ struct expression {
 		struct sctp_stream_value_expr *sctp_stream_value;
 		struct sctp_assocparams_expr *sctp_assocparams;
 		struct sctp_event_expr *sctp_event;
+		struct sctp_event_subscribe_expr *sctp_event_subscribe;
 		struct sctp_sndinfo_expr *sctp_sndinfo;
 		struct sctp_setadaptation_expr *sctp_setadaptation;
 		struct sctp_sndrcvinfo_expr *sctp_sndrcvinfo;
@@ -232,6 +234,20 @@ struct sctp_event_expr {
 	struct expression *se_on;
 };
 
+/* Parse tree for sctp_event_subscribe struct in [gs]etsockopt syscall. */
+struct sctp_event_subscribe_expr {
+	struct expression *sctp_data_io_event;
+	struct expression *sctp_association_event;
+	struct expression *sctp_address_event;
+	struct expression *sctp_send_failure_event;
+	struct expression *sctp_peer_error_event;
+	struct expression *sctp_shutdown_event;
+	struct expression *sctp_partial_delivery_event;
+	struct expression *sctp_adaptation_layer_event;
+	struct expression *sctp_authentication_event;
+	struct expression *sctp_sender_dry_event;
+};
+
 /* Parse tree for sctp_sndinfo struct in [gs]etsockopt syscall. */
 struct sctp_sndinfo_expr {
 	struct expression *snd_sid;

gtests/net/packetdrill/symbols_freebsd.c

@@ -89,6 +89,7 @@ struct int_symbol platform_symbols_table[] = {
 	{ SCTP_MAX_BURST,                   "SCTP_MAX_BURST"                  },
 	{ SCTP_PEER_ADDR_PARAMS,            "SCTP_PEER_ADDR_PARAMS"           },
 	{ SCTP_EVENT,			    "SCTP_EVENT"		      },
+	{ SCTP_EVENTS,			    "SCTP_EVENTS"		      },
 	{ SCTP_DEFAULT_SNDINFO,             "SCTP_DEFAULT_SNDINFO"            },
 	{ SCTP_STATUS,                      "SCTP_STATUS"                     },
 	{ SCTP_GET_PEER_ADDR_INFO,          "SCTP_GET_PEER_ADDR_INFO"         },

gtests/net/packetdrill/symbols_linux.c

@@ -112,6 +112,9 @@ struct int_symbol platform_symbols_table[] = {
 #endif
 #if 0
 	{ SCTP_EVENT,                       "SCTP_EVENT"                      },
+#endif
+#ifdef SCTP_EVENTS
+	{ SCTP_EVENTS,                      "SCTP_EVENTS"                     },
 #endif
 	{ SCTP_PEER_ADDR_PARAMS,            "SCTP_PEER_ADDR_PARAMS"           },
 	{ SCTP_STATUS,                      "SCTP_STATUS"                     },

gtests/net/packetdrill/tests/bsd/sctp/sctp_get_socket_options.pkt

@@ -115,16 +115,24 @@ sasoc_cookie_life=...}, [20]) = 0
 +0 setsockopt(3, IPPROTO_SCTP, SCTP_EVENT, {se_type=SCTP_SHUTDOWN_EVENT, se_on=1}, 8) = 0
 +0 getsockopt(3, IPPROTO_SCTP, SCTP_EVENT, {se_type=SCTP_SHUTDOWN_EVENT, se_on=1}, [8]) = 0
 
-+0 setsockopt(3, IPPROTO_SCTP, SCTP_DEFAULT_SNDINFO, {snd_sid=0, snd_flags=0, snd_ppid=1, snd_context=1}, 16) = 0
-+0 getsockopt(3, IPPROTO_SCTP, SCTP_DEFAULT_SNDINFO, {snd_sid=0, snd_flags=0, snd_ppid=1, snd_context=1}, [16]) = 0
-+0 setsockopt(3, IPPROTO_SCTP, SCTP_DEFAULT_SNDINFO, {snd_sid=0, snd_flags=SCTP_UNORDERED, snd_ppid=2, snd_context=2}, 16) = 0
-+0 getsockopt(3, IPPROTO_SCTP, SCTP_DEFAULT_SNDINFO, {snd_sid=0, snd_flags=SCTP_UNORDERED, snd_ppid=2, snd_context=2}, [16]) = 0
-+0 getsockopt(3, IPPROTO_SCTP, SCTP_DEFAULT_SNDINFO, {snd_sid=0, snd_flags=SCTP_UNORDERED, snd_ppid=2, snd_context=...}, [16]) = 0
++0 setsockopt(3, IPPROTO_SCTP, SCTP_DEFAULT_SNDINFO, {snd_sid=0, snd_flags=0, snd_ppid=htonl(1), snd_context=1}, 16) = 0
++0 getsockopt(3, IPPROTO_SCTP, SCTP_DEFAULT_SNDINFO, {snd_sid=0, snd_flags=0, snd_ppid=htonl(1), snd_context=1}, [16]) = 0
++0 setsockopt(3, IPPROTO_SCTP, SCTP_DEFAULT_SNDINFO, {snd_sid=0, snd_flags=SCTP_UNORDERED, snd_ppid=htonl(2), snd_context=2}, 16) = 0
++0 getsockopt(3, IPPROTO_SCTP, SCTP_DEFAULT_SNDINFO, {snd_sid=0, snd_flags=SCTP_UNORDERED, snd_ppid=htonl(2), snd_context=2}, [16]) = 0
++0 getsockopt(3, IPPROTO_SCTP, SCTP_DEFAULT_SNDINFO, {snd_sid=0, snd_flags=SCTP_UNORDERED, snd_ppid=htonl(2), snd_context=...}, [16]) = 0
 +0 getsockopt(3, IPPROTO_SCTP, SCTP_DEFAULT_SNDINFO, {snd_sid=0, snd_flags=SCTP_UNORDERED, snd_ppid=..., snd_context=2}, [16]) = 0
-+0 getsockopt(3, IPPROTO_SCTP, SCTP_DEFAULT_SNDINFO, {snd_sid=0, snd_flags=..., snd_ppid=2, snd_context=2}, [16]) = 0
-+0 getsockopt(3, IPPROTO_SCTP, SCTP_DEFAULT_SNDINFO, {snd_sid=..., snd_flags=SCTP_UNORDERED, snd_ppid=2, snd_context=2}, [16]) = 0
++0 getsockopt(3, IPPROTO_SCTP, SCTP_DEFAULT_SNDINFO, {snd_sid=0, snd_flags=..., snd_ppid=htonl(2), snd_context=2}, [16]) = 0
++0 getsockopt(3, IPPROTO_SCTP, SCTP_DEFAULT_SNDINFO, {snd_sid=..., snd_flags=SCTP_UNORDERED, snd_ppid=htonl(2), snd_context=2}, [16]) = 0
 
 +0 setsockopt(3, IPPROTO_SCTP, SCTP_ADAPTATION_LAYER, {ssb_adaptation_ind=2}, 4) = 0
 +0 getsockopt(3, IPPROTO_SCTP, SCTP_ADAPTATION_LAYER, {ssb_adaptation_ind=2}, [4]) = 0
 
++0 setsockopt(3, IPPROTO_SCTP, SCTP_EVENTS, {sctp_data_io_event=1, sctp_association_event=1, sctp_address_event=0, sctp_send_failure_event=1,
+sctp_peer_error_event=0, sctp_shutdown_event=1, sctp_partial_delivery_event=0, sctp_adaptation_layer_event=0, sctp_authentication_event=0,
+sctp_sender_dry_event=0}, 11) = 0
+
++0 getsockopt(3, IPPROTO_SCTP, SCTP_EVENTS, {sctp_data_io_event=1, sctp_association_event=1, sctp_address_event=0, sctp_send_failure_event=1,
+sctp_peer_error_event=0, sctp_shutdown_event=1, sctp_partial_delivery_event=0, sctp_adaptation_layer_event=0, sctp_authentication_event=0,
+sctp_sender_dry_event=0}, [11]) = 0
+
 +0 close(3) = 0

gtests/net/packetdrill/tests/bsd/sctp/sctp_socket_options.pkt

@@ -45,4 +45,8 @@
 +0 setsockopt(3, IPPROTO_SCTP, SCTP_PEER_ADDR_PARAMS, {spp_address={sa_family=AF_INET, sin_port=htons(8080), sin_addr=inet_addr("192.0.2.1")},
 spp_hbinterval=30000, spp_pathmaxrxt=100, spp_pathmtu=1468, spp_flags=0, spp_ipv6_flowlabel=0, spp_dscp=0}, 152) = 0
 
++0 setsockopt(3, IPPROTO_SCTP, SCTP_EVENTS, {sctp_data_io_event=1, sctp_association_event=0, sctp_address_event=0, sctp_send_failure_event=0,
+sctp_peer_error_event=0, sctp_shutdown_event=0, sctp_partial_delivery_event=0, sctp_adaptation_layer_event=0, sctp_authentication_event=0,
+sctp_sender_dry_event=0}, 11) = 0
+
 +0 close(3) = 0