///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000-2016 Ericsson Telecom AB
//
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v10.html
///////////////////////////////////////////////////////////////////////////////
//
//  File:               SCTP_Types.ttcn
//  Description:        Type definition for SCTP
//  Rev:                R1B
//  Prodnr:             CNL 113 830
//  Reference:          RFC4690
//
module SCTP_Types{

  external function f_SCTP_enc(in SCTP_Packet pl_pdu) return octetstring
  with {
    extension "prototype(convert)"
  }
  external function f_SCTP_dec(in octetstring pl_stream, out SCTP_Packet pl_pdu) return integer
  with {
    extension "prototype(backtrack)"
  }


  type integer SCTP_INT1 with {variant "FIELDLENGTH(8), COMP(nosign)"}
  type integer SCTP_INT2 with {variant "FIELDLENGTH(16), COMP(nosign), BYTEORDER(last)"}
  type integer SCTP_INT4 with {variant "FIELDLENGTH(32), COMP(nosign), BYTEORDER(last)"}
  type bitstring BIT_FLAG length(1)


  type record SCTP_Packet{
    SCTP_Common_header    common_header,
    SCTP_Chunk_List       chunks
  } with {
    variant ""
  }
  
  type record of SCTP_Chunk SCTP_Chunk_List;
  
  type union SCTP_Chunk{
    SCTP_Data_chunk      data,
    SCTP_Init_chunk      init,
    SCTP_InitAck_chunk   init_ack,
    SCTP_SAck_chunk      sack,
    SCTP_Heartbeat_chunk heartbeat,
    SCTP_Heartbeat_ack_chunk heartbeat_ack,
    SCTP_abort_chunk     abort,
    SCTP_Shutdown_chunk  shutdown,
    SCTP_Shutdown_ack_chunk shutdown_ack,
    SCTP_error_chunk     error_,
    SCTP_CookieEcho_chunk cookie_echo,
    SCTP_Cookie_ack_chunk cookie_ack,
    SCTP_ShutdownComplete_chunk shutdown_complete,
    SCTP_Auth_chunk      auth,
    SCTP_IData_chunk     idata,
    SCTP_ASCONF_ack_chunk asconf_ack,
    SCTP_Re_Config_chunk re_config,
    SCTP_Padding_chunk   padding,
    SCTP_Forward_TSN_chunk forward_tsn,
    SCTP_ASCONF_chunk    asconf,
    SCTP_IForward_TSN_chunk iforward_tsn,
    SCTP_Unknown_chunk   unknown_chunk
  } with {
    variant "PADDING(dword32)"
    variant "TAG( data, chunk_type = 0;
                  init, chunk_type = 1;
                  init_ack, chunk_type = 2;
                  sack, chunk_type = 3;
                  heartbeat, chunk_type = 4;
                  heartbeat_ack, chunk_type = 5;
                  abort, chunk_type = 6;
                  shutdown, chunk_type = 7;
                  shutdown_ack, chunk_type = 8;
                  error_, chunk_type = 9;
                  cookie_echo, chunk_type = 10;
                  cookie_ack, chunk_type = 11;
                  shutdown_complete, chunk_type = 14;
                  auth, chunk_type = 15;
                  idata, chunk_type = 64;
                  asconf_ack, chunk_type = 128;
                  re_config, chunk_type = 130;
                  padding, chunk_type = 132;
                  forward_tsn, chunk_type = 192;
                  asconf, chunk_type = 193;
                  iforward_tsn, chunk_type = 194;
                  unknown_chunk, OTHERWISE;
                )"
  }
  
  
  type record SCTP_Data_chunk{
    SCTP_INT1                 chunk_type (0),
    BIT_FLAG             E_flag,
    BIT_FLAG             B_flag,
    BIT_FLAG             U_flag,
    BIT_FLAG             I_flag,
    bitstring            res_flags length(4),
    SCTP_INT2                 chunk_length,
    SCTP_INT4                 tsn,
    SCTP_INT2                 stream_id,
    SCTP_INT2                 ssn,
    SCTP_INT4                 ppid,
    octetstring          user_data
    
  } with {
    variant "PRESENCE(chunk_type=0)"
    variant (chunk_length)  "LENGTHTO(chunk_type,E_flag,B_flag,U_flag,I_flag,res_flags,chunk_length,tsn,stream_id,ssn,ppid,user_data)"
  }

  
  type record SCTP_Init_chunk{
    SCTP_INT1                 chunk_type (1),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    SCTP_INT4                 init_tag,
    SCTP_INT4                 a_rwnd,
    SCTP_INT2                 os,
    SCTP_INT2                 mis,
    SCTP_INT4                 init_tsn,
    SCTP_Param_list      params optional
  } with {
    variant "PRESENCE(chunk_type=1)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,init_tag,a_rwnd,os,mis,init_tsn,params)"
  }

  type record SCTP_InitAck_chunk{
    SCTP_INT1                 chunk_type (2),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    SCTP_INT4                 init_tag,
    SCTP_INT4                 a_rwnd,
    SCTP_INT2                 os,
    SCTP_INT2                 mis,
    SCTP_INT4                 init_tsn,
    SCTP_Param_list      params optional
  } with {
    variant "PRESENCE(chunk_type=2)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,init_tag,a_rwnd,os,mis,init_tsn,params)"
  }

  type record SCTP_SAck_chunk{
    SCTP_INT1                 chunk_type (3),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    SCTP_INT4                 cum_tsn_ack,
    SCTP_INT4                 a_rwnd,
    SCTP_INT2                 no_of_gap_blocks,
    SCTP_INT2                 no_of_dup_tsn,
    record of SCTP_Gap_block gap_blocks optional,
    record of SCTP_INT4       dup_tsns optional
  } with {
    variant "PRESENCE(chunk_type=3)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,cum_tsn_ack,a_rwnd,no_of_gap_blocks,no_of_dup_tsn,gap_blocks,dup_tsns)"
    variant (no_of_gap_blocks) "LENGTHTO(gap_blocks), UNIT(elements)"
    variant (no_of_dup_tsn) "LENGTHTO(dup_tsns), UNIT(elements)"
  }
  
  type record SCTP_Gap_block{
    SCTP_INT2            start_tsn,
    SCTP_INT2            end_tsn
  }

  type record SCTP_Heartbeat_chunk{
    SCTP_INT1                 chunk_type (4),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    SCTP_Param_list      params optional
  } with {
    variant "PRESENCE(chunk_type=4)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,params)"
  }

  type record SCTP_Heartbeat_ack_chunk{
    SCTP_INT1                 chunk_type (5),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    SCTP_Param_list      params optional
  } with {
    variant "PRESENCE(chunk_type=5)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,params)"
  }


  type record SCTP_abort_chunk{
    SCTP_INT1                 chunk_type (6),
    BIT_FLAG             T_flag,
    bitstring            flags length(7),
    SCTP_INT2                 chunk_length,
    SCTP_Error_cause_list params optional
  } with {
    variant "PRESENCE(chunk_type=6)"
    variant (chunk_length)  "LENGTHTO(chunk_type,T_flag,flags,chunk_length,params)"
  }

  type record SCTP_Shutdown_chunk{
    SCTP_INT1                 chunk_type (7),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    SCTP_INT4                 cum_tsn_ack
  } with {
    variant "PRESENCE(chunk_type=7)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,cum_tsn_ack)"
  }

  type record SCTP_Shutdown_ack_chunk{
    SCTP_INT1                 chunk_type (8),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length
  } with {
    variant "PRESENCE(chunk_type=8)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length)"
  }


  type record SCTP_error_chunk{
    SCTP_INT1                 chunk_type (9),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    SCTP_Error_cause_list params optional
  } with {
    variant "PRESENCE(chunk_type=9)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,params)"
  }


  type record SCTP_CookieEcho_chunk{
    SCTP_INT1                 chunk_type (10),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    octetstring          cookie
  } with {
    variant "PRESENCE(chunk_type=10)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,cookie)"
  }


  type record SCTP_Cookie_ack_chunk{
    SCTP_INT1                 chunk_type (11),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length
  } with {
    variant "PRESENCE(chunk_type=11)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length)"
  }


  type record SCTP_ShutdownComplete_chunk{
    SCTP_INT1                 chunk_type (14),
    BIT_FLAG             T_flag,
    bitstring            flags length(7),
    SCTP_INT2                 chunk_length
  } with {
    variant "PRESENCE(chunk_type=14)"
    variant (chunk_length)  "LENGTHTO(chunk_type,T_flag,flags,chunk_length)"
  }

  type record SCTP_Auth_chunk{
    SCTP_INT1                 chunk_type (15),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    SCTP_INT2                 key_id,
    SCTP_INT2                 hmac_id,
    octetstring          hmac
  } with {
    variant "PRESENCE(chunk_type=15)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,key_id,hmac_id,hmac)"
  }

  type record SCTP_IData_chunk{
    SCTP_INT1                 chunk_type (64),
    BIT_FLAG             E_flag,
    BIT_FLAG             B_flag,
    BIT_FLAG             U_flag,
    BIT_FLAG             I_flag,
    bitstring            res_flags length(4),
    SCTP_INT2                 chunk_length,
    SCTP_INT4                 tsn,
    SCTP_INT2                 stream_id,
    SCTP_INT2                 reserved,
    SCTP_INT4                 mid,
    SCTP_INT4                 ppid_fsn,
    octetstring          user_data
    
  } with {
    variant "PRESENCE(chunk_type=64)"
    variant (chunk_length)  "LENGTHTO(chunk_type,E_flag,B_flag,U_flag,I_flag,res_flags,chunk_length,tsn,stream_id,reserved,mid,ppid_fsn,user_data)"
  }

  type record SCTP_ASCONF_ack_chunk{
    SCTP_INT1                 chunk_type (128),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    SCTP_INT4                 seq_no,
    SCTP_Param_list      params optional
  } with {
    variant "PRESENCE(chunk_type=128)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,seq_no,params)"
  }
 

  type record SCTP_Re_Config_chunk{
    SCTP_INT1                 chunk_type (130),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    SCTP_Param_list params optional
  } with {
    variant "PRESENCE(chunk_type=130)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,params)"
  }

  type record SCTP_Padding_chunk{
    SCTP_INT1                 chunk_type (132),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    octetstring          padding
  } with {
    variant "PRESENCE(chunk_type=132)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,padding)"
  }

  type record SCTP_Forward_TSN_chunk{
    SCTP_INT1                 chunk_type (192),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    SCTP_INT4                 new_tsn,
    record of  SCTP_Forward_TSN_streamdata  stream_ssn_list
  } with {
    variant "PRESENCE(chunk_type=192)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,new_tsn,stream_ssn_list)"
  }

  type record SCTP_Forward_TSN_streamdata{
    SCTP_INT2    stream_id,
    SCTP_INT2    ssn
  }

  type record SCTP_ASCONF_chunk{
    SCTP_INT1                 chunk_type (193),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    SCTP_INT4                 seq_no,
    SCTP_Param_list      params optional
  } with {
    variant "PRESENCE(chunk_type=193)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,seq_no,params)"
  }
  
  type record SCTP_IForward_TSN_chunk{
    SCTP_INT1                 chunk_type (194),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    SCTP_INT4                 new_tsn,
    record of  SCTP_IForward_TSN_streamdata  stream_ssn_list
  } with {
    variant "PRESENCE(chunk_type=194)"
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,new_tsn,stream_ssn_list)"
  }

  type record SCTP_IForward_TSN_streamdata{
    SCTP_INT2    stream_id,
    SCTP_INT2    reserved,
    SCTP_INT4    mid
  }
  
  type record SCTP_Unknown_chunk{
    SCTP_INT1                 chunk_type (0..255),
    bitstring            flags length(8),
    SCTP_INT2                 chunk_length,
    octetstring          chunk_value
  } with {
    variant (chunk_length)  "LENGTHTO(chunk_type,flags,chunk_length,chunk_value)"
  }
  

  type record of SCTP_Error_cause SCTP_Error_cause_list;
  
  type union SCTP_Error_cause {
    SCTP_Invalid_StreamId_cause     invalid_streamId,
    SCTP_Missing_mand_param_cause   missing_params,
    SCTP_Stale_cookie_cause         stale_cookie,
    SCTP_Out_of_res_cause           out_of_resources,
    SCTP_Unresolvable_addr_cause    unresolvable_addr,
    SCTP_Unrecognized_chunk_cause   unrecognized_chunk,
    SCTP_Invalid_mand_param_cause   invalid_mandatory_param,
    SCTP_Unrecognized_params_cause  unrecognized_params,
    SCTP_No_User_data_cause         no_user_data,
    SCTP_Cookie_while_shutdown_cause cookie_while_shutdown,
    SCTP_Restart_with_new_addr_cause restart_with_new_addr,
    SCTP_User_abort_cause           user_abort,
    SCTP_Protocol_violation_cause   protocol_violation,
    SCTP_Req_del_last_ip_cause      req_del_last_ip,
    SCTP_Refused_res_shortage_cause refused_res_shortage,
    SCTP_Req_del_source_ip_cause    req_del_source_ip,
    SCTP_Illegal_ASCONF_cause       illegal_asconf,
    SCTP_No_atuhorization_cause     no_authorization,
    SCTP_UnsupportedHMAC_cause      unsupported_hmac,
    SCTP_Unknown_error_cause        unknown_cause
  } with {
    variant "PADDING(dword32)"
  }

  type record SCTP_Invalid_StreamId_cause{
    SCTP_INT2              cause_code(1),
    SCTP_INT2              cause_length,
    SCTP_INT2              streamId,
    SCTP_INT2              reserved
  } with {
    variant "PRESENCE(cause_code=1)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,streamId,reserved)"
  }

  type record SCTP_Missing_mand_param_cause{
    SCTP_INT2              cause_code(2),
    SCTP_INT2              cause_length,
    SCTP_INT4              num_of_params,
    record of SCTP_INT2    missing_type
  } with {
    variant "PRESENCE(cause_code=2)"
    variant (num_of_params) "LENGTHTO(missing_type), UNIT(elements)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,num_of_params,missing_type)"
  }

  type record SCTP_Stale_cookie_cause{
    SCTP_INT2              cause_code(3),
    SCTP_INT2              cause_length,
    SCTP_INT4              measure
  } with {
    variant "PRESENCE(cause_code=3)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,measure)"
  }

  type record SCTP_Out_of_res_cause{
    SCTP_INT2              cause_code(4),
    SCTP_INT2              cause_length
  } with {
    variant "PRESENCE(cause_code=4)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length)"
  }

  type record SCTP_Unresolvable_addr_cause{
    SCTP_INT2              cause_code(5),
    SCTP_INT2              cause_length,
    octetstring       addr
  } with {
    variant "PRESENCE(cause_code=5)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,addr)"
  }

  type record SCTP_Unrecognized_chunk_cause{
    SCTP_INT2              cause_code(6),
    SCTP_INT2              cause_length,
    octetstring       chunk
  } with {
    variant "PRESENCE(cause_code=6)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,chunk)"
  }

  type record SCTP_Invalid_mand_param_cause{
    SCTP_INT2              cause_code(7),
    SCTP_INT2              cause_length
  } with {
    variant "PRESENCE(cause_code=7)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length)"
  }

  type record SCTP_Unrecognized_params_cause{
    SCTP_INT2              cause_code(8),
    SCTP_INT2              cause_length,
    octetstring       params
  } with {
    variant "PRESENCE(cause_code=8)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,params)"
  }
  
  type record SCTP_No_User_data_cause{
    SCTP_INT2              cause_code(9),
    SCTP_INT2              cause_length,
    SCTP_INT4              tsn
  } with {
    variant "PRESENCE(cause_code=9)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,tsn)"
  }

  type record SCTP_Cookie_while_shutdown_cause{
    SCTP_INT2              cause_code(10),
    SCTP_INT2              cause_length
  } with {
    variant "PRESENCE(cause_code=10)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length)"
  }

  type record SCTP_Restart_with_new_addr_cause{
    SCTP_INT2              cause_code(11),
    SCTP_INT2              cause_length,
    octetstring       new_addr
  } with {
    variant "PRESENCE(cause_code=11)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,new_addr)"
  }
  
  type record SCTP_User_abort_cause{
    SCTP_INT2              cause_code(12),
    SCTP_INT2              cause_length,
    octetstring       reason
  } with {
    variant "PRESENCE(cause_code=12)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,reason)"
  }
  
  type record SCTP_Protocol_violation_cause{
    SCTP_INT2              cause_code(13),
    SCTP_INT2              cause_length,
    octetstring       reason
  } with {
    variant "PRESENCE(cause_code=13)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,reason)"
  }
  
  type record SCTP_Req_del_last_ip_cause{
    SCTP_INT2              cause_code(160),
    SCTP_INT2              cause_length,
    octetstring       tlv
  } with {
    variant "PRESENCE(cause_code=160)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,tlv)"
  }
  
  type record SCTP_Refused_res_shortage_cause{
    SCTP_INT2              cause_code(161),
    SCTP_INT2              cause_length,
    octetstring       tlv
  } with {
    variant "PRESENCE(cause_code=161)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,tlv)"
  }
  
  type record SCTP_Req_del_source_ip_cause{
    SCTP_INT2              cause_code(162),
    SCTP_INT2              cause_length,
    octetstring       tlv
  } with {
    variant "PRESENCE(cause_code=162)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,tlv)"
  }
  
  type record SCTP_Illegal_ASCONF_cause{
    SCTP_INT2              cause_code(163),
    SCTP_INT2              cause_length
  } with {
    variant "PRESENCE(cause_code=163)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length)"
  }
  
  type record SCTP_No_atuhorization_cause{
    SCTP_INT2              cause_code(164),
    SCTP_INT2              cause_length,
    octetstring       tlv
  } with {
    variant "PRESENCE(cause_code=164)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,tlv)"
  }
  
  type record SCTP_UnsupportedHMAC_cause{
    SCTP_INT2              cause_code(261),
    SCTP_INT2              cause_length,
    SCTP_INT2              hmac
  } with {
    variant "PRESENCE(cause_code=261)"
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,hmac)"
  }
  
  type record SCTP_Unknown_error_cause{
    SCTP_INT2              cause_code,
    SCTP_INT2              cause_length,
    octetstring       cause_value
  } with {
    variant (cause_length)  "LENGTHTO(cause_code,cause_length,cause_value)"
  }


  type record of SCTP_parameters SCTP_Param_list;
  
  type union SCTP_parameters{
    SCTP_Hearbeat_info_parameter        heartbeat_info,
    SCTP_IPv4_parameter                 ipv4_addr,
    SCTP_IPv6_parameter                 ipv6_addr,
    SCTP_StateCookie_parameter          state_cookie,
    SCTP_unrecognized_params_parameter  unrecognized_params,
    SCTP_Cookie_pres_parameter          cookie_preservative,
    SCTP_HostNameAddr_parameter         hostname,
    SCTP_Supported_addr_types_parameter supported_addr_types,
    SCTP_Out_SSN_Reset_req_parameter    out_ssn_reset_req,
    SCTP_In_SSN_Reset_req_parameter     in_ssn_reset_req,
    SCTP_SSN_TSN_Reset_req_parameter    ssn_tsn_reset_req,
    SCTP_Reconf_resp_parameter          reconf_resp,
    SCTP_Add_out_stream_req_parameter   add_out_stream,
    SCTP_Add_in_stream_req_parameter    add_in_stream,
    SCTP_Random_parameter               random,
    SCTP_chunk_list_parameter           chunk_list,
    SCTP_Req_HMAC_parameter             req_HMAC,
    SCTP_Padding_parameter              padding,
    SCTP_Supported_extensions_parameter supported_extensions,
    SCTP_Forward_TSN_Supported_parameter forward_tsn_supported,
    SCTP_Add_IP_addr_parameter          add_address,
    SCTP_Del_IP_addr_parameter          del_address,
    SCTP_Error_cause_parameter          error_cause,
    SCTP_Set_Pri_IP_addr_parameter      set_primary_addr,
    SCTP_Success_Ind_parameter          success_ind,
    SCTP_Adaptation_layer_Ind_parameter adaptation_layer_ind,
    SCTP_Unknown_parameter              unknown_param
  } with {
    variant "PADDING(dword32)"
  }

  type record SCTP_Hearbeat_info_parameter{
    SCTP_INT2              param_type(1),
    SCTP_INT2              param_length,
    octetstring       info
  } with {
    variant "PRESENCE(param_type=1)"
    variant (param_length)  "LENGTHTO(param_type,param_length,info)"
  }

  type record SCTP_IPv4_parameter{
    SCTP_INT2              param_type(5),
    SCTP_INT2              param_length,
    octetstring       ipv4_addr
  } with {
    variant "PRESENCE(param_type=5)"
    variant (param_length)  "LENGTHTO(param_type,param_length,ipv4_addr)"
  }

  type record SCTP_IPv6_parameter{
    SCTP_INT2              param_type(6),
    SCTP_INT2              param_length,
    octetstring       ipv6_addr
  } with {
    variant "PRESENCE(param_type=6)"
    variant (param_length)  "LENGTHTO(param_type,param_length,ipv6_addr)"
  }

  type record SCTP_StateCookie_parameter{
    SCTP_INT2              param_type(7),
    SCTP_INT2              param_length,
    octetstring       state_cookie
  } with {
    variant "PRESENCE(param_type=7)"
    variant (param_length)  "LENGTHTO(param_type,param_length,state_cookie)"
  }

  type record SCTP_unrecognized_params_parameter{
    SCTP_INT2              param_type(8),
    SCTP_INT2              param_length,
    octetstring       unrecognized_params
  } with {
    variant "PRESENCE(param_type=8)"
    variant (param_length)  "LENGTHTO(param_type,param_length,unrecognized_params)"
  }

  type record SCTP_Cookie_pres_parameter{
    SCTP_INT2              param_type(9),
    SCTP_INT2              param_length,
    SCTP_INT2              suggested_incr
  } with {
    variant "PRESENCE(param_type=9)"
    variant (param_length)  "LENGTHTO(param_type,param_length,suggested_incr)"
  }

  type record SCTP_HostNameAddr_parameter{
    SCTP_INT2              param_type(11),
    SCTP_INT2              param_length,
    octetstring       host_name
  } with {
    variant "PRESENCE(param_type=11)"
    variant (param_length)  "LENGTHTO(param_type,param_length,host_name)"
  }

  type record SCTP_Supported_addr_types_parameter{
    SCTP_INT2              param_type(12),
    SCTP_INT2              param_length,
    record of SCTP_INT2    supported_addr_types
  } with {
    variant "PRESENCE(param_type=12)"
    variant (param_length)  "LENGTHTO(param_type,param_length,supported_addr_types)"
  }

  type record SCTP_Out_SSN_Reset_req_parameter{
    SCTP_INT2              param_type(13),
    SCTP_INT2              param_length,
    SCTP_INT4              reconf_req_seq,
    SCTP_INT4              reconf_resp_seq,
    SCTP_INT4              last_assigned_tsn,
    record of SCTP_INT2    stream_numbers optional
  } with {
    variant "PRESENCE(param_type=13)"
    variant (param_length)  "LENGTHTO(param_type,param_length,reconf_req_seq,reconf_resp_seq,last_assigned_tsn,stream_numbers)"
  }

  type record SCTP_In_SSN_Reset_req_parameter{
    SCTP_INT2              param_type(14),
    SCTP_INT2              param_length,
    SCTP_INT4              reconf_req_seq,
    record of SCTP_INT2    stream_numbers optional
  } with {
    variant "PRESENCE(param_type=14)"
    variant (param_length)  "LENGTHTO(param_type,param_length,reconf_req_seq,stream_numbers)"
  }

  type record SCTP_SSN_TSN_Reset_req_parameter{
    SCTP_INT2              param_type(15),
    SCTP_INT2              param_length,
    SCTP_INT4              reconf_req_seq
  } with {
    variant "PRESENCE(param_type=15)"
    variant (param_length)  "LENGTHTO(param_type,param_length,reconf_req_seq)"
  }

  type record SCTP_Reconf_resp_parameter{
    SCTP_INT2              param_type(16),
    SCTP_INT2              param_length,
    SCTP_INT4              reconf_resp_seq,
    SCTP_INT4              result,
    SCTP_INT4              sender_next_tsn optional,
    SCTP_INT4              receiver_next_tsn optional
  } with {
    variant "PRESENCE(param_type=16)"
    variant (param_length)  "LENGTHTO(param_type,param_length,reconf_resp_seq,result,sender_next_tsn,receiver_next_tsn)"
  }

  type record SCTP_Add_out_stream_req_parameter{
    SCTP_INT2              param_type(17),
    SCTP_INT2              param_length,
    SCTP_INT4              reconf_req_seq,
    SCTP_INT2              stream_num,
    SCTP_INT2              reserved
  } with {
    variant "PRESENCE(param_type=17)"
    variant (param_length)  "LENGTHTO(param_type,param_length,reconf_req_seq,stream_num,reserved)"
  }

  type record SCTP_Add_in_stream_req_parameter{
    SCTP_INT2              param_type(18),
    SCTP_INT2              param_length,
    SCTP_INT4              reconf_req_seq,
    SCTP_INT2              stream_num,
    SCTP_INT2              reserved
  } with {
    variant "PRESENCE(param_type=18)"
    variant (param_length)  "LENGTHTO(param_type,param_length,reconf_req_seq,stream_num,reserved)"
  }

  type record SCTP_Random_parameter{
    SCTP_INT2              param_type(32770),
    SCTP_INT2              param_length,
    octetstring       random
  } with {
    variant "PRESENCE(param_type=32770)"
    variant (param_length)  "LENGTHTO(param_type,param_length,random)"
  }

  type record SCTP_chunk_list_parameter{
    SCTP_INT2              param_type(32771),
    SCTP_INT2              param_length,
    record of SCTP_INT1    chunk_list
  } with {
    variant "PRESENCE(param_type=32771)"
    variant (param_length)  "LENGTHTO(param_type,param_length,chunk_list)"
  }

  type record SCTP_Req_HMAC_parameter{
    SCTP_INT2              param_type(32772),
    SCTP_INT2              param_length,
    record of SCTP_INT2    HMAC_IDs
  } with {
    variant "PRESENCE(param_type=32772)"
    variant (param_length)  "LENGTHTO(param_type,param_length,HMAC_IDs)"
  }

  type record SCTP_Padding_parameter{
    SCTP_INT2              param_type(32773),
    SCTP_INT2              param_length,
    octetstring       padding
  } with {
    variant "PRESENCE(param_type=32773)"
    variant (param_length)  "LENGTHTO(param_type,param_length,padding)"
  }

  type record SCTP_Supported_extensions_parameter{
    SCTP_INT2              param_type(32776),
    SCTP_INT2              param_length,
    record of SCTP_INT1    supported_extensions
  } with {
    variant "PRESENCE(param_type=32776)"
    variant (param_length)  "LENGTHTO(param_type,param_length,supported_extensions)"
  }
  
  type record SCTP_Forward_TSN_Supported_parameter{
    SCTP_INT2              param_type(49152),
    SCTP_INT2              param_length
  } with {
    variant "PRESENCE(param_type=49152)"
    variant (param_length)  "LENGTHTO(param_type,param_length)"
  }
  
  type record SCTP_Add_IP_addr_parameter{
    SCTP_INT2              param_type(49153),
    SCTP_INT2              param_length,
    SCTP_INT4              asconf_req_id,
    SCTP_parameters   addr
  } with {
    variant "PRESENCE(param_type=49153)"
    variant (param_length)  "LENGTHTO(param_type,param_length,asconf_req_id,addr)"
  }
  
  type record SCTP_Del_IP_addr_parameter{
    SCTP_INT2              param_type(49154),
    SCTP_INT2              param_length,
    SCTP_INT4              asconf_req_id,
    SCTP_parameters   addr
  } with {
    variant "PRESENCE(param_type=49154)"
    variant (param_length)  "LENGTHTO(param_type,param_length,asconf_req_id,addr)"
  }
  
  type record SCTP_Error_cause_parameter{
    SCTP_INT2              param_type(49155),
    SCTP_INT2              param_length,
    SCTP_INT4              asconf_req_id,
    SCTP_Error_cause_list   causes
  } with {
    variant "PRESENCE(param_type=49155)"
    variant (param_length)  "LENGTHTO(param_type,param_length,asconf_req_id,causes)"
  }

  type record SCTP_Set_Pri_IP_addr_parameter{
    SCTP_INT2              param_type(49156),
    SCTP_INT2              param_length,
    SCTP_INT4              asconf_req_id,
    SCTP_parameters   addr
  } with {
    variant "PRESENCE(param_type=49156)"
    variant (param_length)  "LENGTHTO(param_type,param_length,asconf_req_id,addr)"
  }
 
  type record SCTP_Success_Ind_parameter{
    SCTP_INT2              param_type(49157),
    SCTP_INT2              param_length,
    SCTP_INT4              asconf_req_id
  } with {
    variant "PRESENCE(param_type=49157)"
    variant (param_length)  "LENGTHTO(param_type,param_length,asconf_req_id)"
  }
 
  type record SCTP_Adaptation_layer_Ind_parameter{
    SCTP_INT2              param_type(49157),
    SCTP_INT2              param_length,
    SCTP_INT4              code_point
  } with {
    variant "PRESENCE(param_type=49157)"
    variant (param_length)  "LENGTHTO(param_type,param_length,code_point)"
  }
 
  
  type record SCTP_Unknown_parameter{
    SCTP_INT2              param_type,
    SCTP_INT2              param_length,
    octetstring       param_value
  } with {
    variant (param_length)  "LENGTHTO(param_type,param_length,param_value)"
  }

  type record SCTP_Common_header{
    SCTP_INT2                 source_port (0..65535),
    SCTP_INT2                 destination_port (0..65535),
    SCTP_INT4                 verification_tag,
    octetstring          checksum length(4)
  } with {
    variant (verification_tag) "FIELDLENGTH(32)"
  }

} with { encode "RAW" }