| blob | dbcb1579c4bdd31b8bf0ba8a0fb3272b3f1eb0f9 |
1 /* packet-sctp.c
2 * Routines for Stream Control Transmission Protocol dissection
3 * Copyright 2000-2012 Michael Tuexen <tuexen [AT] fh-muenster.de>
4 * Copyright 2011-2021 Thomas Dreibholz <dreibh [AT] iem.uni-due.de>
5 *
6 * Wireshark - Network traffic analyzer
7 * By Gerald Combs <gerald@wireshark.org>
8 * Copyright 1998 Gerald Combs
9 *
10 * SPDX-License-Identifier: GPL-2.0-or-later
11 */
12 /*
13 * It should be compliant to
14 * - RFC 2960
15 * - RFC 3309
16 * - RFC 3758
17 * - RFC 4460
18 * - RFC 4895
19 * - RFC 4960
20 * - RFC 5061
21 * - RFC 6525
22 * - RFC 7053
23 * - https://tools.ietf.org/html/draft-stewart-sctp-pktdrprep-02
24 * - https://www.ietf.org/archive/id/draft-ietf-tsvwg-sctp-zero-checksum-01.html
25 *
26 * Still to do (so stay tuned)
27 * - error checking mode
28 * * padding errors
29 * * length errors
30 * * bundling errors
31 * * value errors
32 *
33 * Reassembly added 2006 by Robin Seggelmann
34 * TSN Tracking by Luis E. G. Ontanon (Feb 2007)
35 * Copyright 2009, Varun Notibala <nbvarun [AT] gmail.com>
36 *
37 * PPID types updated by Thomas Dreibholz (Feb 2011)
38 */
46 #include <epan/packet.h>
47 #include <epan/capture_dissectors.h>
48 #include <epan/prefs.h>
49 #include <epan/exceptions.h>
50 #include <epan/exported_pdu.h>
51 #include <epan/ipproto.h>
52 #include <epan/addr_resolv.h>
53 #include <epan/sctpppids.h>
54 #include <epan/uat.h>
55 #include <epan/expert.h>
56 #include <epan/conversation_table.h>
57 #include <epan/show_exception.h>
58 #include <epan/decode_as.h>
59 #include <epan/proto_data.h>
60 #include <epan/tfs.h>
61 #include <wsutil/array.h>
63 #include <wsutil/crc32.h>
64 #include <wsutil/adler32.h>
65 #include <wsutil/utf8_entities.h>
66 #include <wsutil/str_util.h>
67 #include <wsutil/ws_roundup.h>
71 #define LT(x, y) ((int32_t)((x) - (y)) < 0)
73 #define UDP_TUNNELING_PORT 9899
75 #define MAX_NUMBER_OF_PPIDS 2
76 /** This is a valid PPID, but we use it to mark the end of the list */
77 #define LAST_PPID 0xffffffff
82 /* Initialize the protocol and registered fields */
270 /* Initialize the subtree pointers */
349 #define CHUNK_TYPE_LENGTH 1
350 #define CHUNK_FLAGS_LENGTH 1
351 #define CHUNK_LENGTH_LENGTH 2
352 #define CHUNK_HEADER_LENGTH (CHUNK_TYPE_LENGTH + \
353 CHUNK_FLAGS_LENGTH + \
354 CHUNK_LENGTH_LENGTH)
355 #define CHUNK_HEADER_OFFSET 0
356 #define CHUNK_TYPE_OFFSET CHUNK_HEADER_OFFSET
357 #define CHUNK_FLAGS_OFFSET (CHUNK_TYPE_OFFSET + CHUNK_TYPE_LENGTH)
358 #define CHUNK_LENGTH_OFFSET (CHUNK_FLAGS_OFFSET + CHUNK_FLAGS_LENGTH)
359 #define CHUNK_VALUE_OFFSET (CHUNK_LENGTH_OFFSET + CHUNK_LENGTH_LENGTH)
361 #define PARAMETER_TYPE_LENGTH 2
362 #define PARAMETER_LENGTH_LENGTH 2
363 #define PARAMETER_HEADER_LENGTH (PARAMETER_TYPE_LENGTH + PARAMETER_LENGTH_LENGTH)
365 #define PARAMETER_HEADER_OFFSET 0
366 #define PARAMETER_TYPE_OFFSET PARAMETER_HEADER_OFFSET
367 #define PARAMETER_LENGTH_OFFSET (PARAMETER_TYPE_OFFSET + PARAMETER_TYPE_LENGTH)
368 #define PARAMETER_VALUE_OFFSET (PARAMETER_LENGTH_OFFSET + PARAMETER_LENGTH_LENGTH)
370 #define SOURCE_PORT_LENGTH 2
371 #define DESTINATION_PORT_LENGTH 2
372 #define VERIFICATION_TAG_LENGTH 4
373 #define CHECKSUM_LENGTH 4
374 #define COMMON_HEADER_LENGTH (SOURCE_PORT_LENGTH + \
375 DESTINATION_PORT_LENGTH + \
376 VERIFICATION_TAG_LENGTH + \
377 CHECKSUM_LENGTH)
378 #define SOURCE_PORT_OFFSET 0
379 #define DESTINATION_PORT_OFFSET (SOURCE_PORT_OFFSET + SOURCE_PORT_LENGTH)
380 #define VERIFICATION_TAG_OFFSET (DESTINATION_PORT_OFFSET + DESTINATION_PORT_LENGTH)
381 #define CHECKSUM_OFFSET (VERIFICATION_TAG_OFFSET + VERIFICATION_TAG_LENGTH)
383 #define SCTP_CHECKSUM_NONE 0
384 #define SCTP_CHECKSUM_ADLER32 1
385 #define SCTP_CHECKSUM_CRC32C 2
386 #define SCTP_CHECKSUM_AUTOMATIC 3
388 #define FORWARD_STREAM 0
389 #define BACKWARD_STREAM 1
390 #define FORWARD_ADD_FORWARD_VTAG 2
391 #define BACKWARD_ADD_FORWARD_VTAG 3
392 #define BACKWARD_ADD_BACKWARD_VTAG 4
393 #define ASSOC_NOT_FOUND 5
395 /* Default values for preferences */
405 /* Data types and functions for generation/handling of chunk types for chunk statistics */
411 };
424 address saddr;
425 address daddr;
446 {
452 }
454 static void
456 {
459 }
461 static bool
463 {
469 }
475 }
477 /* Check for invalid characters (to avoid asserting out when
478 * registering the field).
479 */
484 }
488 }
494 static bool
496 {
497 /* If zero (unknown) tags match anything. Nonzero tags must be the same. */
500 }
502 }
506 {
520 }
522 static unsigned
524 {
527 /* Add the ports so that the hash is the same regardless of direction */
529 }
531 static unsigned
533 {
536 // When inserting in this map, we know we have both vtags.
537 // Hash via the first one (we expect vtag collisions will be low.)
538 // When looking up with a entry from a packet that only has one vtag,
539 // we'll reverse the temporary key as necessary.
541 }
543 /* Association comparison strategy:
544 * 1. Ports MUST match.
545 * 2. Assume vtag collisions are rare compared to multihoming. Thus:
546 * 3. If we have already discovered the vtags on both sides (e.g., with an
547 * INIT ACK, which contains both sides) and the ports match, don't require
548 * address matches.
549 * 4. If we have two keys each with 1 matching vtag in the same direction (and
550 * the other vtag 0), don't require address matches; if there are new addresses
551 * assume it's multihoming.
552 * 5. However, if we have two keys each with 1 vtag (and the other tag 0)
553 * that are different but could be the two vtags of one association
554 * (e.g., two unmatched DATA chunks in the opposite direction, or an INIT
555 * and a DATA in the same direction) require address matching. Otherwise
556 * we'll make likely spurious matches.
557 * 6. Don't worry about odd possibilities like both sides of an association
558 * chosing the same vtag.
559 * 7. We ought to track additional addresses given in INIT, INIT ACK, ASCONF.
560 * If we do, we could have an option of more strict association matching
561 * that uses the addresses in all cases and is more similar to what SCTP
562 * stacks actually do. We'd have to store a list/map/set of known source
563 * and destinatiion addresses instead of just one each. This would fail in
564 * the case of multihoming and where we missed the configuration messages
565 * setting up multihoming.
566 */
568 static gboolean
570 {
574 /* Matching for associations where for the entries already in the table
575 * only have one vtag, and have zero for the other direction. (For an
576 * new INIT ACK, we know both directions.)
577 */
580 // Forward match
583 // Possible INIT and DATA in the same direction, where we didn't get
584 // the INIT ACK. Call it a match if the addresses match.
587 }
591 }
592 }
594 // Reverse direction (not an else so we can handle identical ports)
597 // Possible two DATAs chunks in the opposite direction, where we
598 // didn't get the INIT ACK. Call it a match if the addresses match.
601 }
605 }
606 }
609 }
611 static gboolean
613 {
617 /*
618 * Matching for associations where for the entries already in the map
619 * we know the vtags in each direction.
620 * We will not check addresses.
621 */
624 // Forward match
625 // ASSERTION: at least one of the verification tags must be nonzero.
629 }
630 }
632 // Reverse direction (not an else so we can handle identical ports)
636 }
637 }
640 }
642 static infodata_t
644 {
646 infodata_t inf;
650 /* At least one of tmpinfo's vtag1 must be nonzero (both might be, if
651 * it's an INIT ACK.) Lookup in the proper direction(s).
652 */
659 }
660 }
669 }
670 }
689 }
692 }
695 /* Now figure out why we matched and fill in new information. */
699 /* We already checked the addresses if needed when looking up in the map. */
702 }
705 }
708 /* We already checked the addresses if needed when looking up in the map. */
712 }
715 }
716 }
722 }
723 }
726 }
728 static void
730 {
731 uint32_t port = GPOINTER_TO_UINT(p_get_proto_data(pinfo->pool, pinfo, hf_source_port, pinfo->curr_layer_num));
734 }
738 {
740 }
742 static void
744 {
745 uint32_t port = GPOINTER_TO_UINT(p_get_proto_data(pinfo->pool, pinfo, hf_destination_port, pinfo->curr_layer_num));
748 }
752 {
754 }
756 static void
758 {
759 uint32_t srcport = GPOINTER_TO_UINT(p_get_proto_data(pinfo->pool, pinfo, hf_source_port, pinfo->curr_layer_num)),
760 destport = GPOINTER_TO_UINT(p_get_proto_data(pinfo->pool, pinfo, hf_destination_port, pinfo->curr_layer_num));
762 snprintf(result, MAX_DECODE_AS_PROMPT_LEN, "both (%u%s%u)", srcport, UTF8_LEFT_RIGHT_ARROW, destport);
763 }
765 static void
767 {
774 }
775 }
777 static void
779 {
786 }
787 }
791 {
793 }
797 {
799 }
802 {
814 }
821 }
828 }
835 }
838 }
842 static tap_packet_status
843 sctp_conversation_packet(void *pct, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
844 {
851 sctphdr->sport, sctphdr->dport, 1, pinfo->fd->pkt_len, &pinfo->rel_ts, &pinfo->abs_ts, &sctp_ct_dissector_info, CONVERSATION_SCTP);
855 }
857 static const char* sctp_endpoint_get_filter_type(endpoint_item_t* endpoint, conv_filter_type_e filter)
858 {
870 }
877 }
884 }
891 }
894 }
898 static tap_packet_status
899 sctp_endpoint_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, const void *vip, tap_flags_t flags)
900 {
906 /* Take two "add" passes per packet, adding for each direction, ensures that all
907 packets are counted properly (even if address is sending to itself)
908 XXX - this could probably be done more efficiently inside endpoint_table */
909 add_endpoint_table_data(hash, &sctphdr->ip_src, sctphdr->sport, true, 1, pinfo->fd->pkt_len, &sctp_endpoint_dissector_info, ENDPOINT_SCTP);
910 add_endpoint_table_data(hash, &sctphdr->ip_dst, sctphdr->dport, false, 1, pinfo->fd->pkt_len, &sctp_endpoint_dissector_info, ENDPOINT_SCTP);
913 }
915 static unsigned int
917 {
921 result = update_adler32(result, buf, SOURCE_PORT_LENGTH + DESTINATION_PORT_LENGTH + VERIFICATION_TAG_LENGTH);
922 /* handle four 0 bytes as checksum */
927 }
929 static uint32_t
931 {
937 /* CRC for header */
938 crc32 = crc32c_calculate_no_swap(buf, SOURCE_PORT_LENGTH + DESTINATION_PORT_LENGTH + VERIFICATION_TAG_LENGTH, CRC32C_PRELOAD);
940 /* handle four 0 bytes as checksum */
943 /* CRC for the rest of the packet */
949 }
951 /*
952 * Routines for dissecting parameters
953 */
957 static void dissect_parameter(tvbuff_t *, packet_info *, proto_tree *, proto_item *, bool, bool);
965 static bool dissect_data_chunk(tvbuff_t*, uint16_t, packet_info*, proto_tree*, proto_tree*, proto_item*, proto_item*, sctp_half_assoc_t*, bool);
970 /* TSN ANALYSIS CODE */
985 };
990 nstime_t ts;
998 nstime_t ts;
1002 nstime_t ts;
1012 {
1027 }
1031 {
1040 }
1049 {
1057 /* look for the current half_assoc by spt, dpt and vtag */
1061 /* found, if it has been already matched we're done */
1064 /* not found, make a new one and add it to the table */
1075 /* add this half to the table indexed by ports and vtag */
1077 }
1079 /* at this point we have an unmatched half, look for its other half using the ports and IP address */
1083 /*the table contains a pointer to a pointer to a half */
1085 /* if there is no half pointed by this, add the current half to the table */
1088 /* there's a half pointed by this, assume it's our peer and clear the table's pointer */
1092 }
1094 /* we found no entry in the table: add one (using reversed ports and src addresses) so that it can be matched later */
1098 }
1101 }
1103 /* Limit the number of retransmissions we track (to limit memory usage--and
1104 * tree size--in pathological cases, for example zero window probing forever).
1105 */
1106 #define MAX_RETRANS_TRACKED_PER_TSN 100
1108 static void
1111 {
1117 nstime_t rto;
1119 pi = proto_tree_add_uint(tsn_tree_pt, hf_sctp_retransmission, tvb, 0, 0, t->first_transmit.framenum);
1128 /* Detect reneged acks */
1129 /* XXX what if the frames aren't sorted by time? */
1131 {
1132 pi = proto_tree_add_uint_format(pt, hf_sctp_retransmitted_after_ack, tvb, 0, 0, t->ack.framenum,
1137 }
1140 nstime_t rto;
1145 else
1149 hf_sctp_retransmitted_count,
1154 ds);
1166 hf_sctp_retransmitted,
1174 }
1175 }
1178 nstime_t rtt;
1187 }
1188 }
1190 #define RELTSN(tsn) (((tsn) < h->first_tsn) ? (tsn + (0xffffffff - (h->first_tsn)) + 1) : (tsn - h->first_tsn))
1192 /* Returns true if the tsn is a retransmission (we've seen it before), false
1193 * otherwise.
1194 */
1195 static bool
1198 {
1204 /* no half assoc? nothing to do!*/
1211 /* If we're dissecting for a read filter in the GUI [tshark assigns
1212 * frame numbers before running the read filter], don't do the TSN
1213 * analysis. (We can't anyway because we don't have a valid frame
1214 * number...)
1215 *
1216 * Without this check if you load a capture file in the
1217 * GUI while using a read filter, every SCTP TSN is marked as a
1218 * retransmission of that in frame 0.
1219 */
1223 /* we have not seen any tsn yet in this half assoc set the ground */
1227 }
1232 /* printf("%.3d REL TSN: %p->%p [%u] %u \n",framenum,h,h->peer,tsn,reltsn); */
1234 /* look for this tsn in this half's tsn table */
1236 /* no tsn found, create a new one */
1244 }
1257 i++;
1258 }
1264 }
1265 }
1270 }
1272 static void
1275 {
1278 nstime_t rtt;
1294 }
1295 }
1297 static void
1300 {
1310 /* printf("%.6d ACK: %p->%p [%u] \n",framenum,h,h->peer,reltsn); */
1323 ;
1328 }
1329 }
1335 proto_tree_add_debug_text(acks_tree, tvb, 0 , 0, "Assoc: %p vs %p ?? %ld",h,h->peer,tsn);
1336 } */
1337 }
1339 #define RELTSNACK(tsn) (((tsn) < h->peer->first_tsn) ? ((tsn) + (0xffffffff - (h->peer->first_tsn)) + 1) : ((tsn) - h->peer->first_tsn))
1340 static void
1344 {
1359 /* printf("%.3d BACK: %p->%p [%u-%u]\n",framenum,h,h->peer,rel_start,rel_end); */
1362 /* printf("%.3d CACK: %p->%p [%u-%u]\n",framenum,h,h->peer,rel_start,rel_end); */
1363 }
1374 }
1377 }
1379 if (PINFO_FD_VISITED(pinfo) || rel_end < rel_start || rel_end - rel_start > 0xffff0000 ) return;
1389 }
1390 }
1391 }
1393 /* END TSN ANALYSIS CODE */
1398 #define HEARTBEAT_INFO_PARAMETER_INFO_OFFSET PARAMETER_VALUE_OFFSET
1400 static void
1401 dissect_heartbeat_info_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
1402 {
1405 heartbeat_info_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH;
1407 proto_tree_add_item(parameter_tree, hf_heartbeat_info, parameter_tvb, HEARTBEAT_INFO_PARAMETER_INFO_OFFSET, heartbeat_info_length, ENC_NA);
1408 proto_item_append_text(parameter_item, " (Information: %u byte%s)", heartbeat_info_length, plurality(heartbeat_info_length, "", "s"));
1409 }
1411 #define IPV4_ADDRESS_LENGTH 4
1412 #define IPV4_ADDRESS_OFFSET PARAMETER_VALUE_OFFSET
1414 static void
1415 dissect_ipv4_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item, proto_item *additional_item, bool dissecting_init_init_ack_chunk)
1416 {
1418 proto_tree_add_item(parameter_tree, hf_ipv4_address, parameter_tvb, IPV4_ADDRESS_OFFSET, IPV4_ADDRESS_LENGTH, ENC_BIG_ENDIAN);
1419 proto_item_append_text(parameter_item, " (Address: %s)", tvb_ip_to_str(wmem_packet_scope(), parameter_tvb, IPV4_ADDRESS_OFFSET));
1421 proto_item_append_text(additional_item, "%s", tvb_ip_to_str(wmem_packet_scope(), parameter_tvb, IPV4_ADDRESS_OFFSET));
1422 }
1426 else
1428 }
1429 }
1431 #define IPV6_ADDRESS_LENGTH 16
1432 #define IPV6_ADDRESS_OFFSET PARAMETER_VALUE_OFFSET
1434 static void
1435 dissect_ipv6_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item, proto_item *additional_item, bool dissecting_init_init_ack_chunk)
1436 {
1438 proto_tree_add_item(parameter_tree, hf_ipv6_address, parameter_tvb, IPV6_ADDRESS_OFFSET, IPV6_ADDRESS_LENGTH, ENC_NA);
1439 proto_item_append_text(parameter_item, " (Address: %s)", tvb_ip6_to_str(wmem_packet_scope(), parameter_tvb, IPV6_ADDRESS_OFFSET));
1441 proto_item_append_text(additional_item, "%s", tvb_ip6_to_str(wmem_packet_scope(), parameter_tvb, IPV6_ADDRESS_OFFSET));
1442 }
1446 else
1448 }
1449 }
1451 #define STATE_COOKIE_PARAMETER_COOKIE_OFFSET PARAMETER_VALUE_OFFSET
1453 static void
1454 dissect_state_cookie_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
1455 {
1458 state_cookie_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH;
1460 proto_tree_add_item(parameter_tree, hf_state_cookie, parameter_tvb, STATE_COOKIE_PARAMETER_COOKIE_OFFSET, state_cookie_length, ENC_NA);
1461 proto_item_append_text(parameter_item, " (Cookie length: %u byte%s)", state_cookie_length, plurality(state_cookie_length, "", "s"));
1462 }
1464 static void
1465 // NOLINTNEXTLINE(misc-no-recursion)
1466 dissect_unrecognized_parameters_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree)
1467 {
1468 /* FIXME: Does it contain one or more parameters? */
1469 dissect_parameter(tvb_new_subset_remaining(parameter_tvb, PARAMETER_VALUE_OFFSET), pinfo, parameter_tree, NULL, false, false);
1470 }
1472 #define COOKIE_PRESERVATIVE_PARAMETER_INCR_LENGTH 4
1473 #define COOKIE_PRESERVATIVE_PARAMETER_INCR_OFFSET PARAMETER_VALUE_OFFSET
1475 static void
1476 dissect_cookie_preservative_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
1477 {
1478 proto_tree_add_item(parameter_tree, hf_cookie_preservative_increment, parameter_tvb, COOKIE_PRESERVATIVE_PARAMETER_INCR_OFFSET, COOKIE_PRESERVATIVE_PARAMETER_INCR_LENGTH, ENC_BIG_ENDIAN);
1479 proto_item_append_text(parameter_item, " (Increment :%u msec)", tvb_get_ntohl(parameter_tvb, COOKIE_PRESERVATIVE_PARAMETER_INCR_OFFSET));
1480 }
1482 #define HOSTNAME_OFFSET PARAMETER_VALUE_OFFSET
1484 static void
1485 dissect_hostname_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item, proto_item *additional_item)
1486 {
1490 hostname_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH;
1491 proto_tree_add_item_ret_display_string(parameter_tree, hf_hostname, parameter_tvb, HOSTNAME_OFFSET, hostname_length, ENC_ASCII, wmem_packet_scope(), &hostname);
1496 }
1497 }
1498 }
1500 #define IPv4_ADDRESS_TYPE 5
1501 #define IPv6_ADDRESS_TYPE 6
1502 #define HOSTNAME_ADDRESS_TYPE 11
1509 };
1511 #define SUPPORTED_ADDRESS_TYPE_PARAMETER_ADDRESS_TYPE_LENGTH 2
1513 static void
1514 dissect_supported_address_types_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
1515 {
1519 number_of_addr_types = (tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH)
1525 proto_tree_add_item(parameter_tree, hf_supported_address_type, parameter_tvb, offset, SUPPORTED_ADDRESS_TYPE_PARAMETER_ADDRESS_TYPE_LENGTH, ENC_BIG_ENDIAN);
1539 }
1543 }
1545 }
1547 #define STREAM_RESET_SEQ_NR_LENGTH 4
1548 #define SENDERS_LAST_ASSIGNED_TSN_LENGTH 4
1549 #define SID_LENGTH 2
1551 #define STREAM_RESET_REQ_SEQ_NR_OFFSET PARAMETER_VALUE_OFFSET
1552 #define STREAM_RESET_REQ_RSP_SEQ_NR_OFFSET (PARAMETER_VALUE_OFFSET + STREAM_RESET_SEQ_NR_LENGTH)
1553 #define SENDERS_LAST_ASSIGNED_TSN_OFFSET (STREAM_RESET_REQ_RSP_SEQ_NR_OFFSET + STREAM_RESET_SEQ_NR_LENGTH)
1555 static void
1556 dissect_outgoing_ssn_reset_request_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
1557 {
1560 proto_tree_add_item(parameter_tree, hf_stream_reset_req_seq_nr, parameter_tvb, STREAM_RESET_REQ_SEQ_NR_OFFSET, STREAM_RESET_SEQ_NR_LENGTH, ENC_BIG_ENDIAN);
1561 proto_tree_add_item(parameter_tree, hf_stream_reset_rsp_seq_nr, parameter_tvb, STREAM_RESET_REQ_RSP_SEQ_NR_OFFSET, STREAM_RESET_SEQ_NR_LENGTH, ENC_BIG_ENDIAN);
1562 proto_tree_add_item(parameter_tree, hf_senders_last_assigned_tsn, parameter_tvb, SENDERS_LAST_ASSIGNED_TSN_OFFSET, SENDERS_LAST_ASSIGNED_TSN_LENGTH, ENC_BIG_ENDIAN);
1566 if (length > PARAMETER_HEADER_LENGTH + STREAM_RESET_SEQ_NR_LENGTH + STREAM_RESET_SEQ_NR_LENGTH + SENDERS_LAST_ASSIGNED_TSN_LENGTH) {
1567 number_of_sids = (length - (PARAMETER_HEADER_LENGTH + STREAM_RESET_SEQ_NR_LENGTH + STREAM_RESET_SEQ_NR_LENGTH + SENDERS_LAST_ASSIGNED_TSN_LENGTH)) / SID_LENGTH;
1569 proto_tree_add_item(parameter_tree, hf_stream_reset_sid, parameter_tvb, sid_offset, SID_LENGTH, ENC_BIG_ENDIAN);
1571 }
1572 }
1573 }
1575 static void
1576 dissect_incoming_ssn_reset_request_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
1577 {
1580 proto_tree_add_item(parameter_tree, hf_stream_reset_req_seq_nr, parameter_tvb, STREAM_RESET_REQ_SEQ_NR_OFFSET, STREAM_RESET_SEQ_NR_LENGTH, ENC_BIG_ENDIAN);
1585 number_of_sids = (length - (PARAMETER_HEADER_LENGTH + STREAM_RESET_SEQ_NR_LENGTH)) / SID_LENGTH;
1587 proto_tree_add_item(parameter_tree, hf_stream_reset_sid, parameter_tvb, sid_offset, SID_LENGTH, ENC_BIG_ENDIAN);
1589 }
1590 }
1591 }
1593 #define STREAM_RESET_REQ_SEQ_NR_OFFSET PARAMETER_VALUE_OFFSET
1595 static void
1596 dissect_ssn_tsn_reset_request_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
1597 {
1598 proto_tree_add_item(parameter_tree, hf_stream_reset_req_seq_nr, parameter_tvb, STREAM_RESET_REQ_SEQ_NR_OFFSET, STREAM_RESET_SEQ_NR_LENGTH, ENC_BIG_ENDIAN);
1599 }
1601 #define STREAM_RESET_RSP_RESULT_LENGTH 4
1602 #define SENDERS_NEXT_TSN_LENGTH 4
1603 #define RECEIVERS_NEXT_TSN_LENGTH 4
1605 #define STREAM_RESET_RSP_RSP_SEQ_NR_OFFSET PARAMETER_VALUE_OFFSET
1606 #define STREAM_RESET_RSP_RESULT_OFFSET (STREAM_RESET_RSP_RSP_SEQ_NR_OFFSET + STREAM_RESET_SEQ_NR_LENGTH)
1607 #define SENDERS_NEXT_TSN_OFFSET (STREAM_RESET_RSP_RESULT_OFFSET + STREAM_RESET_RSP_RESULT_LENGTH)
1608 #define RECEIVERS_NEXT_TSN_OFFSET (SENDERS_NEXT_TSN_OFFSET + SENDERS_NEXT_TSN_LENGTH)
1619 };
1622 static void
1623 dissect_re_configuration_response_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
1624 {
1629 proto_tree_add_item(parameter_tree, hf_stream_reset_rsp_seq_nr, parameter_tvb, STREAM_RESET_RSP_RSP_SEQ_NR_OFFSET, STREAM_RESET_SEQ_NR_LENGTH, ENC_BIG_ENDIAN);
1630 proto_tree_add_item(parameter_tree, hf_stream_reset_rsp_result, parameter_tvb, STREAM_RESET_RSP_RESULT_OFFSET, STREAM_RESET_RSP_RESULT_LENGTH, ENC_BIG_ENDIAN);
1631 if (length >= PARAMETER_HEADER_LENGTH + STREAM_RESET_SEQ_NR_LENGTH + STREAM_RESET_RSP_RESULT_LENGTH + SENDERS_NEXT_TSN_LENGTH)
1632 proto_tree_add_item(parameter_tree, hf_senders_next_tsn, parameter_tvb, SENDERS_NEXT_TSN_OFFSET, SENDERS_NEXT_TSN_LENGTH, ENC_BIG_ENDIAN);
1633 if (length >= PARAMETER_HEADER_LENGTH + STREAM_RESET_SEQ_NR_LENGTH + STREAM_RESET_RSP_RESULT_LENGTH + SENDERS_NEXT_TSN_LENGTH + RECEIVERS_NEXT_TSN_LENGTH)
1634 proto_tree_add_item(parameter_tree, hf_receivers_next_tsn, parameter_tvb, RECEIVERS_NEXT_TSN_OFFSET, RECEIVERS_NEXT_TSN_LENGTH, ENC_BIG_ENDIAN);
1635 }
1637 #define ADD_OUTGOING_STREAM_REQ_SEQ_NR_LENGTH 4
1638 #define ADD_OUTGOING_STREAM_REQ_NUM_STREAMS_LENGTH 2
1639 #define ADD_OUTGOING_STREAM_REQ_RESERVED_LENGTH 2
1641 #define ADD_OUTGOING_STREAM_REQ_SEQ_NR_OFFSET PARAMETER_VALUE_OFFSET
1642 #define ADD_OUTGOING_STREAM_REQ_NUM_STREAMS_OFFSET (ADD_OUTGOING_STREAM_REQ_SEQ_NR_OFFSET + ADD_OUTGOING_STREAM_REQ_SEQ_NR_LENGTH)
1643 #define ADD_OUTGOING_STREAM_REQ_RESERVED_OFFSET (ADD_OUTGOING_STREAM_REQ_NUM_STREAMS_OFFSET + ADD_OUTGOING_STREAM_REQ_NUM_STREAMS_LENGTH)
1645 static void
1646 dissect_add_outgoing_streams_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
1647 {
1648 /* unsigned length; */
1650 /* length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET); */
1652 proto_tree_add_item(parameter_tree, hf_stream_reset_req_seq_nr, parameter_tvb, ADD_OUTGOING_STREAM_REQ_SEQ_NR_OFFSET, ADD_OUTGOING_STREAM_REQ_SEQ_NR_LENGTH, ENC_BIG_ENDIAN);
1653 proto_tree_add_item(parameter_tree, hf_add_outgoing_streams_number_streams, parameter_tvb, ADD_OUTGOING_STREAM_REQ_NUM_STREAMS_OFFSET, ADD_OUTGOING_STREAM_REQ_NUM_STREAMS_LENGTH, ENC_BIG_ENDIAN);
1654 proto_tree_add_item(parameter_tree, hf_add_outgoing_streams_reserved, parameter_tvb, ADD_OUTGOING_STREAM_REQ_RESERVED_OFFSET, ADD_OUTGOING_STREAM_REQ_RESERVED_LENGTH, ENC_BIG_ENDIAN);
1655 }
1657 #define ADD_INCOMING_STREAM_REQ_SEQ_NR_LENGTH 4
1658 #define ADD_INCOMING_STREAM_REQ_NUM_STREAMS_LENGTH 2
1659 #define ADD_INCOMING_STREAM_REQ_RESERVED_LENGTH 2
1661 #define ADD_INCOMING_STREAM_REQ_SEQ_NR_OFFSET PARAMETER_VALUE_OFFSET
1662 #define ADD_INCOMING_STREAM_REQ_NUM_STREAMS_OFFSET (ADD_INCOMING_STREAM_REQ_SEQ_NR_OFFSET + ADD_OUTGOING_STREAM_REQ_SEQ_NR_LENGTH)
1663 #define ADD_INCOMING_STREAM_REQ_RESERVED_OFFSET (ADD_INCOMING_STREAM_REQ_NUM_STREAMS_OFFSET + ADD_OUTGOING_STREAM_REQ_NUM_STREAMS_LENGTH)
1665 static void
1666 dissect_add_incoming_streams_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item _U_)
1667 {
1668 /* unsigned length; */
1670 /* length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET); */
1672 proto_tree_add_item(parameter_tree, hf_stream_reset_req_seq_nr, parameter_tvb, ADD_INCOMING_STREAM_REQ_SEQ_NR_OFFSET, ADD_OUTGOING_STREAM_REQ_SEQ_NR_LENGTH, ENC_BIG_ENDIAN);
1673 proto_tree_add_item(parameter_tree, hf_add_incoming_streams_number_streams, parameter_tvb, ADD_INCOMING_STREAM_REQ_NUM_STREAMS_OFFSET, ADD_INCOMING_STREAM_REQ_NUM_STREAMS_LENGTH, ENC_BIG_ENDIAN);
1674 proto_tree_add_item(parameter_tree, hf_add_incoming_streams_reserved, parameter_tvb, ADD_INCOMING_STREAM_REQ_RESERVED_OFFSET, ADD_INCOMING_STREAM_REQ_RESERVED_LENGTH, ENC_BIG_ENDIAN);
1675 }
1677 static void
1679 {
1680 }
1682 #define ZERO_CHECKSUM_PARAMETER_EDMID_LENGTH 4
1683 #define ZERO_CHECKSUM_PARAMETER_EDMID_OFFSET PARAMETER_VALUE_OFFSET
1688 };
1690 static void
1691 dissect_zero_checksum_acceptable_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
1692 {
1693 proto_tree_add_item(parameter_tree, hf_zero_checksum_edmid, parameter_tvb, ZERO_CHECKSUM_PARAMETER_EDMID_OFFSET, ZERO_CHECKSUM_PARAMETER_EDMID_LENGTH, ENC_BIG_ENDIAN);
1694 proto_item_append_text(parameter_item, " (EDMID: %s)", val_to_str_const(tvb_get_ntohl(parameter_tvb, ZERO_CHECKSUM_PARAMETER_EDMID_OFFSET), edmid_values, "Unknown"));
1695 }
1697 #define RANDOM_NUMBER_OFFSET PARAMETER_VALUE_OFFSET
1699 static void
1701 {
1704 number_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH;
1706 proto_tree_add_item(parameter_tree, hf_random_number, parameter_tvb, RANDOM_NUMBER_OFFSET, number_length, ENC_NA);
1707 }
1709 static void
1710 dissect_chunks_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
1711 {
1716 number_of_chunks = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH;
1717 for(chunk_number = 0, offset = PARAMETER_VALUE_OFFSET; chunk_number < number_of_chunks; chunk_number++, offset += CHUNK_TYPE_LENGTH) {
1718 proto_tree_add_item(parameter_tree, hf_chunks_to_auth, parameter_tvb, offset, CHUNK_TYPE_LENGTH, ENC_BIG_ENDIAN);
1719 proto_item_append_text(parameter_item, "%s", val_to_str_const(tvb_get_uint8(parameter_tvb, offset), chunk_type_values, "Unknown"));
1722 }
1724 }
1733 #define HMAC_ID_LENGTH 2
1735 static void
1736 dissect_hmac_algo_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
1737 {
1742 number_of_ids = (tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH) / HMAC_ID_LENGTH;
1743 for(id_number = 0, offset = PARAMETER_VALUE_OFFSET; id_number < number_of_ids; id_number++, offset += HMAC_ID_LENGTH) {
1744 proto_tree_add_item(parameter_tree, hf_hmac_id, parameter_tvb, offset, HMAC_ID_LENGTH, ENC_BIG_ENDIAN);
1745 proto_item_append_text(parameter_item, "%s", val_to_str_const(tvb_get_ntohs(parameter_tvb, offset), hmac_id_values, "Unknown"));
1748 }
1750 }
1752 static void
1753 dissect_supported_extensions_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
1754 {
1759 number_of_types = (tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH) / CHUNK_TYPE_LENGTH;
1760 for(type_number = 0, offset = PARAMETER_VALUE_OFFSET; type_number < number_of_types; type_number++, offset += CHUNK_TYPE_LENGTH) {
1761 proto_tree_add_item(parameter_tree, hf_supported_chunk_type, parameter_tvb, offset, CHUNK_TYPE_LENGTH, ENC_BIG_ENDIAN);
1762 proto_item_append_text(parameter_item, "%s", val_to_str_const(tvb_get_uint8(parameter_tvb, offset), chunk_type_values, "Unknown"));
1765 }
1767 }
1769 static void
1771 {
1772 }
1774 #define CORRELATION_ID_LENGTH 4
1775 #define CORRELATION_ID_OFFSET PARAMETER_VALUE_OFFSET
1776 #define ADDRESS_PARAMETER_OFFSET (CORRELATION_ID_OFFSET + CORRELATION_ID_LENGTH)
1778 static void
1779 // NOLINTNEXTLINE(misc-no-recursion)
1780 dissect_add_ip_address_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
1781 {
1785 address_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH - CORRELATION_ID_LENGTH;
1787 proto_tree_add_item(parameter_tree, hf_correlation_id, parameter_tvb, CORRELATION_ID_OFFSET, CORRELATION_ID_LENGTH, ENC_BIG_ENDIAN);
1793 proto_item_append_text(parameter_item, ", correlation ID: %u)", tvb_get_ntohl(parameter_tvb, CORRELATION_ID_OFFSET));
1794 }
1796 static void
1797 // NOLINTNEXTLINE(misc-no-recursion)
1798 dissect_del_ip_address_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
1799 {
1803 address_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH - CORRELATION_ID_LENGTH;
1805 proto_tree_add_item(parameter_tree, hf_correlation_id, parameter_tvb, CORRELATION_ID_OFFSET, CORRELATION_ID_LENGTH, ENC_BIG_ENDIAN);
1811 proto_item_append_text(parameter_item, ", correlation ID: %u)", tvb_get_ntohl(parameter_tvb, CORRELATION_ID_OFFSET));
1812 }
1814 #define ERROR_CAUSE_IND_CASUES_OFFSET (CORRELATION_ID_OFFSET + CORRELATION_ID_LENGTH)
1816 static void
1817 // NOLINTNEXTLINE(misc-no-recursion)
1818 dissect_error_cause_indication_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree)
1819 {
1823 proto_tree_add_item(parameter_tree, hf_correlation_id, parameter_tvb, CORRELATION_ID_OFFSET, CORRELATION_ID_LENGTH, ENC_BIG_ENDIAN);
1824 causes_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH - CORRELATION_ID_LENGTH;
1826 MIN(causes_length, tvb_captured_length_remaining(parameter_tvb, ERROR_CAUSE_IND_CASUES_OFFSET)),
1827 MIN(causes_length, tvb_reported_length_remaining(parameter_tvb, ERROR_CAUSE_IND_CASUES_OFFSET)));
1829 }
1831 static void
1832 // NOLINTNEXTLINE(misc-no-recursion)
1833 dissect_set_primary_address_parameter(tvbuff_t *parameter_tvb, packet_info *pinfo, proto_tree *parameter_tree, proto_item *parameter_item)
1834 {
1838 address_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH - CORRELATION_ID_LENGTH;
1840 proto_tree_add_item(parameter_tree, hf_correlation_id, parameter_tvb, CORRELATION_ID_OFFSET, CORRELATION_ID_LENGTH, ENC_BIG_ENDIAN);
1846 proto_item_append_text(parameter_item, ", correlation ID: %u)", tvb_get_ntohl(parameter_tvb, CORRELATION_ID_OFFSET));
1847 }
1849 static void
1850 dissect_success_report_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
1851 {
1852 proto_tree_add_item(parameter_tree, hf_correlation_id, parameter_tvb, CORRELATION_ID_OFFSET, CORRELATION_ID_LENGTH, ENC_BIG_ENDIAN);
1853 proto_item_append_text(parameter_item, " (Correlation ID: %u)", tvb_get_ntohl(parameter_tvb, CORRELATION_ID_OFFSET));
1854 }
1856 #define ADAP_INDICATION_LENGTH 4
1857 #define ADAP_INDICATION_OFFSET PARAMETER_VALUE_OFFSET
1859 static void
1860 dissect_adap_indication_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
1861 {
1862 proto_tree_add_item(parameter_tree, hf_adap_indication, parameter_tvb, ADAP_INDICATION_OFFSET, ADAP_INDICATION_LENGTH, ENC_BIG_ENDIAN);
1863 proto_item_append_text(parameter_item, " (Indication: %u)", tvb_get_ntohl(parameter_tvb, ADAP_INDICATION_OFFSET));
1864 }
1866 static void
1867 dissect_unknown_parameter(tvbuff_t *parameter_tvb, proto_tree *parameter_tree, proto_item *parameter_item)
1868 {
1872 parameter_value_length = tvb_get_ntohs(parameter_tvb, PARAMETER_LENGTH_OFFSET) - PARAMETER_HEADER_LENGTH;
1875 proto_tree_add_item(parameter_tree, hf_parameter_value, parameter_tvb, PARAMETER_VALUE_OFFSET, parameter_value_length, ENC_NA);
1877 proto_item_append_text(parameter_item, " (Type %u, value length: %u byte%s)", type, parameter_value_length, plurality(parameter_value_length, "", "s"));
1878 }
1880 #define HEARTBEAT_INFO_PARAMETER_ID 0x0001
1881 #define IPV4ADDRESS_PARAMETER_ID 0x0005
1882 #define IPV6ADDRESS_PARAMETER_ID 0x0006
1883 #define STATE_COOKIE_PARAMETER_ID 0x0007
1884 #define UNREC_PARA_PARAMETER_ID 0x0008
1885 #define COOKIE_PRESERVATIVE_PARAMETER_ID 0x0009
1886 #define HOSTNAME_ADDRESS_PARAMETER_ID 0x000b
1887 #define SUPPORTED_ADDRESS_TYPES_PARAMETER_ID 0x000c
1888 #define OUTGOING_SSN_RESET_REQUEST_PARAMETER_ID 0x000d
1889 #define INCOMING_SSN_RESET_REQUEST_PARAMETER_ID 0x000e
1890 #define SSN_TSN_RESET_REQUEST_PARAMETER_ID 0x000f
1891 #define RE_CONFIGURATION_RESPONSE_PARAMETER_ID 0x0010
1892 #define ADD_OUTGOING_STREAMS_REQUEST_PARAMETER_ID 0x0011
1893 #define ADD_INCOMING_STREAMS_REQUEST_PARAMETER_ID 0x0012
1894 #define ECN_PARAMETER_ID 0x8000
1895 #define ZERO_CHECKSUM_ACCEPTABLE_PARAMETER_ID 0x8001
1896 #define RANDOM_PARAMETER_ID 0x8002
1897 #define CHUNKS_PARAMETER_ID 0x8003
1898 #define HMAC_ALGO_PARAMETER_ID 0x8004
1899 #define SUPPORTED_EXTENSIONS_PARAMETER_ID 0x8008
1900 #define FORWARD_TSN_SUPPORTED_PARAMETER_ID 0xC000
1901 #define ADD_IP_ADDRESS_PARAMETER_ID 0xC001
1902 #define DEL_IP_ADDRESS_PARAMETER_ID 0xC002
1903 #define ERROR_CAUSE_INDICATION_PARAMETER_ID 0xC003
1904 #define SET_PRIMARY_ADDRESS_PARAMETER_ID 0xC004
1905 #define SUCCESS_REPORT_PARAMETER_ID 0xC005
1906 #define ADAP_LAYER_INDICATION_PARAMETER_ID 0xC006
1938 #define SCTP_PARAMETER_BIT_1 0x8000
1939 #define SCTP_PARAMETER_BIT_2 0x4000
1943 "Stop processing of chunk"
1944 };
1948 "Do not report"
1949 };
1951 static void
1952 // NOLINTNEXTLINE(misc-no-recursion)
1957 {
1967 parameter_tree = proto_tree_add_subtree_format(chunk_tree, parameter_tvb, PARAMETER_HEADER_OFFSET, -1,
1973 }
1976 expert_add_info_format(pinfo, parameter_item, &ei_sctp_parameter_length, "Parameter length is not padded to a multiple of 4 bytes (length=%d)", reported_length);
1977 }
1978 }
1980 if (!(chunk_tree || (dissecting_init_init_ack_chunk && (type == IPV4ADDRESS_PARAMETER_ID || type == IPV6ADDRESS_PARAMETER_ID))))
1984 type_item = proto_tree_add_item(parameter_tree, hf_parameter_type, parameter_tvb, PARAMETER_TYPE_OFFSET, PARAMETER_TYPE_LENGTH, ENC_BIG_ENDIAN);
1986 proto_tree_add_item(type_tree, hf_parameter_bit_1, parameter_tvb, PARAMETER_TYPE_OFFSET, PARAMETER_TYPE_LENGTH, ENC_BIG_ENDIAN);
1987 proto_tree_add_item(type_tree, hf_parameter_bit_2, parameter_tvb, PARAMETER_TYPE_OFFSET, PARAMETER_TYPE_LENGTH, ENC_BIG_ENDIAN);
1988 proto_tree_add_item(parameter_tree, hf_parameter_length, parameter_tvb, PARAMETER_LENGTH_OFFSET, PARAMETER_LENGTH_LENGTH, ENC_BIG_ENDIAN);
1989 /* XXX - add expert info if length is bogus? */
1993 }
2001 dissect_ipv4_parameter(parameter_tvb, parameter_tree, parameter_item, additional_item, dissecting_init_init_ack_chunk);
2004 dissect_ipv6_parameter(parameter_tvb, parameter_tree, parameter_item, additional_item, dissecting_init_init_ack_chunk);
2081 }
2085 proto_tree_add_item(parameter_tree, hf_parameter_padding, parameter_tvb, PARAMETER_HEADER_OFFSET + length, padding_length, ENC_NA);
2086 }
2087 }
2089 static void
2090 // NOLINTNEXTLINE(misc-no-recursion)
2091 dissect_parameters(tvbuff_t *parameters_tvb, packet_info *pinfo, proto_tree *tree, proto_item *additional_item, bool dissecting_init_init_ack_chunk)
2092 {
2106 /* If we have less bytes than we need, throw an exception while dissecting
2107 * the parameter--not when generating the parameter_tvb below.
2108 */
2111 /* create a tvb for the parameter including the padding bytes */
2112 parameter_tvb = tvb_new_subset_length_caplen(parameters_tvb, offset, MIN(total_length, tvb_captured_length_remaining(parameters_tvb, offset)), total_length);
2113 /* get rid of the handled parameter */
2120 }
2121 dissect_parameter(parameter_tvb, pinfo, tree, additional_item, dissecting_init_init_ack_chunk, final_parameter);
2122 }
2123 }
2126 /*
2127 * Code to handle error causes for ABORT and ERROR chunks
2128 */
2131 #define CAUSE_CODE_LENGTH 2
2132 #define CAUSE_LENGTH_LENGTH 2
2133 #define CAUSE_HEADER_LENGTH (CAUSE_CODE_LENGTH + CAUSE_LENGTH_LENGTH)
2135 #define CAUSE_HEADER_OFFSET 0
2136 #define CAUSE_CODE_OFFSET CAUSE_HEADER_OFFSET
2137 #define CAUSE_LENGTH_OFFSET (CAUSE_CODE_OFFSET + CAUSE_CODE_LENGTH)
2138 #define CAUSE_INFO_OFFSET (CAUSE_LENGTH_OFFSET + CAUSE_LENGTH_LENGTH)
2141 #define CAUSE_STREAM_IDENTIFIER_LENGTH 2
2142 #define CAUSE_RESERVED_LENGTH 2
2143 #define CAUSE_STREAM_IDENTIFIER_OFFSET CAUSE_INFO_OFFSET
2144 #define CAUSE_RESERVED_OFFSET (CAUSE_STREAM_IDENTIFIER_OFFSET + CAUSE_STREAM_IDENTIFIER_LENGTH)
2146 static void
2147 dissect_invalid_stream_identifier_cause(tvbuff_t *cause_tvb, proto_tree *cause_tree, proto_item *cause_item)
2148 {
2149 proto_tree_add_item(cause_tree, hf_cause_stream_identifier, cause_tvb, CAUSE_STREAM_IDENTIFIER_OFFSET, CAUSE_STREAM_IDENTIFIER_LENGTH, ENC_BIG_ENDIAN);
2150 proto_tree_add_item(cause_tree, hf_cause_reserved, cause_tvb, CAUSE_RESERVED_OFFSET, CAUSE_RESERVED_LENGTH, ENC_BIG_ENDIAN);
2151 proto_item_append_text(cause_item, " (SID: %u)", tvb_get_ntohs(cause_tvb, CAUSE_STREAM_IDENTIFIER_OFFSET));
2152 }
2154 #define CAUSE_NUMBER_OF_MISSING_PARAMETERS_LENGTH 4
2155 #define CAUSE_MISSING_PARAMETER_TYPE_LENGTH 2
2157 #define CAUSE_NUMBER_OF_MISSING_PARAMETERS_OFFSET CAUSE_INFO_OFFSET
2158 #define CAUSE_FIRST_MISSING_PARAMETER_TYPE_OFFSET (CAUSE_NUMBER_OF_MISSING_PARAMETERS_OFFSET + \
2159 CAUSE_NUMBER_OF_MISSING_PARAMETERS_LENGTH )
2161 static void
2163 {
2167 number_of_missing_parameters = tvb_get_ntohl(cause_tvb, CAUSE_NUMBER_OF_MISSING_PARAMETERS_OFFSET);
2168 proto_tree_add_item(cause_tree, hf_cause_number_of_missing_parameters, cause_tvb, CAUSE_NUMBER_OF_MISSING_PARAMETERS_OFFSET, CAUSE_NUMBER_OF_MISSING_PARAMETERS_LENGTH, ENC_BIG_ENDIAN);
2170 for(missing_parameter_number = 0; missing_parameter_number < number_of_missing_parameters; missing_parameter_number++) {
2171 proto_tree_add_item(cause_tree, hf_cause_missing_parameter_type, cause_tvb, offset, CAUSE_MISSING_PARAMETER_TYPE_LENGTH, ENC_BIG_ENDIAN);
2173 }
2174 }
2176 #define CAUSE_MEASURE_OF_STALENESS_LENGTH 4
2177 #define CAUSE_MEASURE_OF_STALENESS_OFFSET CAUSE_INFO_OFFSET
2179 static void
2180 dissect_stale_cookie_error_cause(tvbuff_t *cause_tvb, proto_tree *cause_tree, proto_item *cause_item)
2181 {
2182 proto_tree_add_item(cause_tree, hf_cause_measure_of_staleness, cause_tvb, CAUSE_MEASURE_OF_STALENESS_OFFSET, CAUSE_MEASURE_OF_STALENESS_LENGTH, ENC_BIG_ENDIAN);
2183 proto_item_append_text(cause_item, " (Measure: %u usec)", tvb_get_ntohl(cause_tvb, CAUSE_MEASURE_OF_STALENESS_OFFSET));
2184 }
2186 static void
2188 {
2189 }
2191 static void
2192 // NOLINTNEXTLINE(misc-no-recursion)
2193 dissect_unresolvable_address_cause(tvbuff_t *cause_tvb, packet_info *pinfo, proto_tree *cause_tree, proto_item *cause_item)
2194 {
2203 }
2205 static bool
2206 dissect_sctp_chunk(tvbuff_t *chunk_tvb, packet_info *pinfo, proto_tree *tree, proto_tree *sctp_tree, sctp_half_assoc_t *assoc, bool useinfo);
2208 static void
2209 // NOLINTNEXTLINE(misc-no-recursion)
2210 dissect_unrecognized_chunk_type_cause(tvbuff_t *cause_tvb, packet_info *pinfo, proto_tree *cause_tree, proto_item *cause_item)
2211 {
2222 proto_item_append_text(cause_item, " (Type: %u (%s))", unrecognized_type, val_to_str_const(unrecognized_type, chunk_type_values, "unknown"));
2223 }
2225 static void
2227 {
2228 }
2230 static void
2231 // NOLINTNEXTLINE(misc-no-recursion)
2232 dissect_unrecognized_parameters_cause(tvbuff_t *cause_tvb, packet_info *pinfo, proto_tree *cause_tree)
2233 {
2243 }
2245 #define CAUSE_TSN_LENGTH 4
2246 #define CAUSE_TSN_OFFSET CAUSE_INFO_OFFSET
2248 static void
2249 dissect_no_user_data_cause(tvbuff_t *cause_tvb, proto_tree *cause_tree, proto_item *cause_item)
2250 {
2251 proto_tree_add_item(cause_tree, hf_cause_tsn, cause_tvb, CAUSE_TSN_OFFSET, CAUSE_TSN_LENGTH, ENC_BIG_ENDIAN);
2253 }
2255 static void
2257 {
2258 }
2260 static void
2261 // NOLINTNEXTLINE(misc-no-recursion)
2262 dissect_restart_with_new_address_cause(tvbuff_t *cause_tvb, packet_info *pinfo, proto_tree *cause_tree, proto_item *cause_item)
2263 {
2274 }
2276 static void
2278 {
2283 proto_tree_add_item(cause_tree, hf_cause_info, cause_tvb, CAUSE_INFO_OFFSET, cause_info_length, ENC_NA);
2284 }
2286 static void
2288 {
2293 proto_tree_add_item(cause_tree, hf_cause_info, cause_tvb, CAUSE_INFO_OFFSET, cause_info_length, ENC_NA);
2294 }
2296 static void
2297 // NOLINTNEXTLINE(misc-no-recursion)
2298 dissect_delete_last_address_cause(tvbuff_t *cause_tvb, packet_info *pinfo, proto_tree *cause_tree, proto_item *cause_item)
2299 {
2310 }
2312 static void
2313 // NOLINTNEXTLINE(misc-no-recursion)
2315 {
2324 }
2326 static void
2327 // NOLINTNEXTLINE(misc-no-recursion)
2328 dissect_delete_source_address_cause(tvbuff_t *cause_tvb, packet_info *pinfo, proto_tree *cause_tree, proto_item *cause_item)
2329 {
2340 }
2342 static void
2343 // NOLINTNEXTLINE(misc-no-recursion)
2345 {
2354 }
2356 static void
2357 dissect_unsupported_hmac_id_cause(tvbuff_t *cause_tvb, packet_info *pinfo _U_, proto_tree *cause_tree)
2358 {
2359 proto_tree_add_item(cause_tree, hf_hmac_id, cause_tvb, CAUSE_INFO_OFFSET, HMAC_ID_LENGTH, ENC_BIG_ENDIAN);
2360 }
2362 static void
2364 {
2369 proto_tree_add_item(cause_tree, hf_cause_info, cause_tvb, CAUSE_INFO_OFFSET, cause_info_length, ENC_NA);
2370 proto_item_append_text(cause_item, " (Code: %u, information length: %u byte%s)", tvb_get_ntohs(cause_tvb, CAUSE_CODE_OFFSET), cause_info_length, plurality(cause_info_length, "", "s"));
2371 }
2373 #define INVALID_STREAM_IDENTIFIER 0x01
2374 #define MISSING_MANDATORY_PARAMETERS 0x02
2375 #define STALE_COOKIE_ERROR 0x03
2376 #define OUT_OF_RESOURCE 0x04
2377 #define UNRESOLVABLE_ADDRESS 0x05
2378 #define UNRECOGNIZED_CHUNK_TYPE 0x06
2379 #define INVALID_MANDATORY_PARAMETER 0x07
2380 #define UNRECOGNIZED_PARAMETERS 0x08
2381 #define NO_USER_DATA 0x09
2382 #define COOKIE_RECEIVED_WHILE_SHUTTING_DOWN 0x0a
2383 #define RESTART_WITH_NEW_ADDRESSES 0x0b
2384 #define USER_INITIATED_ABORT 0x0c
2385 #define PROTOCOL_VIOLATION 0x0d
2386 #define REQUEST_TO_DELETE_LAST_ADDRESS 0x00a0
2387 #define OPERATION_REFUSED_DUE_TO_RESOURCE_SHORTAGE 0x00a1
2388 #define REQUEST_TO_DELETE_SOURCE_ADDRESS 0x00a2
2389 #define ABORT_DUE_TO_ILLEGAL_ASCONF 0x00a3
2390 #define REQUEST_REFUSED 0x00a4
2391 #define UNSUPPORTED_HMAC_ID 0x0105
2416 static void
2417 // NOLINTNEXTLINE(misc-no-recursion)
2419 {
2429 ett_sctp_chunk_cause, &cause_item, "%s cause", val_to_str_const(code, cause_code_values, "Unknown"));
2431 proto_tree_add_item(cause_tree, hf_cause_code, cause_tvb, CAUSE_CODE_OFFSET, CAUSE_CODE_LENGTH, ENC_BIG_ENDIAN);
2432 proto_tree_add_item(cause_tree, hf_cause_length, cause_tvb, CAUSE_LENGTH_OFFSET, CAUSE_LENGTH_LENGTH, ENC_BIG_ENDIAN);
2433 /* XXX - add expert info if length is bogus? */
2494 }
2498 proto_tree_add_item(cause_tree, hf_cause_padding, cause_tvb, CAUSE_HEADER_OFFSET + length, padding_length, ENC_NA);
2499 }
2501 static void
2502 // NOLINTNEXTLINE(misc-no-recursion)
2504 {
2513 /* If we have less bytes than we need, throw an exception while dissecting
2514 * the cause--not when generating the causes_tvb below.
2515 */
2518 /* create a tvb for the parameter including the padding bytes */
2519 cause_tvb = tvb_new_subset_length_caplen(causes_tvb, offset, MIN(total_length, tvb_captured_length_remaining(causes_tvb, offset)), total_length);
2523 /* get rid of the handled cause */
2525 }
2526 }
2529 /*
2530 * Code to actually dissect the packets
2531 */
2535 static bool
2537 {
2544 /* XXX - we ignore port numbers of 0, as some dissectors use a port
2545 number of 0 to disable the port. */
2552 }
2556 if (dissector_try_uint_with_data(sctp_ppi_dissector_table, ppi, payload_tvb, pinfo, tree, true, GUINT_TO_POINTER(ppi))) {
2558 }
2560 /* The default; try it later */
2562 }
2567 if (dissector_try_uint_with_data(sctp_port_dissector_table, low_port, payload_tvb, pinfo, tree, true, GUINT_TO_POINTER(ppi))) {
2569 }
2571 /* The default; try it later */
2573 }
2574 }
2579 if (dissector_try_uint_with_data(sctp_port_dissector_table, high_port, payload_tvb, pinfo, tree, true, GUINT_TO_POINTER(ppi))) {
2581 }
2583 /* The default; try it later */
2585 }
2586 }
2589 /* do lookup with the heuristic subdissector table */
2590 if (dissector_try_heuristic(sctp_heur_subdissector_list, payload_tvb, pinfo, tree, &hdtbl_entry, GUINT_TO_POINTER(ppi)))
2592 }
2594 /* Do lookups with the subdissector table.
2595 First try the PPI.
2597 When trying port numbers, we try the port number with the lower value
2598 first, followed by the port number with the higher value. This means
2599 that, for packets where a dissector is registered for *both* port
2600 numbers, and where there's no match on the PPI:
2602 1) we pick the same dissector for traffic going in both directions;
2604 2) we prefer the port number that's more likely to be the right
2605 one (as that prefers well-known ports to reserved ports);
2607 although there is, of course, no guarantee that any such strategy
2608 will always pick the right port number. */
2610 dissector_try_uint_with_data(sctp_ppi_dissector_table, ppi, payload_tvb, pinfo, tree, true, GUINT_TO_POINTER(ppi)))
2614 dissector_try_uint_with_data(sctp_port_dissector_table, low_port, payload_tvb, pinfo, tree, true, GUINT_TO_POINTER(ppi)))
2617 dissector_try_uint_with_data(sctp_port_dissector_table, high_port, payload_tvb, pinfo, tree, true, GUINT_TO_POINTER(ppi)))
2621 /* do lookup with the heuristic subdissector table */
2622 if (dissector_try_heuristic(sctp_heur_subdissector_list, payload_tvb, pinfo, tree, &hdtbl_entry, GUINT_TO_POINTER(ppi)))
2624 }
2625 }
2626 /* Oh, well, we don't know this; dissect it as data. */
2629 }
2631 #define DATA_CHUNK_TSN_LENGTH 4
2632 #define DATA_CHUNK_STREAM_ID_LENGTH 2
2633 #define DATA_CHUNK_STREAM_SEQ_NUMBER_LENGTH 2
2634 #define DATA_CHUNK_PAYLOAD_PROTOCOL_ID_LENGTH 4
2635 #define I_DATA_CHUNK_RESERVED_LENGTH 2
2636 #define I_DATA_CHUNK_MID_LENGTH 4
2637 #define I_DATA_CHUNK_PAYLOAD_PROTOCOL_ID_LENGTH 4
2638 #define I_DATA_CHUNK_FSN_LENGTH 4
2640 #define DATA_CHUNK_TSN_OFFSET (CHUNK_VALUE_OFFSET + 0)
2641 #define DATA_CHUNK_STREAM_ID_OFFSET (DATA_CHUNK_TSN_OFFSET + DATA_CHUNK_TSN_LENGTH)
2642 #define DATA_CHUNK_STREAM_SEQ_NUMBER_OFFSET (DATA_CHUNK_STREAM_ID_OFFSET + \
2643 DATA_CHUNK_STREAM_ID_LENGTH)
2644 #define DATA_CHUNK_PAYLOAD_PROTOCOL_ID_OFFSET (DATA_CHUNK_STREAM_SEQ_NUMBER_OFFSET + \
2645 DATA_CHUNK_STREAM_SEQ_NUMBER_LENGTH)
2646 #define DATA_CHUNK_PAYLOAD_OFFSET (DATA_CHUNK_PAYLOAD_PROTOCOL_ID_OFFSET + \
2647 DATA_CHUNK_PAYLOAD_PROTOCOL_ID_LENGTH)
2648 #define I_DATA_CHUNK_RESERVED_OFFSET (DATA_CHUNK_STREAM_ID_OFFSET + \
2649 DATA_CHUNK_STREAM_ID_LENGTH)
2650 #define I_DATA_CHUNK_MID_OFFSET (I_DATA_CHUNK_RESERVED_OFFSET + \
2651 I_DATA_CHUNK_RESERVED_LENGTH)
2652 #define I_DATA_CHUNK_PAYLOAD_PROTOCOL_ID_OFFSET (I_DATA_CHUNK_MID_OFFSET + \
2653 I_DATA_CHUNK_MID_LENGTH)
2654 #define I_DATA_CHUNK_FSN_OFFSET (I_DATA_CHUNK_MID_OFFSET + \
2655 I_DATA_CHUNK_MID_LENGTH)
2656 #define I_DATA_CHUNK_PAYLOAD_OFFSET (I_DATA_CHUNK_PAYLOAD_PROTOCOL_ID_OFFSET + \
2657 I_DATA_CHUNK_PAYLOAD_PROTOCOL_ID_LENGTH)
2659 #define DATA_CHUNK_HEADER_LENGTH (CHUNK_HEADER_LENGTH + \
2660 DATA_CHUNK_TSN_LENGTH + \
2661 DATA_CHUNK_STREAM_ID_LENGTH + \
2662 DATA_CHUNK_STREAM_SEQ_NUMBER_LENGTH + \
2663 DATA_CHUNK_PAYLOAD_PROTOCOL_ID_LENGTH)
2664 #define I_DATA_CHUNK_HEADER_LENGTH (CHUNK_HEADER_LENGTH + \
2665 DATA_CHUNK_TSN_LENGTH + \
2666 DATA_CHUNK_STREAM_ID_LENGTH + \
2667 I_DATA_CHUNK_RESERVED_LENGTH + \
2668 I_DATA_CHUNK_MID_LENGTH +\
2669 I_DATA_CHUNK_PAYLOAD_PROTOCOL_ID_LENGTH)
2671 #define SCTP_DATA_CHUNK_E_BIT 0x01
2672 #define SCTP_DATA_CHUNK_B_BIT 0x02
2673 #define SCTP_DATA_CHUNK_U_BIT 0x04
2674 #define SCTP_DATA_CHUNK_I_BIT 0x08
2676 /* table to hold fragmented SCTP messages */
2690 static int
2692 {
2703 }
2706 static unsigned
2708 {
2713 }
2716 static void
2718 {
2722 /* free all begins */
2727 }
2729 /* free all ends */
2734 }
2736 /* free all fragments */
2742 }
2744 /* msg->messages is wmem_ allocated, no need to free it */
2747 }
2749 static void
2751 {
2755 }
2757 static void
2759 {
2761 }
2766 {
2767 frag_key key;
2777 }
2782 {
2794 }
2795 }
2798 }
2805 {
2811 /* Don't try to do reassembly on error packets */
2815 /* lookup message. if not found, create it */
2828 else
2830 else
2845 }
2847 /* lookup segment. if not found, create it */
2851 /* this fragment is already known.
2852 * compare frame number to check if it's a duplicate
2853 */
2857 /* There already is a fragment having the same ports, v_tag,
2858 * stream id, stream_seq_num and tsn but it appeared in a different
2859 * frame, so it must be a duplicate fragment. Maybe a retransmission?
2860 * Mark it as duplicate and return NULL.
2861 *
2862 * Note: This won't happen if TSN analysis is on: the caller will have
2863 * detected the retransmission and not pass it to the reassembly code.
2864 */
2869 }
2870 }
2872 /* There is no point in storing a fragment with no data in it */
2876 /* create new fragment */
2886 /* add new fragment to linked list. sort ascending by tsn */
2901 }
2902 }
2905 /* save begin or end if necessary */
2911 /* add begin to linked list. sort descending by tsn */
2926 }
2927 }
2929 }
2936 /* add end to linked list. sort ascending by tsn */
2951 }
2952 }
2954 }
2957 }
2963 {
2976 /* no message, we can't do anything */
2978 }
2980 /* check if fragment is part of an already reassembled message */
2982 message &&
2989 /* we found the reassembled message this fragment belongs to */
2992 /* this is the last fragment, create data source */
2996 /* display reassembly info */
3004 frag_i;
3013 }
3025 }
3037 }
3038 }
3041 }
3043 /* this is not the last fragment,
3044 * so let the user know the frame where the reassembly is
3045 */
3048 proto_tree_add_uint(tree, hf_sctp_reassembled_in, tvb, 0, 0, message->reassembled_in->frame_num);
3050 }
3052 /* this fragment has not been reassembled, yet
3053 * check now if we can reassemble it
3054 * at first look for the first and last tsn of the msg
3055 */
3060 /* in case begin still is null, set it to first (highest) begin
3061 * maybe the message tsn restart at 0 in between
3062 */
3070 /* in case end still is null, set it to first (lowest) end
3071 * maybe the message tsn restart at 0 in between
3072 */
3078 /* begin and end have not been collected, yet
3079 * or there might be a tsn restart but the first fragment hasn't a tsn of 0
3080 * just mark as fragment
3081 */
3086 }
3088 /* we found possible begin and end
3089 * look for the first fragment and then try to get to the end
3090 */
3093 /* while looking if all fragments are there
3094 * we can calculate the overall length that
3095 * we need in case of success
3096 */
3099 /* check if begin is past end
3100 * this can happen if there has been a tsn restart
3101 * or we just got the wrong begin and end
3102 * so give it a try
3103 */
3109 /* check if we reached the last possible tsn
3110 * if yes, restart and continue
3111 */
3113 /* there are just fragments missing */
3117 }
3119 /* we got all fragments until the last possible tsn
3120 * and the first is 0 if we got here
3121 */
3132 }
3135 /* we need more fragments. just mark as fragment */
3139 }
3141 /* ok, this message is complete, we can reassemble it
3142 * but at first don't forget to add the length of the last fragment
3143 */
3154 /* now copy all fragments */
3156 /* a tsn restart has occurred */
3158 frag_i;
3165 /* release fragment data */
3168 }
3178 /* release fragment data */
3181 }
3192 /* release fragment data */
3195 }
3196 }
3198 /* save message */
3206 }
3208 /* remove begin and end from list */
3217 }
3228 }
3231 /* create data source */
3235 /* display reassembly info */
3243 frag_i;
3252 }
3264 }
3276 }
3277 }
3279 /* it's not fragmented anymore */
3283 }
3286 create_exp_pdu_table(packet_info *pinfo, tvbuff_t *tvb, const char *table_name, uint32_t table_value)
3287 {
3288 exp_pdu_data_item_t exp_pdu_data_table_value = {
3289 exp_pdu_data_dissector_table_num_value_size,
3290 exp_pdu_data_dissector_table_num_value_populate_data,
3292 };
3302 NULL
3303 };
3305 exp_pdu_data_t *exp_pdu_data = export_pdu_create_tags(pinfo, table_name, EXP_PDU_TAG_DISSECTOR_TABLE_NAME, sctp_exp_pdu_items);
3312 }
3316 {
3317 exp_pdu_data_t *exp_pdu_data = export_pdu_create_common_tags(pinfo, proto_name, EXP_PDU_TAG_DISSECTOR_NAME);
3324 }
3326 static void
3329 {
3334 /* Do nothing when there is no export pdu tap listener */
3336 }
3339 /* get the proto_name of the next frame */
3341 }
3344 /* when we have proto_name and it is not "data" export using the proto_name */
3353 /* do not export anything when none of the above fileds are available */
3355 }
3358 }
3360 static bool
3364 {
3368 /*
3369 * If this is a short frame, then we can't, and don't, do
3370 * reassembly on it. We just give up.
3371 */
3375 /* add fragment to list of known fragments. returns NULL if segment is a duplicate */
3376 fragment = add_fragment(payload_tvb, pinfo, chunk_tree, tsn, stream_id, stream_seq_num, b_bit, e_bit, u_bit, ppi, is_idata);
3379 new_tvb = fragment_reassembly(payload_tvb, fragment, pinfo, chunk_tree, stream_id, stream_seq_num, u_bit);
3381 /* pass reassembled data to next dissector, if possible */
3389 }
3391 /* no reassembly done, do nothing */
3393 }
3397 "Not the last segment"
3398 };
3402 "Subsequent segment"
3403 };
3407 "Ordered delivery"
3408 };
3412 "Possibly delay SACK"
3413 };
3415 static bool
3425 {
3444 NULL
3445 };
3449 proto_item_append_text(chunk_item, ", bogus chunk length %u < %u)", chunk_length, I_DATA_CHUNK_HEADER_LENGTH);
3451 }
3455 proto_item_append_text(chunk_item, ", bogus chunk length %u < %u)", chunk_length, DATA_CHUNK_HEADER_LENGTH);
3457 }
3459 }
3461 /* insert the PPID in the pinfo structure if it is not already there and there is still room */
3467 }
3469 p_add_proto_data(pinfo->pool, pinfo, proto_sctp, number_of_ppid, GUINT_TO_POINTER(payload_proto_id));
3481 }
3483 }
3490 else
3494 proto_tree_add_bitmask_list(flags_tree, chunk_tvb, CHUNK_FLAGS_OFFSET, CHUNK_FLAGS_LENGTH, chunk_flags, ENC_NA);
3496 tsn_item = proto_tree_add_uint(chunk_tree, hf_data_chunk_tsn, chunk_tvb, DATA_CHUNK_TSN_OFFSET, DATA_CHUNK_TSN_LENGTH, tsn);
3497 proto_tree_add_item(chunk_tree, hf_data_chunk_tsn_raw, chunk_tvb, DATA_CHUNK_TSN_OFFSET, DATA_CHUNK_TSN_LENGTH, ENC_BIG_ENDIAN);
3498 }
3500 tsn_item = proto_tree_add_item(chunk_tree, hf_data_chunk_tsn_raw, chunk_tvb, DATA_CHUNK_TSN_OFFSET, DATA_CHUNK_TSN_LENGTH, ENC_BIG_ENDIAN);
3501 }
3502 proto_tree_add_item(chunk_tree, hf_data_chunk_stream_id, chunk_tvb, DATA_CHUNK_STREAM_ID_OFFSET, DATA_CHUNK_STREAM_ID_LENGTH, ENC_BIG_ENDIAN);
3504 proto_tree_add_item(chunk_tree, hf_idata_chunk_reserved, chunk_tvb, I_DATA_CHUNK_RESERVED_OFFSET, I_DATA_CHUNK_RESERVED_LENGTH, ENC_BIG_ENDIAN);
3505 proto_tree_add_item(chunk_tree, hf_idata_chunk_mid, chunk_tvb, I_DATA_CHUNK_MID_OFFSET, I_DATA_CHUNK_MID_LENGTH, ENC_BIG_ENDIAN);
3507 proto_tree_add_item(chunk_tree, hf_data_chunk_payload_proto_id, chunk_tvb, I_DATA_CHUNK_PAYLOAD_PROTOCOL_ID_OFFSET, I_DATA_CHUNK_PAYLOAD_PROTOCOL_ID_LENGTH, ENC_BIG_ENDIAN);
3508 else
3509 proto_tree_add_item(chunk_tree, hf_idata_chunk_fsn, chunk_tvb, I_DATA_CHUNK_FSN_OFFSET, I_DATA_CHUNK_FSN_LENGTH, ENC_BIG_ENDIAN);
3511 proto_tree_add_item(chunk_tree, hf_data_chunk_stream_seq_number, chunk_tvb, DATA_CHUNK_STREAM_SEQ_NUMBER_OFFSET, DATA_CHUNK_STREAM_SEQ_NUMBER_LENGTH, ENC_BIG_ENDIAN);
3512 proto_tree_add_item(chunk_tree, hf_data_chunk_payload_proto_id, chunk_tvb, DATA_CHUNK_PAYLOAD_PROTOCOL_ID_OFFSET, DATA_CHUNK_PAYLOAD_PROTOCOL_ID_LENGTH, ENC_BIG_ENDIAN);
3513 }
3518 else
3523 else
3525 }
3529 proto_item_append_text(chunk_item, " segment, TSN: %u, SID: %u, MID: %u, payload length: %u byte%s)",
3530 tsn,
3533 chunk_length - I_DATA_CHUNK_HEADER_LENGTH, plurality(chunk_length - I_DATA_CHUNK_HEADER_LENGTH, "", "s"));
3534 else
3535 proto_item_append_text(chunk_item, " segment, TSN: %u, SID: %u, MID: %u, FSN: %u, payload length: %u byte%s)",
3536 tsn,
3540 chunk_length - I_DATA_CHUNK_HEADER_LENGTH, plurality(chunk_length - I_DATA_CHUNK_HEADER_LENGTH, "", "s"));
3542 proto_item_append_text(chunk_item, " segment, TSN: %u, SID: %u, SSN: %u, PPID: %u, payload length: %u byte%s)",
3543 tsn,
3546 payload_proto_id,
3547 chunk_length - DATA_CHUNK_HEADER_LENGTH, plurality(chunk_length - DATA_CHUNK_HEADER_LENGTH, "", "s"));
3548 }
3558 }
3563 /* Is this a fragment? */
3565 /* No - just call the subdissector. */
3569 /* Yes. */
3572 /* if reassembly is off just mark as fragment for next dissector and proceed */
3574 {
3575 /* Don't pass on non-first fragments since the next dissector will
3576 * almost certainly not understand the data.
3577 */
3583 }
3585 }
3588 /* This isn't a fragment or reassembly is off and it's the first fragment */
3593 TRY {
3595 }
3596 CATCH_NONFATAL_ERRORS {
3597 /*
3598 * Somebody threw an exception that means that there was a problem
3599 * dissecting the payload; that means that a dissector was found,
3600 * so we don't need to dissect the payload as data or update the
3601 * protocol or info columns.
3602 *
3603 * Just show the exception and then continue dissecting chunks.
3604 */
3606 }
3607 ENDTRY;
3617 /* The logic above should ensure this... */
3622 /* The stream_seq_num variable is used to hold the MID, the tsn variable holds the FSN*/
3629 }
3631 /* if unordered set stream_seq_num to 0 for easier handling */
3634 else
3636 }
3637 /* start reassembly */
3638 return dissect_fragmented_payload(payload_tvb, pinfo, tree, chunk_tree, tsn, payload_proto_id, stream_id, stream_seq_num, b_bit, e_bit, u_bit, is_idata);
3639 }
3641 }
3643 #define INIT_CHUNK_INITIATE_TAG_LENGTH 4
3644 #define INIT_CHUNK_ADV_REC_WINDOW_CREDIT_LENGTH 4
3645 #define INIT_CHUNK_NUMBER_OF_OUTBOUND_STREAMS_LENGTH 2
3646 #define INIT_CHUNK_NUMBER_OF_INBOUND_STREAMS_LENGTH 2
3647 #define INIT_CHUNK_INITIAL_TSN_LENGTH 4
3648 #define INIT_CHUNK_FIXED_PARAMTERS_LENGTH (CHUNK_HEADER_LENGTH + \
3649 INIT_CHUNK_INITIATE_TAG_LENGTH + \
3650 INIT_CHUNK_ADV_REC_WINDOW_CREDIT_LENGTH + \
3651 INIT_CHUNK_NUMBER_OF_OUTBOUND_STREAMS_LENGTH + \
3652 INIT_CHUNK_NUMBER_OF_INBOUND_STREAMS_LENGTH + \
3653 INIT_CHUNK_INITIAL_TSN_LENGTH)
3655 #define INIT_CHUNK_INITIATE_TAG_OFFSET CHUNK_VALUE_OFFSET
3656 #define INIT_CHUNK_ADV_REC_WINDOW_CREDIT_OFFSET (INIT_CHUNK_INITIATE_TAG_OFFSET + \
3657 INIT_CHUNK_INITIATE_TAG_LENGTH )
3658 #define INIT_CHUNK_NUMBER_OF_OUTBOUND_STREAMS_OFFSET (INIT_CHUNK_ADV_REC_WINDOW_CREDIT_OFFSET + \
3659 INIT_CHUNK_ADV_REC_WINDOW_CREDIT_LENGTH )
3660 #define INIT_CHUNK_NUMBER_OF_INBOUND_STREAMS_OFFSET (INIT_CHUNK_NUMBER_OF_OUTBOUND_STREAMS_OFFSET + \
3661 INIT_CHUNK_NUMBER_OF_OUTBOUND_STREAMS_LENGTH )
3662 #define INIT_CHUNK_INITIAL_TSN_OFFSET (INIT_CHUNK_NUMBER_OF_INBOUND_STREAMS_OFFSET + \
3663 INIT_CHUNK_NUMBER_OF_INBOUND_STREAMS_LENGTH )
3664 #define INIT_CHUNK_VARIABLE_LENGTH_PARAMETER_OFFSET (INIT_CHUNK_INITIAL_TSN_OFFSET + \
3665 INIT_CHUNK_INITIAL_TSN_LENGTH )
3667 static void
3668 // NOLINTNEXTLINE(misc-no-recursion)
3669 dissect_init_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, packet_info *pinfo, proto_tree *chunk_tree, proto_item *chunk_item)
3670 {
3675 proto_item_append_text(chunk_item, ", bogus chunk length %u < %u)", chunk_length, INIT_CHUNK_FIXED_PARAMTERS_LENGTH);
3677 }
3680 /* handle fixed parameters */
3681 proto_tree_add_item(chunk_tree, hf_init_chunk_initiate_tag, chunk_tvb, INIT_CHUNK_INITIATE_TAG_OFFSET, INIT_CHUNK_INITIATE_TAG_LENGTH, ENC_BIG_ENDIAN);
3682 hidden_item = proto_tree_add_item(chunk_tree, hf_initiate_tag, chunk_tvb, INIT_CHUNK_INITIATE_TAG_OFFSET, INIT_CHUNK_INITIATE_TAG_LENGTH, ENC_BIG_ENDIAN);
3684 proto_tree_add_item(chunk_tree, hf_init_chunk_adv_rec_window_credit, chunk_tvb, INIT_CHUNK_ADV_REC_WINDOW_CREDIT_OFFSET, INIT_CHUNK_ADV_REC_WINDOW_CREDIT_LENGTH, ENC_BIG_ENDIAN);
3685 proto_tree_add_item(chunk_tree, hf_init_chunk_number_of_outbound_streams, chunk_tvb, INIT_CHUNK_NUMBER_OF_OUTBOUND_STREAMS_OFFSET, INIT_CHUNK_NUMBER_OF_OUTBOUND_STREAMS_LENGTH, ENC_BIG_ENDIAN);
3686 proto_tree_add_item(chunk_tree, hf_init_chunk_number_of_inbound_streams, chunk_tvb, INIT_CHUNK_NUMBER_OF_INBOUND_STREAMS_OFFSET, INIT_CHUNK_NUMBER_OF_INBOUND_STREAMS_LENGTH, ENC_BIG_ENDIAN);
3687 proto_tree_add_item(chunk_tree, hf_init_chunk_initial_tsn, chunk_tvb, INIT_CHUNK_INITIAL_TSN_OFFSET, INIT_CHUNK_INITIAL_TSN_LENGTH, ENC_BIG_ENDIAN);
3692 }
3694 /* handle variable parameters */
3696 parameters_tvb = tvb_new_subset_length_caplen(chunk_tvb, INIT_CHUNK_VARIABLE_LENGTH_PARAMETER_OFFSET,
3697 MIN(chunk_length, tvb_captured_length_remaining(chunk_tvb, INIT_CHUNK_VARIABLE_LENGTH_PARAMETER_OFFSET)),
3698 MIN(chunk_length, tvb_reported_length_remaining(chunk_tvb, INIT_CHUNK_VARIABLE_LENGTH_PARAMETER_OFFSET)));
3700 }
3702 static void
3703 // NOLINTNEXTLINE(misc-no-recursion)
3704 dissect_init_ack_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, packet_info *pinfo, proto_tree *chunk_tree, proto_item *chunk_item)
3705 {
3711 chunk_length,
3712 INIT_CHUNK_FIXED_PARAMTERS_LENGTH);
3714 }
3716 /* handle fixed parameters */
3717 proto_tree_add_item(chunk_tree, hf_initack_chunk_initiate_tag, chunk_tvb, INIT_CHUNK_INITIATE_TAG_OFFSET, INIT_CHUNK_INITIATE_TAG_LENGTH, ENC_BIG_ENDIAN);
3718 hidden_item = proto_tree_add_item(chunk_tree, hf_initiate_tag, chunk_tvb, INIT_CHUNK_INITIATE_TAG_OFFSET, INIT_CHUNK_INITIATE_TAG_LENGTH, ENC_BIG_ENDIAN);
3720 proto_tree_add_item(chunk_tree, hf_initack_chunk_adv_rec_window_credit, chunk_tvb, INIT_CHUNK_ADV_REC_WINDOW_CREDIT_OFFSET, INIT_CHUNK_ADV_REC_WINDOW_CREDIT_LENGTH, ENC_BIG_ENDIAN);
3721 proto_tree_add_item(chunk_tree, hf_initack_chunk_number_of_outbound_streams, chunk_tvb, INIT_CHUNK_NUMBER_OF_OUTBOUND_STREAMS_OFFSET, INIT_CHUNK_NUMBER_OF_OUTBOUND_STREAMS_LENGTH, ENC_BIG_ENDIAN);
3722 proto_tree_add_item(chunk_tree, hf_initack_chunk_number_of_inbound_streams, chunk_tvb, INIT_CHUNK_NUMBER_OF_INBOUND_STREAMS_OFFSET, INIT_CHUNK_NUMBER_OF_INBOUND_STREAMS_LENGTH, ENC_BIG_ENDIAN);
3723 proto_tree_add_item(chunk_tree, hf_initack_chunk_initial_tsn, chunk_tvb, INIT_CHUNK_INITIAL_TSN_OFFSET, INIT_CHUNK_INITIAL_TSN_LENGTH, ENC_BIG_ENDIAN);
3728 }
3729 /* handle variable parameters */
3731 parameters_tvb = tvb_new_subset_length_caplen(chunk_tvb, INIT_CHUNK_VARIABLE_LENGTH_PARAMETER_OFFSET,
3732 MIN(chunk_length, tvb_captured_length_remaining(chunk_tvb, INIT_CHUNK_VARIABLE_LENGTH_PARAMETER_OFFSET)),
3733 MIN(chunk_length, tvb_reported_length_remaining(chunk_tvb, INIT_CHUNK_VARIABLE_LENGTH_PARAMETER_OFFSET)));
3735 }
3737 #define SCTP_SACK_CHUNK_NS_BIT 0x01
3738 #define SACK_CHUNK_CUMULATIVE_TSN_ACK_LENGTH 4
3739 #define SACK_CHUNK_ADV_REC_WINDOW_CREDIT_LENGTH 4
3740 #define SACK_CHUNK_NUMBER_OF_GAP_BLOCKS_LENGTH 2
3741 #define SACK_CHUNK_NUMBER_OF_DUP_TSNS_LENGTH 2
3742 #define SACK_CHUNK_GAP_BLOCK_LENGTH 4
3743 #define SACK_CHUNK_GAP_BLOCK_START_LENGTH 2
3744 #define SACK_CHUNK_GAP_BLOCK_END_LENGTH 2
3745 #define SACK_CHUNK_DUP_TSN_LENGTH 4
3747 #define SACK_CHUNK_CUMULATIVE_TSN_ACK_OFFSET (CHUNK_VALUE_OFFSET + 0)
3748 #define SACK_CHUNK_ADV_REC_WINDOW_CREDIT_OFFSET (SACK_CHUNK_CUMULATIVE_TSN_ACK_OFFSET + \
3749 SACK_CHUNK_CUMULATIVE_TSN_ACK_LENGTH)
3750 #define SACK_CHUNK_NUMBER_OF_GAP_BLOCKS_OFFSET (SACK_CHUNK_ADV_REC_WINDOW_CREDIT_OFFSET + \
3751 SACK_CHUNK_ADV_REC_WINDOW_CREDIT_LENGTH)
3752 #define SACK_CHUNK_NUMBER_OF_DUP_TSNS_OFFSET (SACK_CHUNK_NUMBER_OF_GAP_BLOCKS_OFFSET + \
3753 SACK_CHUNK_NUMBER_OF_GAP_BLOCKS_LENGTH)
3754 #define SACK_CHUNK_GAP_BLOCK_OFFSET (SACK_CHUNK_NUMBER_OF_DUP_TSNS_OFFSET + \
3755 SACK_CHUNK_NUMBER_OF_DUP_TSNS_LENGTH)
3758 static void
3759 dissect_sack_chunk(packet_info *pinfo, tvbuff_t *chunk_tvb, proto_tree *chunk_tree, proto_item *chunk_item, proto_item *flags_item, sctp_half_assoc_t *ha)
3760 {
3777 }
3780 proto_tree_add_item(flags_tree, hf_sack_chunk_ns, chunk_tvb, CHUNK_FLAGS_OFFSET, CHUNK_FLAGS_LENGTH, ENC_BIG_ENDIAN);
3782 ctsa_item = proto_tree_add_uint(chunk_tree, hf_sack_chunk_cumulative_tsn_ack, chunk_tvb, SACK_CHUNK_CUMULATIVE_TSN_ACK_OFFSET, SACK_CHUNK_CUMULATIVE_TSN_ACK_LENGTH, cum_tsn_ack);
3783 proto_tree_add_item(chunk_tree, hf_sack_chunk_cumulative_tsn_ack_raw, chunk_tvb, SACK_CHUNK_CUMULATIVE_TSN_ACK_OFFSET, SACK_CHUNK_CUMULATIVE_TSN_ACK_LENGTH, ENC_BIG_ENDIAN);
3784 }
3786 ctsa_item = proto_tree_add_item(chunk_tree, hf_sack_chunk_cumulative_tsn_ack_raw, chunk_tvb, SACK_CHUNK_CUMULATIVE_TSN_ACK_OFFSET, SACK_CHUNK_CUMULATIVE_TSN_ACK_LENGTH, ENC_BIG_ENDIAN);
3787 }
3788 a_rwnd_item = proto_tree_add_item(chunk_tree, hf_sack_chunk_adv_rec_window_credit, chunk_tvb, SACK_CHUNK_ADV_REC_WINDOW_CREDIT_OFFSET, SACK_CHUNK_ADV_REC_WINDOW_CREDIT_LENGTH, ENC_BIG_ENDIAN);
3789 proto_tree_add_item(chunk_tree, hf_sack_chunk_number_of_gap_blocks, chunk_tvb, SACK_CHUNK_NUMBER_OF_GAP_BLOCKS_OFFSET, SACK_CHUNK_NUMBER_OF_GAP_BLOCKS_LENGTH, ENC_BIG_ENDIAN);
3790 proto_tree_add_item(chunk_tree, hf_sack_chunk_number_of_dup_tsns, chunk_tvb, SACK_CHUNK_NUMBER_OF_DUP_TSNS_OFFSET, SACK_CHUNK_NUMBER_OF_DUP_TSNS_LENGTH, ENC_BIG_ENDIAN);
3797 /* handle the gap acknowledgement blocks */
3814 block_tree = proto_tree_add_subtree_format(chunk_tree, chunk_tvb, gap_block_offset, SACK_CHUNK_GAP_BLOCK_LENGTH,
3815 ett_sctp_sack_chunk_gap_block, NULL, "Gap Acknowledgement for TSN %u to %u", cum_tsn_ack + start, cum_tsn_ack + end);
3817 pi = proto_tree_add_item(block_tree, hf_sack_chunk_gap_block_start, chunk_tvb, gap_block_offset, SACK_CHUNK_GAP_BLOCK_START_LENGTH, ENC_BIG_ENDIAN);
3823 pi = proto_tree_add_item(block_tree, hf_sack_chunk_gap_block_end, chunk_tvb, gap_block_offset + SACK_CHUNK_GAP_BLOCK_START_LENGTH, SACK_CHUNK_GAP_BLOCK_END_LENGTH, ENC_BIG_ENDIAN);
3826 gap_block_offset + SACK_CHUNK_GAP_BLOCK_START_LENGTH, SACK_CHUNK_GAP_BLOCK_END_LENGTH, cum_tsn_ack + end);
3834 /* Check validity */
3837 }
3840 }
3842 }
3845 /* No GapAck -> only show CumAck */
3849 }
3851 /* Show CumAck + highest GapAck */
3855 }
3860 pi = proto_tree_add_uint(chunk_tree, hf_sack_chunk_number_tsns_gap_acked, chunk_tvb, 0, 0, tsns_gap_acked);
3863 /* If there are a huge number of GAP ACKs, warn the user. 100 is a random
3864 * number: it could be tuned.
3865 */
3869 }
3872 /* handle the duplicate TSNs */
3874 dup_tsn_offset = SACK_CHUNK_GAP_BLOCK_OFFSET + number_of_gap_blocks * SACK_CHUNK_GAP_BLOCK_LENGTH;
3876 proto_tree_add_item(chunk_tree, hf_sack_chunk_duplicate_tsn, chunk_tvb, dup_tsn_offset, SACK_CHUNK_DUP_TSN_LENGTH, ENC_BIG_ENDIAN);
3878 }
3880 proto_item_append_text(chunk_item, " (Cumulative TSN: %u, a_rwnd: %u, gaps: %u, duplicate TSNs: %u)",
3882 a_rwnd,
3884 }
3886 /* NE: Dissect nr-sack chunk */
3887 #define SCTP_NR_SACK_CHUNK_NS_BIT 0x01
3888 #define NR_SACK_CHUNK_CUMULATIVE_TSN_ACK_LENGTH 4
3889 #define NR_SACK_CHUNK_ADV_REC_WINDOW_CREDIT_LENGTH 4
3890 #define NR_SACK_CHUNK_NUMBER_OF_GAP_BLOCKS_LENGTH 2
3891 #define NR_SACK_CHUNK_NUMBER_OF_NR_GAP_BLOCKS_LENGTH 2
3892 #define NR_SACK_CHUNK_NUMBER_OF_DUP_TSNS_LENGTH 2
3893 #define NR_SACK_CHUNK_RESERVED_LENGTH 2
3894 #define NR_SACK_CHUNK_GAP_BLOCK_LENGTH 4
3895 #define NR_SACK_CHUNK_GAP_BLOCK_START_LENGTH 2
3896 #define NR_SACK_CHUNK_GAP_BLOCK_END_LENGTH 2
3897 #define NR_SACK_CHUNK_NR_GAP_BLOCK_LENGTH 4
3898 #define NR_SACK_CHUNK_NR_GAP_BLOCK_START_LENGTH 2
3899 #define NR_SACK_CHUNK_NR_GAP_BLOCK_END_LENGTH 2
3900 #define NR_SACK_CHUNK_DUP_TSN_LENGTH 4
3902 #define NR_SACK_CHUNK_CUMULATIVE_TSN_ACK_OFFSET (CHUNK_VALUE_OFFSET + 0)
3903 #define NR_SACK_CHUNK_ADV_REC_WINDOW_CREDIT_OFFSET (NR_SACK_CHUNK_CUMULATIVE_TSN_ACK_OFFSET + \
3904 NR_SACK_CHUNK_CUMULATIVE_TSN_ACK_LENGTH)
3905 #define NR_SACK_CHUNK_NUMBER_OF_GAP_BLOCKS_OFFSET (NR_SACK_CHUNK_ADV_REC_WINDOW_CREDIT_OFFSET + \
3906 NR_SACK_CHUNK_ADV_REC_WINDOW_CREDIT_LENGTH)
3907 #define NR_SACK_CHUNK_NUMBER_OF_NR_GAP_BLOCKS_OFFSET (NR_SACK_CHUNK_NUMBER_OF_GAP_BLOCKS_OFFSET + \
3908 NR_SACK_CHUNK_NUMBER_OF_GAP_BLOCKS_LENGTH)
3909 #define NR_SACK_CHUNK_NUMBER_OF_DUP_TSNS_OFFSET (NR_SACK_CHUNK_NUMBER_OF_NR_GAP_BLOCKS_OFFSET + \
3910 NR_SACK_CHUNK_NUMBER_OF_NR_GAP_BLOCKS_LENGTH)
3911 #define NR_SACK_CHUNK_RESERVED_OFFSET (NR_SACK_CHUNK_NUMBER_OF_DUP_TSNS_OFFSET + \
3912 NR_SACK_CHUNK_NUMBER_OF_DUP_TSNS_LENGTH)
3913 #define NR_SACK_CHUNK_GAP_BLOCK_OFFSET (NR_SACK_CHUNK_RESERVED_OFFSET + \
3914 NR_SACK_CHUNK_RESERVED_LENGTH)
3916 static void
3917 dissect_nr_sack_chunk(packet_info *pinfo, tvbuff_t *chunk_tvb, proto_tree *chunk_tree, proto_item *chunk_item, proto_item *flags_item, sctp_half_assoc_t *ha)
3918 {
3933 proto_tree_add_item(flags_tree, hf_nr_sack_chunk_ns, chunk_tvb, CHUNK_FLAGS_OFFSET, CHUNK_FLAGS_LENGTH, ENC_BIG_ENDIAN);
3935 ctsa_item = proto_tree_add_item(chunk_tree, hf_nr_sack_chunk_cumulative_tsn_ack, chunk_tvb, NR_SACK_CHUNK_CUMULATIVE_TSN_ACK_OFFSET, NR_SACK_CHUNK_CUMULATIVE_TSN_ACK_LENGTH, ENC_BIG_ENDIAN);
3936 proto_tree_add_item(chunk_tree, hf_nr_sack_chunk_adv_rec_window_credit, chunk_tvb, NR_SACK_CHUNK_ADV_REC_WINDOW_CREDIT_OFFSET, NR_SACK_CHUNK_ADV_REC_WINDOW_CREDIT_LENGTH, ENC_BIG_ENDIAN);
3938 proto_tree_add_item(chunk_tree, hf_nr_sack_chunk_number_of_gap_blocks, chunk_tvb, NR_SACK_CHUNK_NUMBER_OF_GAP_BLOCKS_OFFSET, NR_SACK_CHUNK_NUMBER_OF_GAP_BLOCKS_LENGTH, ENC_BIG_ENDIAN);
3940 proto_tree_add_item(chunk_tree, hf_nr_sack_chunk_number_of_nr_gap_blocks, chunk_tvb, NR_SACK_CHUNK_NUMBER_OF_NR_GAP_BLOCKS_OFFSET, NR_SACK_CHUNK_NUMBER_OF_NR_GAP_BLOCKS_LENGTH, ENC_BIG_ENDIAN);
3941 proto_tree_add_item(chunk_tree, hf_nr_sack_chunk_number_of_dup_tsns, chunk_tvb, NR_SACK_CHUNK_NUMBER_OF_DUP_TSNS_OFFSET, NR_SACK_CHUNK_NUMBER_OF_DUP_TSNS_LENGTH, ENC_BIG_ENDIAN);
3942 proto_tree_add_item(chunk_tree, hf_nr_sack_chunk_reserved, chunk_tvb, NR_SACK_CHUNK_RESERVED_OFFSET, NR_SACK_CHUNK_RESERVED_LENGTH, ENC_BIG_ENDIAN);
3962 block_tree = proto_tree_add_subtree_format(chunk_tree, chunk_tvb, gap_block_offset, NR_SACK_CHUNK_GAP_BLOCK_LENGTH,
3963 ett_sctp_nr_sack_chunk_gap_block, NULL, "Gap Acknowledgement for TSN %u to %u", cum_tsn_ack + start, cum_tsn_ack + end);
3965 pi = proto_tree_add_item(block_tree, hf_nr_sack_chunk_gap_block_start, chunk_tvb, gap_block_offset, NR_SACK_CHUNK_GAP_BLOCK_START_LENGTH, ENC_BIG_ENDIAN);
3971 pi = proto_tree_add_item(block_tree, hf_nr_sack_chunk_gap_block_end, chunk_tvb, gap_block_offset + NR_SACK_CHUNK_GAP_BLOCK_START_LENGTH, NR_SACK_CHUNK_GAP_BLOCK_END_LENGTH, ENC_BIG_ENDIAN);
3974 gap_block_offset + NR_SACK_CHUNK_GAP_BLOCK_START_LENGTH, NR_SACK_CHUNK_GAP_BLOCK_END_LENGTH, cum_tsn_ack + end);
3981 /* Check validity */
3984 }
3987 }
3989 }
3994 pi = proto_tree_add_uint(chunk_tree, hf_nr_sack_chunk_number_tsns_gap_acked, chunk_tvb, 0, 0, tsns_gap_acked);
3997 /* If there are a huge number of GAP ACKs, warn the user. 100 is a random
3998 * number: it could be tuned.
3999 */
4003 }
4005 /* NE: handle the nr-sack chunk's nr-gap blocks */
4006 number_of_nr_gap_blocks = tvb_get_ntohs(chunk_tvb, NR_SACK_CHUNK_NUMBER_OF_NR_GAP_BLOCKS_OFFSET);
4010 for(nr_gap_block_number = 0; nr_gap_block_number < number_of_nr_gap_blocks; nr_gap_block_number++) {
4013 /*uint32_t tsn_start;*/
4017 /*tsn_start = cum_tsn_ack + start;*/
4019 block_tree = proto_tree_add_subtree_format(chunk_tree, chunk_tvb, nr_gap_block_offset, NR_SACK_CHUNK_NR_GAP_BLOCK_LENGTH,
4020 ett_sctp_nr_sack_chunk_nr_gap_block, NULL, "NR-Gap Acknowledgement for TSN %u to %u", cum_tsn_ack + start, cum_tsn_ack + end);
4022 pi = proto_tree_add_item(block_tree, hf_nr_sack_chunk_nr_gap_block_start, chunk_tvb, nr_gap_block_offset, NR_SACK_CHUNK_NR_GAP_BLOCK_START_LENGTH, ENC_BIG_ENDIAN);
4028 pi = proto_tree_add_item(block_tree, hf_nr_sack_chunk_nr_gap_block_end, chunk_tvb, nr_gap_block_offset + NR_SACK_CHUNK_NR_GAP_BLOCK_START_LENGTH, NR_SACK_CHUNK_NR_GAP_BLOCK_END_LENGTH, ENC_BIG_ENDIAN);
4031 nr_gap_block_offset + NR_SACK_CHUNK_NR_GAP_BLOCK_START_LENGTH, NR_SACK_CHUNK_NR_GAP_BLOCK_END_LENGTH, cum_tsn_ack + end);
4034 /* sctp_ack_block(pinfo, ha, chunk_tvb, block_tree, &tsn_start, cum_tsn_ack + end); */
4038 /* Check validity */
4041 }
4044 }
4046 }
4051 pi = proto_tree_add_uint(chunk_tree, hf_nr_sack_chunk_number_tsns_nr_gap_acked, chunk_tvb, 0, 0, tsns_nr_gap_acked);
4054 /* If there are a huge number of GAP ACKs, warn the user. 100 is a random
4055 * number: it could be tuned.
4056 */
4059 }
4061 /* handle the duplicate TSNs */
4063 dup_tsn_offset = NR_SACK_CHUNK_GAP_BLOCK_OFFSET + number_of_gap_blocks * NR_SACK_CHUNK_GAP_BLOCK_LENGTH
4068 proto_tree_add_item(chunk_tree, hf_nr_sack_chunk_duplicate_tsn, chunk_tvb, dup_tsn_offset, NR_SACK_CHUNK_DUP_TSN_LENGTH, ENC_BIG_ENDIAN);
4070 }
4072 proto_item_append_text(chunk_item, " (Cumulative TSN: %u, a_rwnd: %u, gaps: %u, nr-gaps: %u, duplicate TSNs: %u)",
4076 }
4078 #define HEARTBEAT_CHUNK_INFO_OFFSET CHUNK_VALUE_OFFSET
4080 static void
4081 // NOLINTNEXTLINE(misc-no-recursion)
4082 dissect_heartbeat_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, packet_info *pinfo, proto_tree *chunk_tree, proto_item *chunk_item)
4083 {
4087 proto_item_append_text(chunk_item, " (Information: %u byte%s)", chunk_length - CHUNK_HEADER_LENGTH, plurality(chunk_length - CHUNK_HEADER_LENGTH, "", "s"));
4089 MIN(chunk_length - CHUNK_HEADER_LENGTH, tvb_captured_length_remaining(chunk_tvb, HEARTBEAT_CHUNK_INFO_OFFSET)),
4090 MIN(chunk_length - CHUNK_HEADER_LENGTH, tvb_reported_length_remaining(chunk_tvb, HEARTBEAT_CHUNK_INFO_OFFSET)));
4091 /* FIXME: Parameters or parameter? */
4093 }
4094 }
4096 #define HEARTBEAT_ACK_CHUNK_INFO_OFFSET CHUNK_VALUE_OFFSET
4098 static void
4099 // NOLINTNEXTLINE(misc-no-recursion)
4100 dissect_heartbeat_ack_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, packet_info *pinfo, proto_tree *chunk_tree, proto_item *chunk_item)
4101 {
4105 proto_item_append_text(chunk_item, " (Information: %u byte%s)", chunk_length - CHUNK_HEADER_LENGTH, plurality(chunk_length - CHUNK_HEADER_LENGTH, "", "s"));
4107 MIN(chunk_length - CHUNK_HEADER_LENGTH, tvb_captured_length_remaining(chunk_tvb, HEARTBEAT_ACK_CHUNK_INFO_OFFSET)),
4108 MIN(chunk_length - CHUNK_HEADER_LENGTH, tvb_reported_length_remaining(chunk_tvb, HEARTBEAT_ACK_CHUNK_INFO_OFFSET)));
4109 /* FIXME: Parameters or parameter? */
4111 }
4112 }
4114 #define ABORT_CHUNK_FIRST_ERROR_CAUSE_OFFSET 4
4115 #define SCTP_ABORT_CHUNK_T_BIT 0x01
4117 static void
4118 // NOLINTNEXTLINE(misc-no-recursion)
4119 dissect_abort_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, packet_info *pinfo, proto_tree *chunk_tree, proto_item *flags_item)
4120 {
4129 proto_tree_add_item(flags_tree, hf_abort_chunk_t_bit, chunk_tvb, CHUNK_FLAGS_OFFSET, CHUNK_FLAGS_LENGTH, ENC_BIG_ENDIAN);
4131 MIN(chunk_length - CHUNK_HEADER_LENGTH, tvb_captured_length_remaining(chunk_tvb, CHUNK_VALUE_OFFSET)),
4132 MIN(chunk_length - CHUNK_HEADER_LENGTH, tvb_reported_length_remaining(chunk_tvb, CHUNK_VALUE_OFFSET)));
4134 }
4135 }
4137 #define SHUTDOWN_CHUNK_CUMULATIVE_TSN_ACK_OFFSET CHUNK_VALUE_OFFSET
4138 #define SHUTDOWN_CHUNK_CUMULATIVE_TSN_ACK_LENGTH 4
4140 static void
4142 {
4144 proto_tree_add_item(chunk_tree, hf_shutdown_chunk_cumulative_tsn_ack, chunk_tvb, SHUTDOWN_CHUNK_CUMULATIVE_TSN_ACK_OFFSET, SHUTDOWN_CHUNK_CUMULATIVE_TSN_ACK_LENGTH, ENC_BIG_ENDIAN);
4145 proto_item_append_text(chunk_item, " (Cumulative TSN ack: %u)", tvb_get_ntohl(chunk_tvb, SHUTDOWN_CHUNK_CUMULATIVE_TSN_ACK_OFFSET));
4146 }
4147 }
4149 static void
4151 {
4152 }
4154 #define ERROR_CAUSE_IND_CAUSES_OFFSET CHUNK_VALUE_OFFSET
4156 static void
4157 // NOLINTNEXTLINE(misc-no-recursion)
4158 dissect_error_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, packet_info *pinfo, proto_tree *chunk_tree)
4159 {
4164 MIN(chunk_length - CHUNK_HEADER_LENGTH, tvb_captured_length_remaining(chunk_tvb, ERROR_CAUSE_IND_CAUSES_OFFSET)),
4165 MIN(chunk_length - CHUNK_HEADER_LENGTH, tvb_reported_length_remaining(chunk_tvb, ERROR_CAUSE_IND_CAUSES_OFFSET)));
4167 }
4168 }
4170 #define COOKIE_OFFSET CHUNK_VALUE_OFFSET
4172 static void
4173 dissect_cookie_echo_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, proto_tree *chunk_tree, proto_item *chunk_item)
4174 {
4176 proto_tree_add_item(chunk_tree, hf_cookie, chunk_tvb, COOKIE_OFFSET, chunk_length - CHUNK_HEADER_LENGTH, ENC_NA);
4177 proto_item_append_text(chunk_item, " (Cookie length: %u byte%s)", chunk_length - CHUNK_HEADER_LENGTH, plurality(chunk_length - CHUNK_HEADER_LENGTH, "", "s"));
4178 }
4179 }
4181 static void
4183 {
4184 }
4186 #define ECNE_CHUNK_LOWEST_TSN_OFFSET CHUNK_VALUE_OFFSET
4187 #define ECNE_CHUNK_LOWEST_TSN_LENGTH 4
4189 static void
4191 {
4192 proto_tree_add_item(chunk_tree, hf_ecne_chunk_lowest_tsn, chunk_tvb, ECNE_CHUNK_LOWEST_TSN_OFFSET, ECNE_CHUNK_LOWEST_TSN_LENGTH, ENC_BIG_ENDIAN);
4193 proto_item_append_text(chunk_item, " (Lowest TSN: %u)", tvb_get_ntohl(chunk_tvb, ECNE_CHUNK_LOWEST_TSN_OFFSET));
4194 }
4196 #define CWR_CHUNK_LOWEST_TSN_OFFSET CHUNK_VALUE_OFFSET
4197 #define CWR_CHUNK_LOWEST_TSN_LENGTH 4
4199 static void
4201 {
4202 proto_tree_add_item(chunk_tree, hf_cwr_chunk_lowest_tsn, chunk_tvb, CWR_CHUNK_LOWEST_TSN_OFFSET, CWR_CHUNK_LOWEST_TSN_LENGTH, ENC_BIG_ENDIAN);
4203 proto_item_append_text(chunk_item, " (Lowest TSN: %u)", tvb_get_ntohl(chunk_tvb, CWR_CHUNK_LOWEST_TSN_OFFSET));
4204 }
4206 #define SCTP_SHUTDOWN_COMPLETE_CHUNK_T_BIT 0x01
4211 "Tag not reflected"
4212 };
4215 static void
4216 dissect_shutdown_complete_chunk(tvbuff_t *chunk_tvb, proto_tree *chunk_tree, proto_item *flags_item)
4217 {
4225 proto_tree_add_item(flags_tree, hf_shutdown_complete_chunk_t_bit, chunk_tvb, CHUNK_FLAGS_OFFSET, CHUNK_FLAGS_LENGTH, ENC_BIG_ENDIAN);
4226 }
4227 }
4229 #define FORWARD_TSN_CHUNK_TSN_LENGTH 4
4230 #define FORWARD_TSN_CHUNK_SID_LENGTH 2
4231 #define FORWARD_TSN_CHUNK_SSN_LENGTH 2
4232 #define FORWARD_TSN_CHUNK_TSN_OFFSET CHUNK_VALUE_OFFSET
4233 #define FORWARD_TSN_CHUNK_SID_OFFSET 0
4234 #define FORWARD_TSN_CHUNK_SSN_OFFSET (FORWARD_TSN_CHUNK_SID_OFFSET + FORWARD_TSN_CHUNK_SID_LENGTH)
4236 static void
4237 dissect_forward_tsn_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, proto_tree *chunk_tree, proto_item *chunk_item)
4238 {
4242 /* FIXME */
4245 chunk_length,
4248 }
4250 proto_tree_add_item(chunk_tree, hf_forward_tsn_chunk_tsn, chunk_tvb, FORWARD_TSN_CHUNK_TSN_OFFSET, FORWARD_TSN_CHUNK_TSN_LENGTH, ENC_BIG_ENDIAN);
4251 number_of_affected_streams = (chunk_length - CHUNK_HEADER_LENGTH - FORWARD_TSN_CHUNK_TSN_LENGTH) /
4256 proto_tree_add_item(chunk_tree, hf_forward_tsn_chunk_sid, chunk_tvb, offset + FORWARD_TSN_CHUNK_SID_OFFSET, FORWARD_TSN_CHUNK_SID_LENGTH, ENC_BIG_ENDIAN);
4257 proto_tree_add_item(chunk_tree, hf_forward_tsn_chunk_ssn, chunk_tvb, offset + FORWARD_TSN_CHUNK_SSN_OFFSET, FORWARD_TSN_CHUNK_SSN_LENGTH, ENC_BIG_ENDIAN);
4259 }
4260 proto_item_append_text(chunk_item, "(Cumulative TSN: %u)", tvb_get_ntohl(chunk_tvb, FORWARD_TSN_CHUNK_TSN_OFFSET));
4261 }
4262 }
4264 #define I_FORWARD_TSN_CHUNK_TSN_LENGTH 4
4265 #define I_FORWARD_TSN_CHUNK_SID_LENGTH 2
4266 #define I_FORWARD_TSN_CHUNK_FLAGS_LENGTH 2
4267 #define I_FORWARD_TSN_CHUNK_MID_LENGTH 4
4268 #define I_FORWARD_TSN_CHUNK_TSN_OFFSET CHUNK_VALUE_OFFSET
4269 #define I_FORWARD_TSN_CHUNK_SID_OFFSET 0
4270 #define I_FORWARD_TSN_CHUNK_FLAGS_OFFSET (I_FORWARD_TSN_CHUNK_SID_OFFSET + I_FORWARD_TSN_CHUNK_SID_LENGTH)
4271 #define I_FORWARD_TSN_CHUNK_MID_OFFSET (I_FORWARD_TSN_CHUNK_FLAGS_OFFSET + I_FORWARD_TSN_CHUNK_FLAGS_LENGTH)
4273 #define SCTP_I_FORWARD_TSN_CHUNK_U_BIT 0x0001
4274 #define SCTP_I_FORWARD_TSN_CHUNK_RES_MASK 0xfffe
4278 "Ordered messages"
4279 };
4281 static void
4282 dissect_i_forward_tsn_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, proto_tree *chunk_tree, proto_item *chunk_item)
4283 {
4289 /* FIXME */
4292 chunk_length,
4295 }
4297 proto_tree_add_item(chunk_tree, hf_i_forward_tsn_chunk_tsn, chunk_tvb, I_FORWARD_TSN_CHUNK_TSN_OFFSET, I_FORWARD_TSN_CHUNK_TSN_LENGTH, ENC_BIG_ENDIAN);
4298 number_of_affected_streams = (chunk_length - CHUNK_HEADER_LENGTH - I_FORWARD_TSN_CHUNK_TSN_LENGTH) /
4299 (I_FORWARD_TSN_CHUNK_SID_LENGTH + I_FORWARD_TSN_CHUNK_FLAGS_LENGTH + I_FORWARD_TSN_CHUNK_MID_LENGTH);
4303 proto_tree_add_item(chunk_tree, hf_i_forward_tsn_chunk_sid, chunk_tvb, offset + I_FORWARD_TSN_CHUNK_SID_OFFSET, I_FORWARD_TSN_CHUNK_SID_LENGTH, ENC_BIG_ENDIAN);
4304 flags_item = proto_tree_add_item(chunk_tree, hf_i_forward_tsn_chunk_flags, chunk_tvb, offset + I_FORWARD_TSN_CHUNK_FLAGS_OFFSET, I_FORWARD_TSN_CHUNK_FLAGS_LENGTH, ENC_BIG_ENDIAN);
4306 proto_tree_add_item(flags_tree, hf_i_forward_tsn_chunk_res, chunk_tvb, offset + I_FORWARD_TSN_CHUNK_FLAGS_OFFSET, I_FORWARD_TSN_CHUNK_FLAGS_LENGTH, ENC_BIG_ENDIAN);
4307 proto_tree_add_item(flags_tree, hf_i_forward_tsn_chunk_u_bit, chunk_tvb, offset + I_FORWARD_TSN_CHUNK_FLAGS_OFFSET, I_FORWARD_TSN_CHUNK_FLAGS_LENGTH, ENC_BIG_ENDIAN);
4308 proto_tree_add_item(chunk_tree, hf_i_forward_tsn_chunk_mid, chunk_tvb, offset + I_FORWARD_TSN_CHUNK_MID_OFFSET, I_FORWARD_TSN_CHUNK_MID_LENGTH, ENC_BIG_ENDIAN);
4309 offset += (I_FORWARD_TSN_CHUNK_SID_LENGTH + I_FORWARD_TSN_CHUNK_FLAGS_LENGTH + I_FORWARD_TSN_CHUNK_MID_LENGTH);
4310 }
4311 proto_item_append_text(chunk_item, "(Cumulative TSN: %u)", tvb_get_ntohl(chunk_tvb, I_FORWARD_TSN_CHUNK_TSN_OFFSET));
4312 }
4313 }
4315 #define RE_CONFIG_PARAMETERS_OFFSET CHUNK_HEADER_LENGTH
4317 static void
4318 // NOLINTNEXTLINE(misc-no-recursion)
4319 dissect_re_config_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, packet_info *pinfo, proto_tree *chunk_tree, proto_item *chunk_item _U_)
4320 {
4324 MIN(chunk_length - CHUNK_HEADER_LENGTH, tvb_captured_length_remaining(chunk_tvb, RE_CONFIG_PARAMETERS_OFFSET)),
4325 MIN(chunk_length - CHUNK_HEADER_LENGTH, tvb_reported_length_remaining(chunk_tvb, RE_CONFIG_PARAMETERS_OFFSET)));
4327 }
4329 #define SHARED_KEY_ID_LENGTH 2
4331 #define SHARED_KEY_ID_OFFSET PARAMETER_VALUE_OFFSET
4332 #define HMAC_ID_OFFSET (SHARED_KEY_ID_OFFSET + SHARED_KEY_ID_LENGTH)
4333 #define HMAC_OFFSET (HMAC_ID_OFFSET + HMAC_ID_LENGTH)
4335 static void
4336 dissect_auth_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, proto_tree *chunk_tree, proto_item *chunk_item _U_)
4337 {
4341 proto_tree_add_item(chunk_tree, hf_shared_key_id, chunk_tvb, SHARED_KEY_ID_OFFSET, SHARED_KEY_ID_LENGTH, ENC_BIG_ENDIAN);
4342 proto_tree_add_item(chunk_tree, hf_hmac_id, chunk_tvb, HMAC_ID_OFFSET, HMAC_ID_LENGTH, ENC_BIG_ENDIAN);
4345 }
4347 #define SCTP_SEQUENCE_NUMBER_LENGTH 4
4348 #define SEQUENCE_NUMBER_OFFSET CHUNK_VALUE_OFFSET
4349 #define ASCONF_CHUNK_PARAMETERS_OFFSET (SEQUENCE_NUMBER_OFFSET + SCTP_SEQUENCE_NUMBER_LENGTH)
4351 static void
4352 // NOLINTNEXTLINE(misc-no-recursion)
4353 dissect_asconf_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, packet_info *pinfo, proto_tree *chunk_tree, proto_item *chunk_item)
4354 {
4359 chunk_length,
4362 }
4364 proto_tree_add_item(chunk_tree, hf_asconf_seq_nr, chunk_tvb, SEQUENCE_NUMBER_OFFSET, SCTP_SEQUENCE_NUMBER_LENGTH, ENC_BIG_ENDIAN);
4365 }
4371 }
4373 #define ASCONF_ACK_CHUNK_PARAMETERS_OFFSET (SEQUENCE_NUMBER_OFFSET + SCTP_SEQUENCE_NUMBER_LENGTH)
4375 static void
4376 // NOLINTNEXTLINE(misc-no-recursion)
4377 dissect_asconf_ack_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, packet_info *pinfo, proto_tree *chunk_tree, proto_item *chunk_item)
4378 {
4386 }
4388 proto_tree_add_item(chunk_tree, hf_asconf_ack_seq_nr, chunk_tvb, SEQUENCE_NUMBER_OFFSET, SCTP_SEQUENCE_NUMBER_LENGTH, ENC_BIG_ENDIAN);
4389 }
4392 MIN(chunk_length, tvb_captured_length_remaining(chunk_tvb, ASCONF_ACK_CHUNK_PARAMETERS_OFFSET)),
4393 MIN(chunk_length, tvb_reported_length_remaining(chunk_tvb, ASCONF_ACK_CHUNK_PARAMETERS_OFFSET)));
4395 }
4397 #define PKTDROP_CHUNK_BANDWIDTH_LENGTH 4
4398 #define PKTDROP_CHUNK_QUEUESIZE_LENGTH 4
4399 #define PKTDROP_CHUNK_TRUNCATED_SIZE_LENGTH 2
4400 #define PKTDROP_CHUNK_RESERVED_SIZE_LENGTH 2
4402 #define PKTDROP_CHUNK_HEADER_LENGTH (CHUNK_HEADER_LENGTH + \
4403 PKTDROP_CHUNK_BANDWIDTH_LENGTH + \
4404 PKTDROP_CHUNK_QUEUESIZE_LENGTH + \
4405 PKTDROP_CHUNK_TRUNCATED_SIZE_LENGTH + \
4406 PKTDROP_CHUNK_RESERVED_SIZE_LENGTH)
4408 #define PKTDROP_CHUNK_BANDWIDTH_OFFSET CHUNK_VALUE_OFFSET
4409 #define PKTDROP_CHUNK_QUEUESIZE_OFFSET (PKTDROP_CHUNK_BANDWIDTH_OFFSET + PKTDROP_CHUNK_BANDWIDTH_LENGTH)
4410 #define PKTDROP_CHUNK_TRUNCATED_SIZE_OFFSET (PKTDROP_CHUNK_QUEUESIZE_OFFSET + PKTDROP_CHUNK_QUEUESIZE_LENGTH)
4411 #define PKTDROP_CHUNK_RESERVED_SIZE_OFFSET (PKTDROP_CHUNK_TRUNCATED_SIZE_OFFSET + PKTDROP_CHUNK_TRUNCATED_SIZE_LENGTH)
4412 #define PKTDROP_CHUNK_DATA_FIELD_OFFSET (PKTDROP_CHUNK_RESERVED_SIZE_OFFSET + PKTDROP_CHUNK_RESERVED_SIZE_LENGTH)
4414 #define SCTP_PKTDROP_CHUNK_M_BIT 0x01
4415 #define SCTP_PKTDROP_CHUNK_B_BIT 0x02
4416 #define SCTP_PKTDROP_CHUNK_T_BIT 0x04
4420 "Source is an endhost"
4421 };
4425 "SCTP checksum was correct"
4426 };
4430 "Packet is not truncated"
4431 };
4433 static void
4434 // NOLINTNEXTLINE(misc-no-recursion)
4435 dissect_pktdrop_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, packet_info *pinfo, proto_tree *chunk_tree, proto_item *chunk_item, proto_item *flags_item)
4436 {
4442 chunk_length,
4443 PKTDROP_CHUNK_HEADER_LENGTH);
4445 }
4454 proto_tree_add_item(flags_tree, hf_pktdrop_chunk_m_bit, chunk_tvb, CHUNK_FLAGS_OFFSET, CHUNK_FLAGS_LENGTH, ENC_BIG_ENDIAN);
4455 proto_tree_add_item(flags_tree, hf_pktdrop_chunk_b_bit, chunk_tvb, CHUNK_FLAGS_OFFSET, CHUNK_FLAGS_LENGTH, ENC_BIG_ENDIAN);
4456 proto_tree_add_item(flags_tree, hf_pktdrop_chunk_t_bit, chunk_tvb, CHUNK_FLAGS_OFFSET, CHUNK_FLAGS_LENGTH, ENC_BIG_ENDIAN);
4457 proto_tree_add_item(chunk_tree, hf_pktdrop_chunk_bandwidth, chunk_tvb, PKTDROP_CHUNK_BANDWIDTH_OFFSET, PKTDROP_CHUNK_BANDWIDTH_LENGTH, ENC_BIG_ENDIAN);
4458 proto_tree_add_item(chunk_tree, hf_pktdrop_chunk_queuesize, chunk_tvb, PKTDROP_CHUNK_QUEUESIZE_OFFSET, PKTDROP_CHUNK_QUEUESIZE_LENGTH, ENC_BIG_ENDIAN);
4459 proto_tree_add_item(chunk_tree, hf_pktdrop_chunk_truncated_length, chunk_tvb, PKTDROP_CHUNK_TRUNCATED_SIZE_OFFSET, PKTDROP_CHUNK_TRUNCATED_SIZE_LENGTH, ENC_BIG_ENDIAN);
4460 proto_tree_add_item(chunk_tree, hf_pktdrop_chunk_reserved, chunk_tvb, PKTDROP_CHUNK_RESERVED_SIZE_OFFSET, PKTDROP_CHUNK_RESERVED_SIZE_LENGTH, ENC_BIG_ENDIAN);
4463 /* XXX - We should dissect what we can and catch the BoundsError when we run out of bytes */
4465 proto_tree_add_item(chunk_tree, hf_pktdrop_chunk_data_field, chunk_tvb, PKTDROP_CHUNK_DATA_FIELD_OFFSET, chunk_length, ENC_NA);
4473 }
4474 }
4475 }
4476 }
4478 static void
4479 dissect_pad_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, proto_tree *chunk_tree, proto_item *chunk_item)
4480 {
4485 proto_tree_add_item(chunk_tree, hf_pad_chunk_padding_data, chunk_tvb, CHUNK_VALUE_OFFSET, value_length, ENC_NA);
4486 proto_item_append_text(chunk_item, " (Padding data length: %u byte%s)", value_length, plurality(value_length, "", "s"));
4487 }
4488 }
4490 static void
4491 dissect_unknown_chunk(tvbuff_t *chunk_tvb, uint16_t chunk_length, uint8_t chunk_type, proto_tree *chunk_tree, proto_item *chunk_item)
4492 {
4498 proto_tree_add_item(chunk_tree, hf_chunk_value, chunk_tvb, CHUNK_VALUE_OFFSET, value_length, ENC_NA);
4499 proto_item_append_text(chunk_item, " (Type: %u, value length: %u byte%s)", chunk_type, value_length, plurality(value_length, "", "s"));
4500 }
4501 }
4503 #define SCTP_CHUNK_BIT_1 0x80
4504 #define SCTP_CHUNK_BIT_2 0x40
4508 "Stop processing of the packet"
4509 };
4513 "Do not report"
4514 };
4517 static bool
4518 // NOLINTNEXTLINE(misc-no-recursion)
4525 {
4534 /* first extract the chunk header */
4541 col_append_fstr(pinfo->cinfo, COL_INFO, "%s ", val_to_str_const(type, chunk_type_values, "RESERVED"));
4543 /* create proto_tree stuff */
4544 chunk_item = proto_tree_add_none_format(sctp_tree, hf_chunk, chunk_tvb, CHUNK_HEADER_OFFSET, reported_length,
4549 /* then insert the chunk header components into the protocol tree */
4550 type_item = proto_tree_add_item(chunk_tree, hf_chunk_type, chunk_tvb, CHUNK_TYPE_OFFSET, CHUNK_TYPE_LENGTH, ENC_BIG_ENDIAN);
4552 proto_tree_add_item(type_tree, hf_chunk_bit_1, chunk_tvb, CHUNK_TYPE_OFFSET, CHUNK_TYPE_LENGTH, ENC_BIG_ENDIAN);
4553 proto_tree_add_item(type_tree, hf_chunk_bit_2, chunk_tvb, CHUNK_TYPE_OFFSET, CHUNK_TYPE_LENGTH, ENC_BIG_ENDIAN);
4554 flags_item = proto_tree_add_item(chunk_tree, hf_chunk_flags, chunk_tvb, CHUNK_FLAGS_OFFSET, CHUNK_FLAGS_LENGTH, ENC_BIG_ENDIAN);
4559 }
4563 proto_tree_add_uint_format_value(chunk_tree, hf_chunk_length, chunk_tvb, CHUNK_LENGTH_OFFSET, CHUNK_LENGTH_LENGTH, length,
4565 proto_item_append_text(chunk_item, ", bogus chunk length %u < %u)", length, CHUNK_HEADER_LENGTH);
4566 }
4571 }
4573 length_item = proto_tree_add_uint(chunk_tree, hf_chunk_length, chunk_tvb, CHUNK_LENGTH_OFFSET, CHUNK_LENGTH_LENGTH, length);
4575 expert_add_info_format(pinfo, length_item, &ei_sctp_chunk_length_bad, "Chunk length (%d) is longer than remaining data (%d) in the packet.", length, reported_length);
4576 /* We'll almost certainly throw an exception shortly... */
4577 }
4579 /*
4580 length -= CHUNK_HEADER_LENGTH;
4581 */
4583 /* now dissect the chunk value */
4587 result = dissect_data_chunk(chunk_tvb, length, pinfo, tree, chunk_tree, chunk_item, flags_item, ha, false);
4590 result = dissect_data_chunk(chunk_tvb, length, pinfo, tree, chunk_tree, chunk_item, flags_item, ha, true);
4666 }
4670 proto_tree_add_item(chunk_tree, hf_chunk_padding, chunk_tvb, CHUNK_HEADER_OFFSET + length, padding_length, ENC_NA);
4676 }
4678 static void
4679 // NOLINTNEXTLINE(misc-no-recursion)
4680 dissect_sctp_chunks(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, proto_item *sctp_item, proto_tree *sctp_tree, sctp_half_assoc_t *ha, bool encapsulated, proto_item *vt)
4681 {
4687 assoc_info_t tmpinfo;
4688 infodata_t id_dir;
4691 /* the common header of the datagram is already handled */
4697 /* extract the chunk length and compute number of padding bytes */
4701 /* If we have less bytes than we need, throw an exception while dissecting
4702 * the chunk--not when generating the chunk_tvb below.
4703 */
4706 /* create a tvb for the chunk including the padding bytes */
4707 chunk_tvb = tvb_new_subset_length_caplen(tvb, offset, MIN(total_length, tvb_captured_length_remaining(tvb, offset)), total_length);
4709 /* save it in the sctp_info structure */
4713 else
4715 }
4726 /* Certain chunk types have exceptional Verification Tag handling
4727 * ( see https://datatracker.ietf.org/doc/html/rfc9260#section-8.5.1 )
4728 * XXX: Those chunk types shouldn't be bundled with other chunk types
4729 * (ABORT can be bundled after other control types, but ABORT with the
4730 * T bit set should not be) and there should be an expert info if so.
4731 * Should we use the association from the first chunk or the last
4732 * chunk in such a case?
4733 */
4737 }
4738 }
4740 if ((tvb_get_uint8(chunk_tvb, CHUNK_FLAGS_OFFSET) & SCTP_SHUTDOWN_COMPLETE_CHUNK_T_BIT) != 0) {
4742 }
4743 }
4747 }
4751 }
4755 }
4758 }
4762 /* XXX: Should we set these if encapsulated is true or not? */
4767 pi = proto_tree_add_uint_format_value(sctp_tree, hf_sctp_assoc_index, tvb, 0 , 0, sctp_info.assoc_index, "disabled (enable in preferences)");
4768 }
4772 }
4774 /* call dissect_sctp_chunk for the actual work */
4784 }
4786 /* get rid of the dissected chunk */
4788 }
4789 }
4792 }
4793 }
4795 static void
4796 // NOLINTNEXTLINE(misc-no-recursion)
4798 {
4814 /* Only try to checksum the packet if we have all of it */
4843 }
4844 }
4852 /* In the interest of speed, if "tree" is NULL, don't do any work not
4853 necessary to generate protocol tree items. */
4856 /* create the sctp protocol tree */
4862 else
4867 /* add the components of the common header to the protocol tree */
4868 proto_tree_add_item(sctp_tree, hf_source_port, tvb, SOURCE_PORT_OFFSET, SOURCE_PORT_LENGTH, ENC_BIG_ENDIAN);
4869 proto_tree_add_item(sctp_tree, hf_destination_port, tvb, DESTINATION_PORT_OFFSET, DESTINATION_PORT_LENGTH, ENC_BIG_ENDIAN);
4870 vt = proto_tree_add_item(sctp_tree, hf_verification_tag, tvb, VERIFICATION_TAG_OFFSET, VERIFICATION_TAG_LENGTH, ENC_BIG_ENDIAN);
4871 hidden_item = proto_tree_add_item(sctp_tree, hf_port, tvb, SOURCE_PORT_OFFSET, SOURCE_PORT_LENGTH, ENC_BIG_ENDIAN);
4873 hidden_item = proto_tree_add_item(sctp_tree, hf_port, tvb, DESTINATION_PORT_OFFSET, DESTINATION_PORT_LENGTH, ENC_BIG_ENDIAN);
4878 }
4881 /* We have the whole packet */
4885 proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, 0,
4889 proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum_adler, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, calculated_adler32,
4893 proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum_crc32c, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, calculated_crc32c,
4898 proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum_adler, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, calculated_adler32,
4901 proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum_crc32c, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, calculated_crc32c,
4904 proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum_adler, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, calculated_adler32,
4906 proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum_crc32c, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, calculated_crc32c,
4908 }
4910 }
4912 /* We don't have the whole packet so we can't verify the checksum */
4913 proto_tree_add_checksum(sctp_tree, tvb, CHECKSUM_OFFSET, hf_checksum, hf_checksum_status, &ei_sctp_bad_sctp_checksum, pinfo, 0,
4915 }
4917 /* add all chunks of the sctp datagram to the protocol tree */
4920 }
4922 static bool
4923 capture_sctp(const unsigned char *pd _U_, int offset _U_, int len _U_, capture_packet_info_t *cpinfo, const union wtap_pseudo_header *pseudo_header _U_)
4924 {
4927 }
4929 static int
4931 {
4935 /* Extract the common header */
4939 /* update pi structure */
4944 /* make entry in the Protocol column on summary display */
4947 /* Clear entries in Info column on summary display */
4953 }
4955 /* The tvb array in struct _sctp_info is huge: currently 2k pointers.
4956 * We know (by the value of 'number_of_tvbs') which of these entries have
4957 * been used, so don't memset() the array. This saves us from zeroing out
4958 * 8k (4-byte pointers) or 16k (8-byte pointers) of memory every time we
4959 * dissect a packet (saving quite a bit of time!).
4960 */
4969 /* Initialize these to unknown */
4978 p_add_proto_data(pinfo->pool, pinfo, hf_source_port, pinfo->curr_layer_num, GUINT_TO_POINTER(pinfo->srcport));
4979 p_add_proto_data(pinfo->pool, pinfo, hf_destination_port, pinfo->curr_layer_num, GUINT_TO_POINTER(pinfo->destport));
4981 TRY {
4983 }
4985 FINALLY {
4987 /* XXX: If a (only present in an expired Internet-Draft)
4988 * PKTDROP chunk is present, that shouldn't stop us from
4989 * tapping the information from the outer encapsulation,
4990 * but we'd have to be careful about not updating sctp_info
4991 * with information from the encapsulated packet.
4992 */
4994 }
4996 ENDTRY;
4999 }
5001 /* Register the protocol with Wireshark */
5002 void
5004 {
5006 /* Setup list of header fields */
5008 { &hf_source_port, { "Source port", "sctp.srcport", FT_UINT16, BASE_PT_SCTP, NULL, 0x0, NULL, HFILL } },
5009 { &hf_destination_port, { "Destination port", "sctp.dstport", FT_UINT16, BASE_PT_SCTP, NULL, 0x0, NULL, HFILL } },
5011 { &hf_verification_tag, { "Verification tag", "sctp.verification_tag", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
5012 { &hf_checksum, { "Checksum", "sctp.checksum", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
5013 { &hf_checksum_adler, { "Checksum (Adler)", "sctp.checksum", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
5014 { &hf_checksum_crc32c, { "Checksum (CRC32C)", "sctp.checksum", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
5015 { &hf_checksum_status, { "Checksum Status", "sctp.checksum.status", FT_UINT8, BASE_NONE, VALS(proto_checksum_vals), 0x0, NULL, HFILL } },
5017 { &hf_chunk_type, { "Chunk type", "sctp.chunk_type", FT_UINT8, BASE_DEC, VALS(chunk_type_values), 0x0, NULL, HFILL } },
5018 { &hf_chunk_flags, { "Chunk flags", "sctp.chunk_flags", FT_UINT8, BASE_HEX, NULL, 0x0, NULL, HFILL } },
5019 { &hf_chunk_bit_1, { "Bit", "sctp.chunk_bit_1", FT_BOOLEAN, 8, TFS(&sctp_chunk_bit_1_value), SCTP_CHUNK_BIT_1, NULL, HFILL } },
5020 { &hf_chunk_bit_2, { "Bit", "sctp.chunk_bit_2", FT_BOOLEAN, 8, TFS(&sctp_chunk_bit_2_value), SCTP_CHUNK_BIT_2, NULL, HFILL } },
5021 { &hf_chunk_length, { "Chunk length", "sctp.chunk_length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5022 { &hf_chunk_padding, { "Chunk padding", "sctp.chunk_padding", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5023 { &hf_chunk_value, { "Chunk value", "sctp.chunk_value", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5025 { &hf_initiate_tag, { "Initiate tag", "sctp.initiate_tag", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
5026 { &hf_init_chunk_initiate_tag, { "Initiate tag", "sctp.init_initiate_tag", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
5027 { &hf_init_chunk_adv_rec_window_credit, { "Advertised receiver window credit (a_rwnd)", "sctp.init_credit", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5028 { &hf_init_chunk_number_of_outbound_streams, { "Number of outbound streams", "sctp.init_nr_out_streams", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5029 { &hf_init_chunk_number_of_inbound_streams, { "Number of inbound streams", "sctp.init_nr_in_streams", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5030 { &hf_init_chunk_initial_tsn, { "Initial TSN", "sctp.init_initial_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5031 { &hf_initack_chunk_initiate_tag, { "Initiate tag", "sctp.initack_initiate_tag", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
5032 { &hf_initack_chunk_adv_rec_window_credit, { "Advertised receiver window credit (a_rwnd)", "sctp.initack_credit", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5033 { &hf_initack_chunk_number_of_outbound_streams, { "Number of outbound streams", "sctp.initack_nr_out_streams", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5034 { &hf_initack_chunk_number_of_inbound_streams, { "Number of inbound streams", "sctp.initack_nr_in_streams", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5035 { &hf_initack_chunk_initial_tsn, { "Initial TSN", "sctp.initack_initial_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5036 { &hf_data_chunk_tsn, { "Transmission sequence number (relative)", "sctp.data_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5037 { &hf_data_chunk_tsn_raw, { "Transmission sequence number (absolute)", "sctp.data_tsn_raw", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5038 { &hf_data_chunk_stream_id, { "Stream identifier", "sctp.data_sid", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } },
5039 { &hf_data_chunk_stream_seq_number, { "Stream sequence number", "sctp.data_ssn", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5040 { &hf_data_chunk_payload_proto_id, { "Payload protocol identifier", "sctp.data_payload_proto_id", FT_UINT32, BASE_DEC|BASE_EXT_STRING, &sctpppid_val_ext, 0x0, NULL, HFILL } },
5041 { &hf_idata_chunk_reserved, { "Reserved", "sctp.data_reserved", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5042 { &hf_idata_chunk_mid, { "Message identifier", "sctp.data_mid", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5043 { &hf_idata_chunk_fsn, { "Fragment sequence number", "sctp.data_fsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5044 { &hf_data_chunk_e_bit, { "E-Bit", "sctp.data_e_bit", FT_BOOLEAN, 8, TFS(&sctp_data_chunk_e_bit_value), SCTP_DATA_CHUNK_E_BIT, NULL, HFILL } },
5045 { &hf_data_chunk_b_bit, { "B-Bit", "sctp.data_b_bit", FT_BOOLEAN, 8, TFS(&sctp_data_chunk_b_bit_value), SCTP_DATA_CHUNK_B_BIT, NULL, HFILL } },
5046 { &hf_data_chunk_u_bit, { "U-Bit", "sctp.data_u_bit", FT_BOOLEAN, 8, TFS(&sctp_data_chunk_u_bit_value), SCTP_DATA_CHUNK_U_BIT, NULL, HFILL } },
5047 { &hf_data_chunk_i_bit, { "I-Bit", "sctp.data_i_bit", FT_BOOLEAN, 8, TFS(&sctp_data_chunk_i_bit_value), SCTP_DATA_CHUNK_I_BIT, NULL, HFILL } },
5048 { &hf_sack_chunk_ns, { "Nonce sum", "sctp.sack_nonce_sum", FT_UINT8, BASE_DEC, NULL, SCTP_SACK_CHUNK_NS_BIT, NULL, HFILL } },
5049 { &hf_sack_chunk_cumulative_tsn_ack, { "Cumulative TSN ACK (relative)", "sctp.sack_cumulative_tsn_ack", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5050 { &hf_sack_chunk_cumulative_tsn_ack_raw, { "Cumulative TSN ACK (absolute)", "sctp.sack_cumulative_tsn_ack_raw", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5051 { &hf_sack_chunk_adv_rec_window_credit, { "Advertised receiver window credit (a_rwnd)", "sctp.sack_a_rwnd", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5052 { &hf_sack_chunk_number_of_gap_blocks, { "Number of gap acknowledgement blocks", "sctp.sack_number_of_gap_blocks", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5053 { &hf_sack_chunk_number_of_dup_tsns, { "Number of duplicated TSNs", "sctp.sack_number_of_duplicated_tsns", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5054 { &hf_sack_chunk_gap_block_start, { "Start", "sctp.sack_gap_block_start", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5055 { &hf_sack_chunk_gap_block_start_tsn, { "Start TSN", "sctp.sack_gap_block_start_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5056 { &hf_sack_chunk_gap_block_end, { "End", "sctp.sack_gap_block_end", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5057 { &hf_sack_chunk_gap_block_end_tsn, { "End TSN", "sctp.sack_gap_block_end_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5058 { &hf_sack_chunk_number_tsns_gap_acked, { "Number of TSNs in gap acknowledgement blocks", "sctp.sack_number_of_tsns_gap_acked", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5059 { &hf_sack_chunk_duplicate_tsn, { "Duplicate TSN", "sctp.sack_duplicate_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5060 { &hf_nr_sack_chunk_ns, { "Nonce sum", "sctp.nr_sack_nonce_sum", FT_UINT8, BASE_DEC, NULL, SCTP_NR_SACK_CHUNK_NS_BIT, NULL, HFILL } },
5061 { &hf_nr_sack_chunk_cumulative_tsn_ack, { "Cumulative TSN ACK", "sctp.nr_sack_cumulative_tsn_ack", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5062 { &hf_nr_sack_chunk_adv_rec_window_credit, { "Advertised receiver window credit (a_rwnd)", "sctp.nr_sack_a_rwnd", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5063 { &hf_nr_sack_chunk_number_of_gap_blocks, { "Number of gap acknowledgement blocks", "sctp.nr_sack_number_of_gap_blocks", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5064 { &hf_nr_sack_chunk_number_of_nr_gap_blocks, { "Number of nr-gap acknowledgement blocks", "sctp.nr_sack_number_of_nr_gap_blocks", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5065 { &hf_nr_sack_chunk_number_of_dup_tsns, { "Number of duplicated TSNs", "sctp.nr_sack_number_of_duplicated_tsns", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5066 { &hf_nr_sack_chunk_reserved, { "Reserved", "sctp.nr_sack_reserved", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } },
5067 { &hf_nr_sack_chunk_gap_block_start, { "Start", "sctp.nr_sack_gap_block_start", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5068 { &hf_nr_sack_chunk_gap_block_start_tsn, { "Start TSN", "sctp.nr_sack_gap_block_start_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5069 { &hf_nr_sack_chunk_gap_block_end, { "End", "sctp.nr_sack_gap_block_end", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5070 { &hf_nr_sack_chunk_gap_block_end_tsn, { "End TSN", "sctp.nr_sack_gap_block_end_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5071 { &hf_nr_sack_chunk_number_tsns_gap_acked, { "Number of TSNs in gap acknowledgement blocks", "sctp.nr_sack_number_of_tsns_gap_acked", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5072 { &hf_nr_sack_chunk_nr_gap_block_start, { "Start", "sctp.nr_sack_nr_gap_block_start", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5073 { &hf_nr_sack_chunk_nr_gap_block_start_tsn, { "Start TSN", "sctp.nr_sack_nr_gap_block_start_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5074 { &hf_nr_sack_chunk_nr_gap_block_end, { "End", "sctp.nr_sack_nr_gap_block_end", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5075 { &hf_nr_sack_chunk_nr_gap_block_end_tsn, { "End TSN", "sctp.nr_sack_nr_gap_block_end_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5076 { &hf_nr_sack_chunk_number_tsns_nr_gap_acked, { "Number of TSNs in nr-gap acknowledgement blocks","sctp.nr_sack_number_of_tsns_nr_gap_acked", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5077 { &hf_nr_sack_chunk_duplicate_tsn, { "Duplicate TSN", "sctp.nr_sack_duplicate_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5078 { &hf_shutdown_chunk_cumulative_tsn_ack, { "Cumulative TSN Ack", "sctp.shutdown_cumulative_tsn_ack", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5079 { &hf_ecne_chunk_lowest_tsn, { "Lowest TSN", "sctp.ecne_lowest_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5080 { &hf_cwr_chunk_lowest_tsn, { "Lowest TSN", "sctp.cwr_lowest_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5081 { &hf_shutdown_complete_chunk_t_bit, { "T-Bit", "sctp.shutdown_complete_t_bit", FT_BOOLEAN, 8, TFS(&sctp_shutdown_complete_chunk_t_bit_value), SCTP_SHUTDOWN_COMPLETE_CHUNK_T_BIT, NULL, HFILL } },
5082 { &hf_abort_chunk_t_bit, { "T-Bit", "sctp.abort_t_bit", FT_BOOLEAN, 8, TFS(&sctp_shutdown_complete_chunk_t_bit_value), SCTP_ABORT_CHUNK_T_BIT, NULL, HFILL } },
5083 { &hf_forward_tsn_chunk_tsn, { "New cumulative TSN", "sctp.forward_tsn_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5084 { &hf_forward_tsn_chunk_sid, { "Stream identifier", "sctp.forward_tsn_sid", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5085 { &hf_forward_tsn_chunk_ssn, { "Stream sequence number", "sctp.forward_tsn_ssn", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5086 { &hf_i_forward_tsn_chunk_tsn, { "New cumulative TSN", "sctp.i_forward_tsn_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5087 { &hf_i_forward_tsn_chunk_sid, { "Stream identifier", "sctp.i_forward_tsn_sid", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5088 { &hf_i_forward_tsn_chunk_flags, { "Flags", "sctp.i_forward_tsn_flags", FT_UINT16, BASE_HEX, NULL, 0x0, NULL, HFILL } },
5089 { &hf_i_forward_tsn_chunk_res, { "Reserved", "sctp.i_forward_tsn_res", FT_UINT16, BASE_DEC, NULL, SCTP_I_FORWARD_TSN_CHUNK_RES_MASK, NULL, HFILL } },
5090 { &hf_i_forward_tsn_chunk_u_bit, { "U-Bit", "sctp.i_forward_tsn_u_bit", FT_BOOLEAN, 16, TFS(&sctp_i_forward_tsn_chunk_u_bit_value), SCTP_I_FORWARD_TSN_CHUNK_U_BIT, NULL, HFILL } },
5091 { &hf_i_forward_tsn_chunk_mid, { "Message identifier", "sctp.forward_tsn_mid", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5092 { &hf_parameter_type, { "Parameter type", "sctp.parameter_type", FT_UINT16, BASE_HEX, VALS(parameter_identifier_values), 0x0, NULL, HFILL } },
5093 { &hf_parameter_length, { "Parameter length", "sctp.parameter_length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5094 { &hf_parameter_value, { "Parameter value", "sctp.parameter_value", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5095 { &hf_parameter_padding, { "Parameter padding", "sctp.parameter_padding", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5096 { &hf_parameter_bit_1, { "Bit", "sctp.parameter_bit_1", FT_BOOLEAN, 16, TFS(&sctp_parameter_bit_1_value), SCTP_PARAMETER_BIT_1, NULL, HFILL } },
5097 { &hf_parameter_bit_2, { "Bit", "sctp.parameter_bit_2", FT_BOOLEAN, 16, TFS(&sctp_parameter_bit_2_value), SCTP_PARAMETER_BIT_2, NULL, HFILL } },
5098 { &hf_ipv4_address, { "IP Version 4 address", "sctp.parameter_ipv4_address", FT_IPv4, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5099 { &hf_ipv6_address, { "IP Version 6 address", "sctp.parameter_ipv6_address", FT_IPv6, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5100 { &hf_heartbeat_info, { "Heartbeat information", "sctp.parameter_heartbeat_information", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5101 { &hf_state_cookie, { "State cookie", "sctp.parameter_state_cookie", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5102 { &hf_cookie_preservative_increment, { "Suggested Cookie life-span increment (msec)", "sctp.parameter_cookie_preservative_incr", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5103 { &hf_hostname, { "Hostname", "sctp.parameter_hostname", FT_STRINGZ, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5104 { &hf_supported_address_type, { "Supported address type", "sctp.parameter_supported_address_type", FT_UINT16, BASE_DEC, VALS(address_types_values), 0x0, NULL, HFILL } },
5105 { &hf_stream_reset_req_seq_nr, { "Re-configuration request sequence number", "sctp.parameter_reconfig_request_sequence_number", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5106 { &hf_stream_reset_rsp_seq_nr, { "Re-configuration response sequence number", "sctp.parameter_reconfig_response_sequence_number", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5107 { &hf_senders_last_assigned_tsn, { "Senders last assigned TSN", "sctp.parameter_senders_last_assigned_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5108 { &hf_senders_next_tsn, { "Senders next TSN", "sctp.parameter_senders_next_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5109 { &hf_receivers_next_tsn, { "Receivers next TSN", "sctp.parameter_receivers_next_tsn", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5110 { &hf_stream_reset_rsp_result, { "Result", "sctp.parameter_reconfig_response_result", FT_UINT32, BASE_DEC, VALS(stream_reset_result_values), 0x0, NULL, HFILL } },
5111 { &hf_stream_reset_sid, { "Stream Identifier", "sctp.parameter_reconfig_sid", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5112 { &hf_add_outgoing_streams_number_streams, { "Number of streams", "sctp.parameter_add_outgoing_streams_number", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5113 { &hf_add_outgoing_streams_reserved, { "Reserved", "sctp.parameter_add_outgoing_streams_reserved", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5114 { &hf_add_incoming_streams_number_streams, { "Number of streams", "sctp.parameter_add_incoming_streams_number", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5115 { &hf_add_incoming_streams_reserved, { "Reserved", "sctp.parameter_add_incoming_streams_reserved", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5116 { &hf_asconf_seq_nr, { "Sequence number", "sctp.asconf_seq_nr_number", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
5117 { &hf_asconf_ack_seq_nr, { "Sequence number", "sctp.asconf_ack_seq_nr_number", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
5118 { &hf_correlation_id, { "Correlation_id", "sctp.correlation_id", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
5119 { &hf_adap_indication, { "Indication", "sctp.adaptation_layer_indication", FT_UINT32, BASE_HEX, NULL, 0x0, NULL, HFILL } },
5120 { &hf_zero_checksum_edmid, { "Error Detection Method Identifier", "sctp.edmid", FT_UINT32, BASE_DEC, VALS(edmid_values), 0x0, NULL, HFILL } },
5121 { &hf_random_number, { "Random number", "sctp.random_number", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5122 { &hf_chunks_to_auth, { "Chunk type", "sctp.chunk_type_to_auth", FT_UINT8, BASE_DEC, VALS(chunk_type_values), 0x0, NULL, HFILL } },
5123 { &hf_hmac_id, { "HMAC identifier", "sctp.hmac_id", FT_UINT16, BASE_DEC, VALS(hmac_id_values), 0x0, NULL, HFILL } },
5125 { &hf_shared_key_id, { "Shared key identifier", "sctp.shared_key_id", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5126 { &hf_supported_chunk_type, { "Supported chunk type", "sctp.supported_chunk_type", FT_UINT8, BASE_DEC, VALS(chunk_type_values), 0x0, NULL, HFILL } },
5127 { &hf_cause_code, { "Cause code", "sctp.cause_code", FT_UINT16, BASE_HEX, VALS(cause_code_values), 0x0, NULL, HFILL } },
5128 { &hf_cause_length, { "Cause length", "sctp.cause_length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5129 { &hf_cause_info, { "Cause information", "sctp.cause_information", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5130 { &hf_cause_padding, { "Cause padding", "sctp.cause_padding", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5131 { &hf_cause_stream_identifier, { "Stream identifier", "sctp.cause_stream_identifier", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5132 { &hf_cause_reserved, { "Reserved", "sctp.cause_reserved", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5133 { &hf_cause_number_of_missing_parameters, { "Number of missing parameters", "sctp.cause_nr_of_missing_parameters", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5134 { &hf_cause_missing_parameter_type, { "Missing parameter type", "sctp.cause_missing_parameter_type", FT_UINT16, BASE_HEX, VALS(parameter_identifier_values), 0x0, NULL, HFILL } },
5135 { &hf_cause_measure_of_staleness, { "Measure of staleness in usec", "sctp.cause_measure_of_staleness", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5137 { &hf_pktdrop_chunk_m_bit, { "M-Bit", "sctp.pckdrop_m_bit", FT_BOOLEAN, 8, TFS(&sctp_pktdropk_m_bit_value), SCTP_PKTDROP_CHUNK_M_BIT, NULL, HFILL } },
5138 { &hf_pktdrop_chunk_b_bit, { "B-Bit", "sctp.pckdrop_b_bit", FT_BOOLEAN, 8, TFS(&sctp_pktdropk_b_bit_value), SCTP_PKTDROP_CHUNK_B_BIT, NULL, HFILL } },
5139 { &hf_pktdrop_chunk_t_bit, { "T-Bit", "sctp.pckdrop_t_bit", FT_BOOLEAN, 8, TFS(&sctp_pktdropk_t_bit_value), SCTP_PKTDROP_CHUNK_T_BIT, NULL, HFILL } },
5140 { &hf_pktdrop_chunk_bandwidth, { "Bandwidth", "sctp.pktdrop_bandwidth", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5141 { &hf_pktdrop_chunk_queuesize, { "Queuesize", "sctp.pktdrop_queuesize", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5142 { &hf_pktdrop_chunk_truncated_length, { "Truncated length", "sctp.pktdrop_truncated_length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5143 { &hf_pktdrop_chunk_reserved, { "Reserved", "sctp.pktdrop_reserved", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5144 { &hf_pktdrop_chunk_data_field, { "Data field", "sctp.pktdrop_datafield", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5145 { &hf_pad_chunk_padding_data, { "Padding data", "sctp.padding_data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5147 { &hf_sctp_fragment, { "SCTP Fragment", "sctp.fragment", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5148 { &hf_sctp_fragments, { "Reassembled SCTP Fragments", "sctp.fragments", FT_NONE, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5149 { &hf_sctp_reassembled_in, { "Reassembled Message in frame", "sctp.reassembled_in", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5150 { &hf_sctp_duplicate, { "Fragment already seen in frame", "sctp.duplicate", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5152 { &hf_sctp_data_rtt, { "The RTT to SACK was", "sctp.data_rtt", FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5153 { &hf_sctp_sack_rtt, { "The RTT since DATA was", "sctp.sack_rtt", FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5154 { &hf_sctp_rto, { "Retransmitted after", "sctp.retransmission_time", FT_RELATIVE_TIME, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5155 { &hf_sctp_retransmission, { "This TSN is a retransmission of one in frame", "sctp.retransmission", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5156 { &hf_sctp_retransmitted, { "This TSN is retransmitted in frame", "sctp.retransmitted", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5157 { &hf_sctp_retransmitted_count, { "TSN was retransmitted this many times", "sctp.retransmitted_count", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5158 { &hf_sctp_acked, { "This chunk is acked in frame", "sctp.acked", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5159 { &hf_sctp_ack_tsn, { "Acknowledges TSN", "sctp.ack", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
5160 { &hf_sctp_ack_frame, { "Acknowledges TSN in frame", "sctp.ack_frame", FT_FRAMENUM, BASE_NONE, FRAMENUM_TYPE(FT_FRAMENUM_ACK), 0x0, NULL, HFILL } },
5161 { &hf_sctp_retransmitted_after_ack, { "Chunk was acked prior to retransmission", "sctp.retransmitted_after_ack", FT_FRAMENUM, BASE_NONE, NULL, 0x0, NULL, HFILL } },
5162 { &hf_sctp_assoc_index, { "Association index", "sctp.assoc_index", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } }
5164 };
5166 /* Setup protocol subtree array */
5198 &ett_sctp_tsn_retransmitted
5199 };
5202 { &ei_sctp_tsn_retransmitted, { "sctp.retransmission.expert", PI_SEQUENCE, PI_NOTE, "Retransmitted TSN", EXPFILL }},
5203 { &ei_sctp_retransmitted_after_ack, { "sctp.retransmitted_after_ack.expert", PI_SEQUENCE, PI_WARN, "This TSN was acked prior to this retransmission (reneged ack?).", EXPFILL }},
5204 { &ei_sctp_tsn_retransmitted_more_than_twice, { "sctp.retransmission.more_than_twice", PI_SEQUENCE, PI_WARN, "This TSN was retransmitted more than 2 times.", EXPFILL }},
5205 { &ei_sctp_parameter_padding, { "sctp.parameter_padding.expert", PI_MALFORMED, PI_NOTE, "The padding of this final parameter should be the padding of the chunk.", EXPFILL }},
5206 { &ei_sctp_parameter_length, { "sctp.parameter_length.bad", PI_MALFORMED, PI_ERROR, "Parameter length bad", EXPFILL }},
5207 { &ei_sctp_sack_chunk_adv_rec_window_credit, { "sctp.sack_a_rwnd.expert", PI_SEQUENCE, PI_NOTE, "Zero Advertised Receiver Window Credit", EXPFILL }},
5208 { &ei_sctp_sack_chunk_gap_block_malformed, { "sctp.sack_gap_block_malformed", PI_PROTOCOL, PI_ERROR, "Malformed gap block.", EXPFILL }},
5209 { &ei_sctp_sack_chunk_gap_block_out_of_order, { "sctp.sack_gap_block_out_of_order", PI_PROTOCOL, PI_WARN, "Gap blocks not in strict order.", EXPFILL }},
5210 { &ei_sctp_sack_chunk_number_tsns_gap_acked_100, { "sctp.sack_number_of_tsns_gap_acked.100", PI_SEQUENCE, PI_WARN, "More than 100 TSNs were gap-acknowledged in this SACK.", EXPFILL }},
5211 { &ei_sctp_nr_sack_chunk_number_tsns_gap_acked_100, { "sctp.nr_sack_number_of_tsns_gap_acked.100", PI_SEQUENCE, PI_WARN, "More than 100 TSNs were gap-acknowledged in this NR-SACK.", EXPFILL }},
5212 { &ei_sctp_nr_sack_chunk_number_tsns_nr_gap_acked_100, { "sctp.nr_sack_number_of_tsns_nr_gap_acked.100", PI_SEQUENCE, PI_WARN, "More than 100 TSNs were nr-gap-acknowledged in this NR-SACK.", EXPFILL }},
5213 { &ei_sctp_chunk_length_bad, { "sctp.chunk_length.bad", PI_MALFORMED, PI_ERROR, "Chunk length bad", EXPFILL }},
5214 { &ei_sctp_bad_sctp_checksum, { "sctp.checksum_bad.expert", PI_CHECKSUM, PI_ERROR, "Bad SCTP checksum.", EXPFILL }},
5215 };
5223 };
5225 /* Decode As handling */
5229 static decode_as_value_t sctp_da_port_values[3] = {{sctp_src_prompt, 1, sctp_da_src_values}, {sctp_dst_prompt, 1, sctp_da_dst_values}, {sctp_both_prompt, 2, sctp_da_both_values}};
5230 static decode_as_t sctp_da_port = {"sctp", "sctp.port", 3, 2, sctp_da_port_values, "SCTP", "port(s) as",
5235 static decode_as_value_t sctp_da_ppi_values[2] = {{sctp_ppi_prompt1, 1, sctp_da_ppi_build_value1}, {sctp_ppi_prompt2, 1, sctp_da_ppi_build_value2}};
5239 /* UAT for header fields */
5243 UAT_FLD_VS(type_fields, type_enable, "Visibility", chunk_enabled, "Hide or show the type in the chunk statistics"),
5244 UAT_END_FIELDS
5245 };
5258 NULL,
5259 sctp_chunk_type_copy_cb,
5260 sctp_chunk_type_update_cb,
5261 sctp_chunk_type_free_cb,
5262 NULL,
5263 NULL,
5264 custom_types_uat_fields
5265 );
5267 /* Register the protocol name and description */
5286 "Try to decode a packet using an heuristic sub-dissector before using a sub-dissector registered to a specific port or PPI",
5307 chunk_types_uat);
5309 /* Required function calls to register the header fields and subtrees used */
5317 /* subdissector code */
5318 sctp_port_dissector_table = register_dissector_table("sctp.port", "SCTP port", proto_sctp, FT_UINT16, BASE_DEC);
5319 sctp_ppi_dissector_table = register_dissector_table("sctp.ppi", "SCTP payload protocol identifier", proto_sctp, FT_UINT32, BASE_HEX);
5322 sctp_heur_subdissector_list = register_heur_dissector_list_with_description("sctp", "SCTP payload", proto_sctp);
5333 register_conversation_table(proto_sctp, false, sctp_conversation_packet, sctp_endpoint_packet);
5339 }
5341 void
5343 {
5344 capture_dissector_handle_t sctp_cap_handle;
5352 }
5354 /*
5355 * Editor modelines - https://www.wireshark.org/tools/modelines.html
5356 *
5357 * Local variables:
5358 * c-basic-offset: 2
5359 * tab-width: 8
5360 * indent-tabs-mode: nil
5361 * End:
5362 *
5363 * vi: set shiftwidth=2 tabstop=8 expandtab:
5364 * :indentSize=2:tabSize=8:noTabs=true:
5365 */