| Wireshark 4.7.3 The Wireshark network protocol analyzer

Loading...
Searching...
No Matches
packet-tcp.h
1/* packet-tcp.h
2 *
3 * Wireshark - Network traffic analyzer
4 * By Gerald Combs <gerald@wireshark.org>
5 * Copyright 1998 Gerald Combs
6 *
7 * SPDX-License-Identifier: GPL-2.0-or-later
8 */
9
10#ifndef __PACKET_TCP_H__
11#define __PACKET_TCP_H__
12
13#include "ws_symbol_export.h"
14
15#include <epan/conversation.h>
16#include <epan/reassemble.h>
17#include <epan/wmem_scopes.h>
18
19#ifdef __cplusplus
20 extern "C" {
21#endif /* __cplusplus */
22
23/* TCP flags */
24#define TH_FIN 0x001
25#define TH_SYN 0x002
26#define TH_RST 0x004
27#define TH_PUSH 0x008
28#define TH_ACK 0x010
29#define TH_URG 0x020
30#define TH_ECE 0x040
31#define TH_CWR 0x080
32#define TH_AE 0x100
33#define TH_RES 0xE00 /* 3 reserved bits */
34#define TH_MASK 0x0FFF
35
36#define IS_TH_FIN(x) (x & TH_FIN)
37#define IS_TH_URG(x) (x & TH_URG)
38
39/* Idea for gt: either x > y, or y is much bigger (assume wrap) */
40#define GT_SEQ(x, y) ((int32_t)((y) - (x)) < 0)
41#define LT_SEQ(x, y) ((int32_t)((x) - (y)) < 0)
42#define GE_SEQ(x, y) ((int32_t)((y) - (x)) <= 0)
43#define LE_SEQ(x, y) ((int32_t)((x) - (y)) <= 0)
44#define EQ_SEQ(x, y) (x) == (y)
45
46/* Stop counting over 100 isolated parts, although it could technically reach 2^31 */
47#define MAX_CONTIGUOUS_SEQUENCES 100
48
49/* mh as in mptcp header */
50 struct mptcpheader {
51
52 bool mh_mpc; /* true if seen an mp_capable option */
53 bool mh_join; /* true if seen an mp_join option */
54 bool mh_dss; /* true if seen a dss */
55 bool mh_add; /* true if seen an MP_ADD */
56 bool mh_remove; /* true if seen an MP_REMOVE */
57 bool mh_prio; /* true if seen an MP_PRIO */
58 bool mh_fail; /* true if seen an MP_FAIL */
59 bool mh_fastclose; /* true if seen a fastclose */
60 bool mh_tcprst; /* true if seen a MP_TCPRST */
61
62 uint8_t mh_capable_flags; /* to get hmac version for instance */
63 uint8_t mh_dss_flags; /* data sequence signal flag */
64 uint32_t mh_dss_ssn; /* DSS Subflow Sequence Number */
65 uint64_t mh_dss_rawdsn; /* DSS Data Sequence Number */
66 uint64_t mh_dss_rawack; /* DSS raw data ack */
67 uint16_t mh_dss_length; /* mapping/DSS length */
68
69 uint64_t mh_key; /* Sender key in MP_CAPABLE */
70 uint32_t mh_token; /* seen in MP_JOIN. Should be a hash of the initial key */
71
72 uint32_t mh_stream; /* this stream index field is included to help differentiate when address/port pairs are reused */
73
74 /* Data Sequence Number of the current segment. It needs to be computed from previous mappings
75 * and as such is not necessarily set
76 */
77 uint64_t mh_rawdsn64;
78 /* DSN formatted according to the wireshark MPTCP options */
79 uint64_t mh_dsn;
80};
81
82/* the tcp header structure, passed to tap listeners */
83 typedef struct tcpheader {
84 uint32_t th_rawseq; /* raw value */
85 uint32_t th_seq; /* raw or relative value depending on tcp_relative_seq */
86
87 uint32_t th_rawack; /* raw value */
88 uint32_t th_ack; /* raw or relative value depending on tcp_relative_seq */
89 bool flagkarn; /* XXX - might later become a bit field */
90
91 /* This is the absolute maximum we could find in TCP options (RFC2018, section 3) */
92 #define MAX_TCP_SACK_RANGES 4
93 uint8_t num_sack_ranges;
94 bool th_have_seglen; /* true if th_seglen is valid */
95 uint32_t th_seglen; /* in bytes */
96 uint32_t th_win; /* make it 32 bits so we can handle some scaling */
97 uint16_t th_sport;
98 uint16_t th_dport;
99 uint8_t th_hlen;
100 bool th_use_ace;
101 uint16_t th_flags;
102 uint32_t th_stream; /* this stream index field is included to help differentiate when address/port pairs are reused */
103 address ip_src;
104 address ip_dst;
105 uint32_t sack_left_edge[MAX_TCP_SACK_RANGES];
106 uint32_t sack_right_edge[MAX_TCP_SACK_RANGES];
107
108 /* header for TCP option Multipath Operation */
109 struct mptcpheader *th_mptcp;
110
111 uint32_t th_dup_count; /* capture-level duplicate count (0 = not checked) */
112 uint32_t th_dup_orig_frame; /* frame number of first occurrence in dedup group */
113} tcp_info_t;
114
115/*
116 * Private data passed from the TCP dissector to subdissectors.
117 * NOTE: This structure is used by Export PDU functionality so
118 * make sure that handling is also updated if this structure
119 * changes!
120 */
121 struct tcpinfo {
122 uint32_t seq; /* Sequence number of first byte in the data */
123 uint32_t nxtseq; /* Sequence number of first byte after data */
124 uint32_t lastackseq; /* Sequence number of last ack */
125 uint16_t flags; /* TCP flags */
126 uint16_t urgent_pointer; /* Urgent pointer value for the current packet. */
127 uint32_t stream; /* Stream id passed to export PDU */
128 bool is_reassembled; /* This is reassembled data. */
129};
130
131/*
132 * Loop for dissecting PDUs within a TCP stream; assumes that a PDU
133 * consists of a fixed-length chunk of data that contains enough information
134 * to determine the length of the PDU, followed by rest of the PDU.
135 *
136 * The first three arguments are the arguments passed to the dissector
137 * that calls this routine.
138 *
139 * "proto_desegment" is the dissector's flag controlling whether it should
140 * desegment PDUs that cross TCP segment boundaries.
141 *
142 * "fixed_len" is the length of the fixed-length part of the PDU.
143 *
144 * "get_pdu_len()" is a routine called to get the length of the PDU from
145 * the fixed-length part of the PDU; it's passed "pinfo", "tvb", "offset" and
146 * "dissector_data".
147 *
148 * "dissect_pdu()" is the routine to dissect a PDU.
149 */
150WS_DLL_PUBLIC void
151tcp_dissect_pdus(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
152 bool proto_desegment, unsigned fixed_len,
153 unsigned (*get_pdu_len)(packet_info *, tvbuff_t *, int, void*),
154 dissector_t dissect_pdu, void* dissector_data);
155
156 extern const reassembly_table_functions
157tcp_reassembly_table_functions;
158
159 extern struct tcp_multisegment_pdu *
160pdu_store_sequencenumber_of_next_pdu(packet_info *pinfo, uint32_t seq, uint32_t nxtpdu, wmem_tree_t *multisegment_pdus);
161
162 typedef struct _tcp_unacked_t {
163 struct _tcp_unacked_t *next;
164 uint32_t frame;
165 uint32_t seq;
166 uint32_t nextseq;
167 bool karn_flag; /* indication for the later Karn discovery */
168 nstime_t ts;
169} tcp_unacked_t;
170
171 struct tcp_acked {
172 uint32_t frame_acked;
173 uint32_t rto_frame;
174 nstime_t ts;
175
176 nstime_t rto_ts; /* Time since previous packet for
177 retransmissions. */
178 uint16_t flags; /* see TCP_A_* in packet-tcp.c */
179 bool partial_ack; /* true when acknowledging data
180 and not a full segment */
181 bool iskarn; /* true when this ACK is ambiguous according to Karn */
182 uint32_t dupack_num; /* dup ack number */
183 uint32_t dupack_frame; /* dup ack to frame # */
184 uint32_t bytes_in_flight; /* number of bytes in flight */
185 uint32_t push_bytes_sent; /* bytes since the last PSH flag */
186
187 uint32_t new_data_seq; /* For segments with old data,
188 where new data starts */
189 uint32_t dup_count; /* capture-level packet occurrence count; 0 = not yet checked */
190 uint32_t dup_orig_frame; /* frame number of the first occurrence of this packet */
191 wmem_array_t *dup_frame_list; /* shared list of all frame numbers in this dedup group */
192};
193
194/* One instance of this structure is created for each pdu that spans across
195 * multiple tcp segments.
196 */
197 struct tcp_multisegment_pdu {
198 uint32_t seq;
199 uint32_t nxtpdu;
200 uint32_t first_frame; /* The frame where this MSP was created (used as key in reassembly tables). */
201 uint32_t last_frame;
202 nstime_t last_frame_time;
203 uint32_t first_frame_with_seq; /* The frame that contains the first frame that matches 'seq'
204 (same as 'first_frame', larger than 'first_frame' for OoO segments) */
205 uint32_t flags;
206#define MSP_FLAGS_REASSEMBLE_ENTIRE_SEGMENT 0x00000001
207/* Whether this MSP is finished and no more segments can be added. */
208#define MSP_FLAGS_GOT_ALL_SEGMENTS 0x00000002
209/* Whether the first segment of this MSP was not yet seen. */
210#define MSP_FLAGS_MISSING_FIRST_SEGMENT 0x00000004
211};
212
213
214/* Represents the MPTCP DSS option mapping part
215 It allows to map relative subflow sequence number (ssn) to global MPTCP sequence numbers
216 under their 64 bits form
217*/
218 typedef struct _mptcp_dss_mapping_t {
219
220/* In DSS, SSN are enumerated with relative seq_nb, i.e. starting from 0 */
221
222 uint32_t ssn_low;
223 uint32_t ssn_high;
224
225 uint64_t rawdsn; /* matches the low member of range
226 should be converted to the 64 bits version before being registered
227 */
228 /* to check if mapping was sent before or after packet */
229 uint32_t frame;
230 /* Ideally the dsn should always be registered with the extended version
231 * but it may not be possible if we don't know the 32 MSB of the base_dsn
232 */
233 bool extended_dsn; /* true if MPTCP_DSS_FLAG_DATA_8BYTES */
234} mptcp_dss_mapping_t;
235
236
237/* Structure used in mptcp meta member 'dsn_map'
238 */
239 typedef struct _mptcp_dsn2packet_mapping_t {
240 uint32_t frame; /* packet to look into PINFO_FD_NUM */
241 struct tcp_analysis* subflow; /* in order to get statistics */
242} mptcp_dsn2packet_mapping_t;
243
244
245/* Should basically look like a_tcp_flow_t but for mptcp with 64bit sequence number.
246 The meta is specific to a direction of the communication and aggregates information of
247 all the subflows
248*/
249 typedef struct _mptcp_meta_flow_t {
250
251 uint8_t static_flags; /* remember which fields are set */
252
253 /* flags exchanged between hosts during 3WHS. Gives checksum/extensibility/hmac information */
254 uint8_t flags;
255 uint8_t version; /* negotiated mptcp version */
256 uint64_t base_dsn; /* first data seq number (used by relative sequence numbers) seen. */
257 uint64_t nextseq; /* highest seen nextseq */
258 uint64_t dfin; /* data fin */
259
260 uint64_t key; /* if it was set */
261
262 /* expected token sha1 digest of keys, truncated to 32 most significant bits
263 derived from key. Stored to speed up subflow/MPTCP connection mapping */
264 uint32_t token;
265
266 uint32_t nextseqframe; /* frame number for segment with highest sequence number */
267
268 /* highest seen continuous seq number (without hole in the stream) */
269 uint64_t maxseqtobeacked;
270
271 uint64_t fin; /* frame number of the final dataFIN */
272
273 /* first addresses registered */
274 address ip_src;
275 address ip_dst;
276 uint32_t sport;
277 uint32_t dport;
278} mptcp_meta_flow_t;
279
280/* MPTCP data specific to this subflow direction */
281 struct mptcp_subflow {
282 /* map DSN to packets
283 * Used when looking for reinjections across subflows
284 */
285 wmem_itree_t *dsn2packet_map;
286
287 /* Map SSN to a DSS mappings
288 * a DSS can map DSN to SSNs possibly over several packets,
289 * hence some packets may have been mapped by previous DSS,
290 * whence the necessity to be able to look for SSN -> DSN */
291 wmem_itree_t *ssn2dsn_mappings;
292 /* meta flow to which it is attached. Helps setting forward and backward meta flow */
293 mptcp_meta_flow_t *meta;
294 uint32_t nonce; /* used only for MP_JOIN */
295 uint8_t static_flags; /* flags stating which of the flow */
296 uint8_t address_id; /* sent during an MP_JOIN */
297};
298
299
300 typedef enum {
301 MPTCP_HMAC_NOT_SET = 0,
302 /* this is either SHA1 for MPTCP v0 or sha256 for MPTCP v1 */
303 MPTCP_HMAC_SHA = 1,
304 MPTCP_HMAC_LAST
305} mptcp_hmac_algorithm_t;
306
307
308#define MPTCP_CAPABLE_CRYPTO_MASK 0x3F
309
310#define MPTCP_CHECKSUM_MASK 0x80
311
312/* Information in a flow that is only used when tcp_analyze_seq preference
313 * is enabled, so save the memory when it isn't
314 */
315 typedef struct tcp_analyze_seq_flow_info_t {
316 tcp_unacked_t *segments;/* List of segments for which we haven't seen an ACK */
317 uint16_t segment_count; /* How many unacked segments we're currently storing */
318 uint8_t lastacklen; /* length of the last fwd ACK packet - 0 means pure ACK */
319
320 bool valid_bif; /* if lost pkts, disable BiF until ACK is recvd */
321 bool push_set_last; /* tracking last time PSH flag was set */
322
323 /*
324 * Handling of contiguous SEQ ranges
325 */
326 bool is_client; /* tracking who initiated the conversation */
327 uint8_t num_contiguous_ranges;
328
329 /*
330 * Handling of SACK blocks
331 * Copied from tcpheader
332 */
333 uint8_t num_sack_ranges;
334 nstime_t lastacktime; /* Time of the last ack packet */
335 uint32_t lastack; /* Last seen ack for the reverse flow */
336 uint32_t lastnondupack; /* frame number of last seen non dupack */
337 uint32_t dupacknum; /* dupack number */
338 uint32_t nextseq; /* highest seen nextseq */
339 uint32_t maxseqtobeacked;/* highest seen continuous seq number (without hole in the stream) from the fwd party,
340 * this is the maximum seq number that can be acked by the rev party in normal case.
341 * If the rev party sends an ACK beyond this seq number it indicates TCP_A_ACK_LOST_PACKET condition */
342 uint32_t nextseqframe; /* frame number for segment with highest
343 * sequence number
344 */
345 uint32_t push_bytes_sent; /* bytes since the last PSH flag */
346 nstime_t nextseqtime; /* Time of the nextseq packet so we can
347 * distinguish between retransmission,
348 * fast retransmissions and outoforder
349 */
350
351 uint32_t sack_left_edge[MAX_TCP_SACK_RANGES];
352 uint32_t sack_right_edge[MAX_TCP_SACK_RANGES];
353 uint32_t contiguous_ranges[MAX_CONTIGUOUS_SEQUENCES][2];
354
355} tcp_analyze_seq_flow_info_t;
356
357 /* Process info, currently discovered via IPFIX */
358 typedef struct tcp_process_info_t {
359 uint32_t process_uid; /* UID of local process */
360 uint32_t process_pid; /* PID of local process */
361 char *username; /* Username of the local process */
362 char *command; /* Local process name + path + args */
363
364} tcp_process_info_t;
365
366 typedef struct _tcp_flow_t {
367 uint32_t base_seq; /* base seq number (used by relative sequence numbers)*/
368#define TCP_MAX_UNACKED_SEGMENTS 10000 /* The most unacked segments we'll store */
369 uint32_t fin; /* frame number of the final FIN */
370 uint32_t window; /* last seen window */
371 int16_t win_scale; /* -1 is we don't know, -2 is window scaling is not used */
372 int16_t mss; /* maximum segment size, -1 unknown */
373 bool scps_capable; /* flow advertised scps capabilities */
374 uint8_t static_flags; /* true if base seq set */
375 uint16_t maxsizeacked; /* 0 if not yet known */
376/* This tcp flow/session contains only one single PDU and should
377 * be reassembled until the final FIN segment.
378 */
379#define TCP_FLOW_REASSEMBLE_UNTIL_FIN 0x0001
380 uint16_t flags;
381
382 /* The number of data flows seen in that direction */
383 uint16_t flow_count;
384 uint8_t mp_operations; /* tracking of the MPTCP operations */
385 bool is_first_ack; /* indicates if this is the first ACK */
386 bool closing_initiator; /* tracking who is responsible of the connection end */
387 bool closing_initiator_rst; /* tracking who sent TCP RST first */
388 tcp_analyze_seq_flow_info_t* tcp_analyze_seq_info;
389
390 /* see TCP_A_* in packet-tcp.c */
391 uint32_t lastsegmentflags;
392
393 /* The next (largest) sequence number after all segments seen so far.
394 * Valid only on the first pass and used to handle out-of-order segments
395 * during reassembly. */
396 uint32_t maxnextseq;
397
398 /* This tree is indexed by sequence number and keeps track of all
399 * all pdus spanning multiple segments for this flow.
400 */
401 wmem_tree_t *multisegment_pdus;
402
403 /* A sorted list of pending out-of-order segments. */
404 wmem_list_t *ooo_segments;
405 /* A hash map of the same, used on subsequent passes. */
406 wmem_map_t *ooo_segments_map;
407 /* NOTE - the same entries are place in the list and map, so this
408 * is not especially wasteful of memory, but memory could be saved
409 * (at the cost of some performance) with an implementation of a
410 * tree with a custom comparison function. */
411
412 /* Process info, currently discovered via IPFIX */
413 tcp_process_info_t* process_info;
414
415 /* MPTCP subflow intel */
416 struct mptcp_subflow *mptcp_subflow;
417} tcp_flow_t;
418
419/* Stores common information between both hosts of the MPTCP connection*/
420 struct mptcp_analysis {
421
422 uint16_t mp_flags; /* MPTCP meta analysis related, see MPTCP_META_* in packet-tcp.c */
423 uint8_t hmac_algo; /* hmac decided after negotiation */
424 /* Keep track of the last TCP operations seen in order to avoid false DUP ACKs */
425 uint8_t mp_operations;
426 uint32_t stream; /* Keep track of unique mptcp stream (per MP_CAPABLE handshake) */
427 wmem_list_t* subflows; /* List of subflows (tcp_analysis) */
428
429 /* identifier of the tcp stream that saw the initial 3WHS with MP_CAPABLE option */
430 struct tcp_analysis *master;
431
432 /*
433 * For other subflows, they link the meta via mptcp_subflow_t::meta_flow
434 * according to the validity of the token.
435 */
436 mptcp_meta_flow_t meta_flow[2];
437};
438
439 struct tcp_analysis {
440 /* These two structs are managed based on comparing the source
441 * and destination addresses and, if they're equal, comparing
442 * the source and destination ports.
443 *
444 * If the source is greater than the destination, then stuff
445 * sent from src is in flow1.
446 *
447 * If the source is less than the destination, then stuff
448 * sent from src is in flow2.
449 *
450 * XXX - if the addresses and ports are equal, we don't guarantee
451 * the behavior.
452 */
453 tcp_flow_t flow1;
454 tcp_flow_t flow2;
455
456 /* These pointers are set by get_tcp_conversation_data()
457 * fwd point in the same direction as the current packet
458 * and rev in the reverse direction
459 */
460 tcp_flow_t *fwd;
461 tcp_flow_t *rev;
462
463 /* This pointer is NULL or points to a tcp_acked struct if this
464 * packet has "interesting" properties such as being a KeepAlive or
465 * similar
466 */
467 struct tcp_acked *ta;
468
469 /* This structure contains a tree containing all the various ta's
470 * keyed by frame number.
471 */
472 wmem_tree_t *acked_table;
473
474 /* Remember the timestamp of the first frame seen in this tcp
475 * conversation to be able to calculate a relative time compared
476 * to the start of this conversation
477 */
478 nstime_t ts_first;
479
480 /* Remember the timestamp of the most recent SYN in this conversation in
481 * order to calculate the first_rtt below. Not necessarily ts_first, if
482 * the SYN is retransmitted. */
483 nstime_t ts_mru_syn;
484
485 /* If we have the handshake, remember the RTT between the initial SYN
486 * and ACK for use detecting out-of-order segments. */
487 nstime_t ts_first_rtt;
488
489 /* Remember the timestamp of the frame that was last seen in this
490 * tcp conversation to be able to calculate a delta time compared
491 * to previous frame in this conversation
492 */
493 nstime_t ts_prev;
494
495 /* Keep track of tcp stream numbers instead of using the conversation
496 * index (as how it was done before). This prevents gaps in the
497 * stream index numbering
498 */
499 uint32_t stream;
500
501 /* Keep track of packet number within the TCP stream */
502 uint32_t pnum;
503
504 /* allocated only when mptcp enabled
505 * several tcp_analysis may refer to the same mptcp_analysis
506 * can exist without any meta
507 */
508 struct mptcp_analysis* mptcp_analysis;
509
510 /* Remembers the server port on the SYN (or SYN|ACK) packet to
511 * help determine which dissector to call
512 */
513 uint16_t server_port;
514
515 /* Set when the client sends a SYN with data and the cookie in the Fast Open
516 * option.
517 */
518 bool tfo_syn_data;
519
520 /* Remembers which side is currently sending data. */
521 int8_t flow_direction : 2;
522
523 /* Track the TCP conversation completeness, as the capture might
524 * contain all parts of a TCP flow (establishment, data, clearing) or
525 * just some parts if we jumped on the bandwagon of an already established
526 * connection or left before it was terminated explicitly
527 */
528 uint8_t conversation_completeness;
529 /* Track AccECN support */
530 bool had_acc_ecn_setup_syn;
531 bool had_acc_ecn_setup_syn_ack;
532 bool had_acc_ecn_option;
533
534 /* Stores the value as a String to be displayed in the appropriate field */
535 char *conversation_completeness_str;
536};
537
538/* Structure that keeps per packet data. First used to be able
539 * to calculate the time_delta from the last seen frame in this
540 * TCP conversation. Can be extended for future use.
541 */
542 struct tcp_per_packet_data_t {
543 nstime_t ts_del;
544 uint32_t pnum;
545 uint8_t tcp_snd_manual_analysis;
546 bool karn_flag; /* XXX - might later become a bit field */
547};
548
549/* Structure that keeps per packet data. Some operations are cpu-intensive and are
550 * best cached into this structure
551 */
552 typedef struct mptcp_per_packet_data_t_ {
553
554 /* Mapping that covers this packet content */
555 mptcp_dss_mapping_t *mapping;
556
557} mptcp_per_packet_data_t;
558
559
560WS_DLL_PUBLIC void dissect_tcp_payload(tvbuff_t *tvb, packet_info *pinfo, int offset,
561 uint32_t seq, uint32_t nxtseq, uint32_t sport,
562 uint32_t dport, proto_tree *tree,
563 proto_tree *tcp_tree,
564 struct tcp_analysis *tcpd, struct tcpinfo *tcpinfo);
565
566WS_DLL_PUBLIC struct tcp_analysis *get_tcp_conversation_data(conversation_t *conv,
567 packet_info *pinfo);
568
573WS_DLL_PUBLIC struct tcp_analysis *get_tcp_conversation_data_idempotent(conversation_t *conv);
574
575WS_DLL_PUBLIC bool decode_tcp_ports(tvbuff_t *, int, packet_info *, proto_tree *, int, int, struct tcp_analysis *, struct tcpinfo *);
576
589 extern void add_tcp_process_info(uint32_t frame_num, address *local_addr, address *remote_addr, uint16_t local_port, uint16_t remote_port, uint32_t uid, uint32_t pid, char *username, char *command);
590
595WS_DLL_PUBLIC uint32_t get_tcp_stream_count(void);
596
601WS_DLL_PUBLIC uint32_t get_mptcp_stream_count(void);
602
603/* Follow Stream functionality shared with HTTP (and SSL?) */
604 extern char *tcp_follow_conv_filter(epan_dissect_t *edt, packet_info *pinfo, unsigned *stream, unsigned *sub_stream);
605 extern char *tcp_follow_index_filter(unsigned stream, unsigned sub_stream);
606 extern char *tcp_follow_address_filter(address *src_addr, address *dst_addr, int src_port, int dst_port);
607
608#ifdef __cplusplus
609}
610#endif /* __cplusplus */
611
612#endif
address
struct _address address
Holds a network or link-layer address of any supported type.
conversation.h
conversation_t
struct conversation conversation_t
epan_dissect_t
struct epan_dissect epan_dissect_t
Opaque type representing a single packet dissection context.
Definition epan.h:62
packet_info
struct _packet_info packet_info
Represents the metadata and indexing information for a single captured frame.
wmem_array_t
struct _wmem_array_t wmem_array_t
Opaque type representing a dynamically resizable array in the wmem system.
Definition wmem_array.h:42
wmem_itree_t
struct _wmem_tree_t wmem_itree_t
Alias for a wmem interval tree.
Definition wmem_interval_tree.h:46
wmem_list_t
struct _wmem_list_t wmem_list_t
Opaque type representing a scoped, doubly-linked list in the wmem system.
Definition wmem_list.h:42
wmem_map_t
struct _wmem_map_t wmem_map_t
Opaque type representing a wmem-managed hash map.
Definition wmem_map.h:46
wmem_tree_t
struct _wmem_tree_t wmem_tree_t
Opaque type representing a red-black tree in the wmem system.
Definition wmem_tree.h:49
reassemble.h
_mptcp_dsn2packet_mapping_t
Definition packet-tcp.h:239
_mptcp_dss_mapping_t
Definition packet-tcp.h:218
_mptcp_meta_flow_t
Definition packet-tcp.h:249
_tcp_flow_t
Definition packet-tcp.h:366
_tcp_unacked_t
Definition packet-tcp.h:162
mptcp_analysis
Definition packet-tcp.h:420
mptcp_per_packet_data_t_
Definition packet-tcp.h:552
mptcp_subflow
Definition packet-tcp.h:281
mptcpheader
Definition packet-tcp.h:50
nstime_t
Definition nstime.h:26
reassembly_table_functions
Table of functions for a reassembly table.
Definition reassemble.h:151
stream
Definition stream.c:41
tcp_acked
Definition packet-tcp.h:171
tcp_analysis
Definition packet-tcp.h:439
tcp_analyze_seq_flow_info_t
Definition packet-tcp.h:315
tcp_multisegment_pdu
Definition packet-tcp.h:197
tcp_per_packet_data_t
Definition packet-tcp.h:542
tcp_process_info_t
Definition packet-tcp.h:358
tcpheader
Definition packet-tcp.h:83
tcpinfo
Definition packet-tcp.h:121
wmem_scopes.h