Fix various typos and spelling errors.
[obnox/wireshark/wip.git] / epan / dissectors / packet-tcp.c
1 /* packet-tcp.c
2  * Routines for TCP packet disassembly
3  *
4  * $Id$
5  *
6  * Wireshark - Network traffic analyzer
7  * By Gerald Combs <gerald@wireshark.org>
8  * Copyright 1998 Gerald Combs
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
23  */
24
25 #ifdef HAVE_CONFIG_H
26 # include "config.h"
27 #endif
28
29 #include <stdio.h>
30 #include <string.h>
31 #include <glib.h>
32 #include <epan/in_cksum.h>
33
34 #include <epan/packet.h>
35 #include <epan/addr_resolv.h>
36 #include <epan/ipproto.h>
37 #include <epan/ip_opts.h>
38 #include <epan/follow.h>
39 #include <epan/prefs.h>
40 #include <epan/emem.h>
41 #include "packet-tcp.h"
42 #include "packet-frame.h"
43 #include <epan/conversation.h>
44 #include <epan/reassemble.h>
45 #include <epan/tap.h>
46 #include <epan/slab.h>
47 #include <epan/expert.h>
48
49 static int tcp_tap = -1;
50
51 /* Place TCP summary in proto tree */
52 static gboolean tcp_summary_in_tree = TRUE;
53
54 /*
55  * Flag to control whether to check the TCP checksum.
56  *
57  * In at least some Solaris network traces, there are packets with bad
58  * TCP checksums, but the traffic appears to indicate that the packets
59  * *were* received; the packets were probably sent by the host on which
60  * the capture was being done, on a network interface to which
61  * checksumming was offloaded, so that DLPI supplied an un-checksummed
62  * packet to the capture program but a checksummed packet got put onto
63  * the wire.
64  */
65 static gboolean tcp_check_checksum = FALSE;
66
67 extern FILE* data_out_file;
68
69 static int proto_tcp = -1;
70 static int hf_tcp_srcport = -1;
71 static int hf_tcp_dstport = -1;
72 static int hf_tcp_port = -1;
73 static int hf_tcp_stream = -1;
74 static int hf_tcp_seq = -1;
75 static int hf_tcp_nxtseq = -1;
76 static int hf_tcp_ack = -1;
77 static int hf_tcp_hdr_len = -1;
78 static int hf_tcp_flags = -1;
79 static int hf_tcp_flags_res = -1;
80 static int hf_tcp_flags_ns = -1;
81 static int hf_tcp_flags_cwr = -1;
82 static int hf_tcp_flags_ecn = -1;
83 static int hf_tcp_flags_urg = -1;
84 static int hf_tcp_flags_ack = -1;
85 static int hf_tcp_flags_push = -1;
86 static int hf_tcp_flags_reset = -1;
87 static int hf_tcp_flags_syn = -1;
88 static int hf_tcp_flags_fin = -1;
89 static int hf_tcp_window_size = -1;
90 static int hf_tcp_checksum = -1;
91 static int hf_tcp_checksum_bad = -1;
92 static int hf_tcp_checksum_good = -1;
93 static int hf_tcp_len = -1;
94 static int hf_tcp_urgent_pointer = -1;
95 static int hf_tcp_analysis_flags = -1;
96 static int hf_tcp_analysis_bytes_in_flight = -1;
97 static int hf_tcp_analysis_acks_frame = -1;
98 static int hf_tcp_analysis_ack_rtt = -1;
99 static int hf_tcp_analysis_rto = -1;
100 static int hf_tcp_analysis_rto_frame = -1;
101 static int hf_tcp_analysis_retransmission = -1;
102 static int hf_tcp_analysis_fast_retransmission = -1;
103 static int hf_tcp_analysis_out_of_order = -1;
104 static int hf_tcp_analysis_reused_ports = -1;
105 static int hf_tcp_analysis_lost_packet = -1;
106 static int hf_tcp_analysis_ack_lost_packet = -1;
107 static int hf_tcp_analysis_window_update = -1;
108 static int hf_tcp_analysis_window_full = -1;
109 static int hf_tcp_analysis_keep_alive = -1;
110 static int hf_tcp_analysis_keep_alive_ack = -1;
111 static int hf_tcp_analysis_duplicate_ack = -1;
112 static int hf_tcp_analysis_duplicate_ack_num = -1;
113 static int hf_tcp_analysis_duplicate_ack_frame = -1;
114 static int hf_tcp_analysis_zero_window = -1;
115 static int hf_tcp_analysis_zero_window_probe = -1;
116 static int hf_tcp_analysis_zero_window_probe_ack = -1;
117 static int hf_tcp_continuation_to = -1;
118 static int hf_tcp_pdu_time = -1;
119 static int hf_tcp_pdu_size = -1;
120 static int hf_tcp_pdu_last_frame = -1;
121 static int hf_tcp_reassembled_in = -1;
122 static int hf_tcp_reassembled_length = -1;
123 static int hf_tcp_segments = -1;
124 static int hf_tcp_segment = -1;
125 static int hf_tcp_segment_overlap = -1;
126 static int hf_tcp_segment_overlap_conflict = -1;
127 static int hf_tcp_segment_multiple_tails = -1;
128 static int hf_tcp_segment_too_long_fragment = -1;
129 static int hf_tcp_segment_error = -1;
130 static int hf_tcp_options = -1;
131 static int hf_tcp_option_kind = -1;
132 static int hf_tcp_option_len = -1;
133 static int hf_tcp_option_mss = -1;
134 static int hf_tcp_option_mss_val = -1;
135 static int hf_tcp_option_wscale_shift = -1;
136 static int hf_tcp_option_wscale_multiplier = -1;
137 static int hf_tcp_option_sack_perm = -1;
138 static int hf_tcp_option_sack = -1;
139 static int hf_tcp_option_sack_sle = -1;
140 static int hf_tcp_option_sack_sre = -1;
141 static int hf_tcp_option_echo = -1;
142 static int hf_tcp_option_echo_reply = -1;
143 static int hf_tcp_option_timestamp_tsval = -1;
144 static int hf_tcp_option_timestamp_tsecr = -1;
145 static int hf_tcp_option_cc = -1;
146 static int hf_tcp_option_ccnew = -1;
147 static int hf_tcp_option_ccecho = -1;
148 static int hf_tcp_option_md5 = -1;
149 static int hf_tcp_option_qs = -1;
150 static int hf_tcp_ts_relative = -1;
151 static int hf_tcp_ts_delta = -1;
152 static int hf_tcp_option_scps = -1;
153 static int hf_tcp_option_scps_vector = -1;
154 static int hf_tcp_option_scps_binding = -1;
155 static int hf_tcp_scpsoption_flags_bets = -1;
156 static int hf_tcp_scpsoption_flags_snack1 = -1;
157 static int hf_tcp_scpsoption_flags_snack2 = -1;
158 static int hf_tcp_scpsoption_flags_compress = -1;
159 static int hf_tcp_scpsoption_flags_nlts = -1;
160 static int hf_tcp_scpsoption_flags_resv1 = -1;
161 static int hf_tcp_scpsoption_flags_resv2 = -1;
162 static int hf_tcp_scpsoption_flags_resv3 = -1;
163 static int hf_tcp_option_snack = -1;
164 static int hf_tcp_option_snack_offset = -1;
165 static int hf_tcp_option_snack_size = -1;
166 static int hf_tcp_option_snack_le = -1;
167 static int hf_tcp_option_snack_re = -1;
168 static int hf_tcp_option_mood = -1;
169 static int hf_tcp_option_mood_val = -1;
170 static int hf_tcp_option_user_to = -1;
171 static int hf_tcp_option_user_to_granularity = -1;
172 static int hf_tcp_option_user_to_val = -1;
173 static int hf_tcp_proc_src_uid = -1;
174 static int hf_tcp_proc_src_pid = -1;
175 static int hf_tcp_proc_src_uname = -1;
176 static int hf_tcp_proc_src_cmd = -1;
177 static int hf_tcp_proc_dst_uid = -1;
178 static int hf_tcp_proc_dst_pid = -1;
179 static int hf_tcp_proc_dst_uname = -1;
180 static int hf_tcp_proc_dst_cmd = -1;
181
182 static gint ett_tcp = -1;
183 static gint ett_tcp_flags = -1;
184 static gint ett_tcp_options = -1;
185 static gint ett_tcp_option_timestamp = -1;
186 static gint ett_tcp_option_wscale = -1;
187 static gint ett_tcp_option_sack = -1;
188 static gint ett_tcp_option_scps = -1;
189 static gint ett_tcp_option_scps_extended = -1;
190 static gint ett_tcp_option_user_to = -1;
191 static gint ett_tcp_analysis = -1;
192 static gint ett_tcp_analysis_faults = -1;
193 static gint ett_tcp_timestamps = -1;
194 static gint ett_tcp_segments = -1;
195 static gint ett_tcp_segment  = -1;
196 static gint ett_tcp_checksum = -1;
197 static gint ett_tcp_process_info = -1;
198
199 /*
200  *  TCP option
201  */
202
203 #define TCPOPT_NOP              1       /* Padding */
204 #define TCPOPT_EOL              0       /* End of options */
205 #define TCPOPT_MSS              2       /* Segment size negotiating */
206 #define TCPOPT_WINDOW           3       /* Window scaling */
207 #define TCPOPT_SACK_PERM        4       /* SACK Permitted */
208 #define TCPOPT_SACK             5       /* SACK Block */
209 #define TCPOPT_ECHO             6
210 #define TCPOPT_ECHOREPLY        7
211 #define TCPOPT_TIMESTAMP        8       /* Better RTT estimations/PAWS */
212 #define TCPOPT_CC               11
213 #define TCPOPT_CCNEW            12
214 #define TCPOPT_CCECHO           13
215 #define TCPOPT_MD5              19      /* RFC2385 */
216 #define TCPOPT_SCPS             20      /* SCPS Capabilities */
217 #define TCPOPT_SNACK            21      /* SCPS SNACK */
218 #define TCPOPT_RECBOUND         22      /* SCPS Record Boundary */
219 #define TCPOPT_CORREXP          23      /* SCPS Corruption Experienced */
220 #define TCPOPT_MOOD             25      /* RFC5841 TCP Packet Mood */
221 #define TCPOPT_QS               27      /* RFC4782 */
222 #define TCPOPT_USER_TO          28      /* RFC5482 */
223
224 /*
225  *     TCP option lengths
226  */
227
228 #define TCPOLEN_MSS            4
229 #define TCPOLEN_WINDOW         3
230 #define TCPOLEN_SACK_PERM      2
231 #define TCPOLEN_SACK_MIN       2
232 #define TCPOLEN_ECHO           6
233 #define TCPOLEN_ECHOREPLY      6
234 #define TCPOLEN_TIMESTAMP     10
235 #define TCPOLEN_CC             6
236 #define TCPOLEN_CCNEW          6
237 #define TCPOLEN_CCECHO         6
238 #define TCPOLEN_MD5           18
239 #define TCPOLEN_SCPS           4
240 #define TCPOLEN_SNACK          6
241 #define TCPOLEN_RECBOUND       2
242 #define TCPOLEN_CORREXP        2
243 #define TCPOLEN_MOOD_MIN       2
244 #define TCPOLEN_QS             8
245 #define TCPOLEN_USER_TO        4
246
247 static const true_false_string tcp_option_user_to_granularity = {
248   "Minutes", "Seconds"
249 };
250
251 static const value_string tcp_option_kind_vs[] = {
252     { TCPOPT_WINDOW, "Window Scale" },
253     { TCPOPT_TIMESTAMP, "Timestamp" },
254     { 0, NULL }
255 };
256
257 /* not all of the hf_fields below make sense for TCP but we have to provide
258    them anyways to comply with the api (which was aimed for ip fragment
259    reassembly) */
260 static const fragment_items tcp_segment_items = {
261     &ett_tcp_segment,
262     &ett_tcp_segments,
263     &hf_tcp_segments,
264     &hf_tcp_segment,
265     &hf_tcp_segment_overlap,
266     &hf_tcp_segment_overlap_conflict,
267     &hf_tcp_segment_multiple_tails,
268     &hf_tcp_segment_too_long_fragment,
269     &hf_tcp_segment_error,
270     &hf_tcp_reassembled_in,
271     &hf_tcp_reassembled_length,
272     "Segments"
273 };
274
275 static dissector_table_t subdissector_table;
276 static heur_dissector_list_t heur_subdissector_list;
277 static dissector_handle_t data_handle;
278
279 /* TCP structs and definitions */
280
281 /* **************************************************************************
282  * RTT, relative sequence numbers, window scaling & etc.
283  * **************************************************************************/
284 static gboolean tcp_analyze_seq           = TRUE;
285 static gboolean tcp_relative_seq          = TRUE;
286 static gboolean tcp_window_scaling        = TRUE;
287 static gboolean tcp_track_bytes_in_flight = TRUE;
288 static gboolean tcp_calculate_ts          = FALSE;
289
290 /* SLAB allocator for tcp_unacked structures
291  */
292 SLAB_ITEM_TYPE_DEFINE(tcp_unacked_t)
293 static SLAB_FREE_LIST_DEFINE(tcp_unacked_t)
294 #define TCP_UNACKED_NEW(fi)                 \
295     SLAB_ALLOC(fi, tcp_unacked_t)
296 #define TCP_UNACKED_FREE(fi)                    \
297     SLAB_FREE(fi, tcp_unacked_t)
298
299
300 #define TCP_A_RETRANSMISSION        0x0001
301 #define TCP_A_LOST_PACKET           0x0002
302 #define TCP_A_ACK_LOST_PACKET       0x0004
303 #define TCP_A_KEEP_ALIVE            0x0008
304 #define TCP_A_DUPLICATE_ACK         0x0010
305 #define TCP_A_ZERO_WINDOW           0x0020
306 #define TCP_A_ZERO_WINDOW_PROBE     0x0040
307 #define TCP_A_ZERO_WINDOW_PROBE_ACK 0x0080
308 #define TCP_A_KEEP_ALIVE_ACK        0x0100
309 #define TCP_A_OUT_OF_ORDER          0x0200
310 #define TCP_A_FAST_RETRANSMISSION   0x0400
311 #define TCP_A_WINDOW_UPDATE         0x0800
312 #define TCP_A_WINDOW_FULL           0x1000
313 #define TCP_A_REUSED_PORTS          0x2000
314
315
316 static void
317 process_tcp_payload(tvbuff_t *tvb, volatile int offset, packet_info *pinfo,
318     proto_tree *tree, proto_tree *tcp_tree, int src_port, int dst_port,
319     guint32 seq, guint32 nxtseq, gboolean is_tcp_segment,
320     struct tcp_analysis *tcpd);
321
322
323 struct tcp_analysis *
324 init_tcp_conversation_data(packet_info *pinfo)
325 {
326     struct tcp_analysis *tcpd;
327
328     /* Initialize the tcp protocol data structure to add to the tcp conversation */
329     tcpd=se_alloc0(sizeof(struct tcp_analysis));
330     tcpd->flow1.win_scale=-1;
331     tcpd->flow1.multisegment_pdus=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "tcp_multisegment_pdus");
332     /*
333     tcpd->flow1.username = NULL;
334     tcpd->flow1.command = NULL;
335     */
336     tcpd->flow2.win_scale=-1;
337     tcpd->flow2.multisegment_pdus=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "tcp_multisegment_pdus");
338     /*
339     tcpd->flow2.username = NULL;
340     tcpd->flow2.command = NULL;
341     */
342     tcpd->acked_table=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "tcp_analyze_acked_table");
343     tcpd->ts_first.secs=pinfo->fd->abs_ts.secs;
344     tcpd->ts_first.nsecs=pinfo->fd->abs_ts.nsecs;
345     tcpd->ts_prev.secs=pinfo->fd->abs_ts.secs;
346     tcpd->ts_prev.nsecs=pinfo->fd->abs_ts.nsecs;
347     tcpd->flow1.valid_bif = 1;
348     tcpd->flow2.valid_bif = 1;
349
350
351     return tcpd;
352 }
353
354 struct tcp_analysis *
355 get_tcp_conversation_data(conversation_t *conv, packet_info *pinfo)
356 {
357     int direction;
358     struct tcp_analysis *tcpd;
359
360     /* Did the caller supply the conversation pointer? */
361     if( conv==NULL )
362             conv = find_or_create_conversation(pinfo);
363
364     /* Get the data for this conversation */
365     tcpd=conversation_get_proto_data(conv, proto_tcp);
366
367     /* If the conversation was just created or it matched a
368      * conversation with template options, tcpd will not
369      * have been initialized. So, initialize
370      * a new tcpd structure for the conversation.
371      */
372     if (!tcpd) {
373         tcpd = init_tcp_conversation_data(pinfo);
374         conversation_add_proto_data(conv, proto_tcp, tcpd);
375     }
376
377     if (!tcpd) {
378       return NULL;
379     }
380
381     /* check direction and get ua lists */
382     direction=CMP_ADDRESS(&pinfo->src, &pinfo->dst);
383     /* if the addresses are equal, match the ports instead */
384     if(direction==0) {
385         direction= (pinfo->srcport > pinfo->destport) ? 1 : -1;
386     }
387     if(direction>=0){
388         tcpd->fwd=&(tcpd->flow1);
389         tcpd->rev=&(tcpd->flow2);
390     } else {
391         tcpd->fwd=&(tcpd->flow2);
392         tcpd->rev=&(tcpd->flow1);
393     }
394
395     tcpd->ta=NULL;
396     return tcpd;
397 }
398
399 /* Attach process info to a flow */
400 /* XXX - We depend on the TCP dissector finding the conversation first */
401 void
402 add_tcp_process_info(guint32 frame_num, address *local_addr, address *remote_addr, guint16 local_port, guint16 remote_port, guint32 uid, guint32 pid, gchar *username, gchar *command) {
403     conversation_t *conv;
404     struct tcp_analysis *tcpd;
405     tcp_flow_t *flow = NULL;
406
407     conv = find_conversation(frame_num, local_addr, remote_addr, PT_TCP, local_port, remote_port, 0);
408     if (!conv) {
409         return;
410     }
411
412     tcpd = conversation_get_proto_data(conv, proto_tcp);
413     if (!tcpd) {
414         return;
415     }
416
417     if (CMP_ADDRESS(local_addr, &conv->key_ptr->addr1) == 0 && local_port == conv->key_ptr->port1) {
418         flow = &tcpd->flow1;
419     } else if (CMP_ADDRESS(remote_addr, &conv->key_ptr->addr1) == 0 && remote_port == conv->key_ptr->port1) {
420         flow = &tcpd->flow2;
421     }
422     if (!flow || flow->command) {
423         return;
424     }
425
426     flow->process_uid = uid;
427     flow->process_pid = pid;
428     flow->username = se_strdup(username);
429     flow->command = se_strdup(command);
430 }
431
432
433 /* Calculate the timestamps relative to this conversation */
434 static void
435 tcp_calculate_timestamps(packet_info *pinfo, struct tcp_analysis *tcpd,
436             struct tcp_per_packet_data_t *tcppd)
437 {
438     if( !tcppd ) {
439         tcppd = se_alloc(sizeof(struct tcp_per_packet_data_t));
440         p_add_proto_data(pinfo->fd, proto_tcp, tcppd);
441     }
442
443     if (!tcpd)
444         return;
445
446     nstime_delta(&tcppd->ts_del, &pinfo->fd->abs_ts, &tcpd->ts_prev);
447
448     tcpd->ts_prev.secs=pinfo->fd->abs_ts.secs;
449     tcpd->ts_prev.nsecs=pinfo->fd->abs_ts.nsecs;
450 }
451
452 /* Add a subtree with the timestamps relative to this conversation */
453 static void
454 tcp_print_timestamps(packet_info *pinfo, tvbuff_t *tvb, proto_tree *parent_tree, struct tcp_analysis *tcpd, struct tcp_per_packet_data_t *tcppd)
455 {
456     proto_item  *item;
457     proto_tree  *tree;
458     nstime_t    ts;
459
460     if (!tcpd)
461         return;
462
463     item=proto_tree_add_text(parent_tree, tvb, 0, 0, "Timestamps");
464     PROTO_ITEM_SET_GENERATED(item);
465     tree=proto_item_add_subtree(item, ett_tcp_timestamps);
466
467     nstime_delta(&ts, &pinfo->fd->abs_ts, &tcpd->ts_first);
468     item = proto_tree_add_time(tree, hf_tcp_ts_relative, tvb, 0, 0, &ts);
469     PROTO_ITEM_SET_GENERATED(item);
470
471     if( !tcppd )
472         tcppd = p_get_proto_data(pinfo->fd, proto_tcp);
473
474     if( tcppd ) {
475         item = proto_tree_add_time(tree, hf_tcp_ts_delta, tvb, 0, 0,
476             &tcppd->ts_del);
477         PROTO_ITEM_SET_GENERATED(item);
478     }
479 }
480
481 static void
482 print_pdu_tracking_data(packet_info *pinfo, tvbuff_t *tvb, proto_tree *tcp_tree, struct tcp_multisegment_pdu *msp)
483 {
484     proto_item *item;
485
486     col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[Continuation to #%u] ", msp->first_frame);
487     item=proto_tree_add_uint(tcp_tree, hf_tcp_continuation_to,
488         tvb, 0, 0, msp->first_frame);
489     PROTO_ITEM_SET_GENERATED(item);
490 }
491
492 /* if we know that a PDU starts inside this segment, return the adjusted
493    offset to where that PDU starts or just return offset back
494    and let TCP try to find out what it can about this segment
495 */
496 static int
497 scan_for_next_pdu(tvbuff_t *tvb, proto_tree *tcp_tree, packet_info *pinfo, int offset, guint32 seq, guint32 nxtseq, emem_tree_t *multisegment_pdus)
498 {
499     struct tcp_multisegment_pdu *msp=NULL;
500
501     if(!pinfo->fd->flags.visited){
502         msp=se_tree_lookup32_le(multisegment_pdus, seq-1);
503         if(msp){
504             /* If this is a continuation of a PDU started in a
505              * previous segment we need to update the last_frame
506              * variables.
507             */
508             if(seq>msp->seq && seq<msp->nxtpdu){
509                 msp->last_frame=pinfo->fd->num;
510                 msp->last_frame_time=pinfo->fd->abs_ts;
511                 print_pdu_tracking_data(pinfo, tvb, tcp_tree, msp);
512             }
513
514             /* If this segment is completely within a previous PDU
515              * then we just skip this packet
516              */
517             if(seq>msp->seq && nxtseq<=msp->nxtpdu){
518                 return -1;
519             }
520             if(seq<msp->nxtpdu && nxtseq>msp->nxtpdu){
521                 offset+=msp->nxtpdu-seq;
522                 return offset;
523             }
524
525         }
526     } else {
527         /* First we try to find the start and transfer time for a PDU.
528          * We only print this for the very first segment of a PDU
529          * and only for PDUs spanning multiple segments.
530          * Se we look for if there was any multisegment PDU started
531          * just BEFORE the end of this segment. I.e. either inside this
532          * segment or in a previous segment.
533          * Since this might also match PDUs that are completely within
534          * this segment we also verify that the found PDU does span
535          * beyond the end of this segment.
536          */
537         msp=se_tree_lookup32_le(multisegment_pdus, nxtseq-1);
538         if(msp){
539             if( (pinfo->fd->num==msp->first_frame)
540             ){
541                 proto_item *item;
542                 nstime_t ns;
543
544                 item=proto_tree_add_uint(tcp_tree, hf_tcp_pdu_last_frame, tvb, 0, 0, msp->last_frame);
545                 PROTO_ITEM_SET_GENERATED(item);
546
547                 nstime_delta(&ns, &msp->last_frame_time, &pinfo->fd->abs_ts);
548                 item = proto_tree_add_time(tcp_tree, hf_tcp_pdu_time,
549                         tvb, 0, 0, &ns);
550                 PROTO_ITEM_SET_GENERATED(item);
551             }
552         }
553
554         /* Second we check if this segment is part of a PDU started
555          * prior to the segment (seq-1)
556          */
557         msp=se_tree_lookup32_le(multisegment_pdus, seq-1);
558         if(msp){
559             /* If this segment is completely within a previous PDU
560              * then we just skip this packet
561              */
562             if(seq>msp->seq && nxtseq<=msp->nxtpdu){
563                 print_pdu_tracking_data(pinfo, tvb, tcp_tree, msp);
564                 return -1;
565             }
566
567             if(seq<msp->nxtpdu && nxtseq>msp->nxtpdu){
568                 offset+=msp->nxtpdu-seq;
569                 return offset;
570             }
571         }
572
573     }
574     return offset;
575 }
576
577 /* if we saw a PDU that extended beyond the end of the segment,
578    use this function to remember where the next pdu starts
579 */
580 struct tcp_multisegment_pdu *
581 pdu_store_sequencenumber_of_next_pdu(packet_info *pinfo, guint32 seq, guint32 nxtpdu, emem_tree_t *multisegment_pdus)
582 {
583     struct tcp_multisegment_pdu *msp;
584
585     msp=se_alloc(sizeof(struct tcp_multisegment_pdu));
586     msp->nxtpdu=nxtpdu;
587     msp->seq=seq;
588     msp->first_frame=pinfo->fd->num;
589     msp->last_frame=pinfo->fd->num;
590     msp->last_frame_time=pinfo->fd->abs_ts;
591     msp->flags=0;
592     se_tree_insert32(multisegment_pdus, seq, (void *)msp);
593     return msp;
594 }
595
596 /* This is called for SYN+ACK packets and the purpose is to verify that we
597  * have seen window scaling in both directions.
598  * If we cant find window scaling being set in both directions
599  * that means it was present in the SYN but not in the SYN+ACK
600  * (or the SYN was missing) and then we disable the window scaling
601  * for this tcp session.
602  */
603 static void
604 verify_tcp_window_scaling(struct tcp_analysis *tcpd)
605 {
606     if( tcpd && ((tcpd->flow1.win_scale==-1) || (tcpd->flow2.win_scale==-1)) ){
607         tcpd->flow1.win_scale=-1;
608         tcpd->flow2.win_scale=-1;
609     }
610 }
611
612 /* if we saw a window scaling option, store it for future reference
613 */
614 static void
615 pdu_store_window_scale_option(guint8 ws, struct tcp_analysis *tcpd)
616 {
617     if (tcpd)
618         tcpd->fwd->win_scale=ws;
619 }
620
621 static void
622 tcp_get_relative_seq_ack(guint32 *seq, guint32 *ack, guint32 *win, struct tcp_analysis *tcpd)
623 {
624     if (tcpd) {
625         if (tcp_relative_seq) {
626             (*seq) -= tcpd->fwd->base_seq;
627             (*ack) -= tcpd->rev->base_seq;
628         }
629         if ((tcp_window_scaling) && (tcpd->fwd->win_scale!=-1)) {
630             (*win)<<=tcpd->fwd->win_scale;
631         }
632     }
633 }
634
635
636 /* when this function returns, it will (if createflag) populate the ta pointer.
637  */
638 static void
639 tcp_analyze_get_acked_struct(guint32 frame, gboolean createflag, struct tcp_analysis *tcpd)
640 {
641     if (!tcpd)
642         return;
643
644     tcpd->ta=se_tree_lookup32(tcpd->acked_table, frame);
645     if((!tcpd->ta) && createflag){
646         tcpd->ta=se_alloc0(sizeof(struct tcp_acked));
647         se_tree_insert32(tcpd->acked_table, frame, (void *)tcpd->ta);
648     }
649 }
650
651
652 /* fwd contains a list of all segments processed but not yet ACKed in the
653  *     same direction as the current segment.
654  * rev contains a list of all segments received but not yet ACKed in the
655  *     opposite direction to the current segment.
656  *
657  * New segments are always added to the head of the fwd/rev lists.
658  *
659  */
660 static void
661 tcp_analyze_sequence_number(packet_info *pinfo, guint32 seq, guint32 ack, guint32 seglen, guint16 flags, guint32 window, struct tcp_analysis *tcpd)
662 {
663     tcp_unacked_t *ual=NULL;
664     tcp_unacked_t *prevual=NULL;
665     guint32 nextseq;
666     int ackcount;
667
668 #ifdef REMOVED
669 printf("analyze_sequence numbers   frame:%u  direction:%s\n",pinfo->fd->num,direction>=0?"FWD":"REW");
670 printf("FWD list lastflags:0x%04x base_seq:0x%08x:\n",tcpd->fwd->lastsegmentflags,tcpd->fwd->base_seq);for(ual=tcpd->fwd->segments;ual;ual=ual->next)printf("Frame:%d Seq:%d Nextseq:%d\n",ual->frame,ual->seq,ual->nextseq);
671 printf("REV list lastflags:0x%04x base_seq:0x%08x:\n",tcpd->rev->lastsegmentflags,tcpd->rev->base_seq);for(ual=tcpd->rev->segments;ual;ual=ual->next)printf("Frame:%d Seq:%d Nextseq:%d\n",ual->frame,ual->seq,ual->nextseq);
672 #endif
673
674     if (!tcpd) {
675         return;
676     }
677
678     /* if this is the first segment for this list we need to store the
679      * base_seq
680      *
681      * Start relative seq and ack numbers at 1 if this
682      * is not a SYN packet. This makes the relative
683      * seq/ack numbers to be displayed correctly in the
684      * event that the SYN or SYN/ACK packet is not seen
685      * (this solves bug 1542)
686      */
687     if(tcpd->fwd->base_seq==0){
688         tcpd->fwd->base_seq = (flags & TH_SYN) ? seq : seq-1;
689     }
690
691     /* Only store reverse sequence if this isn't the SYN
692      * There's no guarantee that the ACK field of a SYN
693      * contains zeros; get the ISN from the first segment
694      * with the ACK bit set instead (usually the SYN/ACK).
695      */
696     if( (tcpd->rev->base_seq==0) && (flags & TH_ACK) ){
697         tcpd->rev->base_seq = (flags & TH_SYN) ? ack : ack-1;
698     }
699
700         if( flags & TH_ACK ){
701                 tcpd->rev->valid_bif = 1;
702         }
703
704     /* ZERO WINDOW PROBE
705      * it is a zero window probe if
706      *  the sequnece number is the next expected one
707      *  the window in the other direction is 0
708      *  the segment is exactly 1 byte
709      */
710 /*QQQ tested*/
711     if( seglen==1
712     &&  seq==tcpd->fwd->nextseq
713     &&  tcpd->rev->window==0 ){
714         if(!tcpd->ta){
715             tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE, tcpd);
716         }
717         tcpd->ta->flags|=TCP_A_ZERO_WINDOW_PROBE;
718         goto finished_fwd;
719     }
720
721
722     /* ZERO WINDOW
723      * a zero window packet has window == 0   but none of the SYN/FIN/RST set
724      */
725 /*QQQ tested*/
726     if( window==0
727     && (flags&(TH_RST|TH_FIN|TH_SYN))==0 ){
728         if(!tcpd->ta){
729             tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE, tcpd);
730         }
731         tcpd->ta->flags|=TCP_A_ZERO_WINDOW;
732     }
733
734
735     /* LOST PACKET
736      * If this segment is beyond the last seen nextseq we must
737      * have missed some previous segment
738      *
739      * We only check for this if we have actually seen segments prior to this
740      * one.
741      * RST packets are not checked for this.
742      */
743     if( tcpd->fwd->nextseq
744     &&  GT_SEQ(seq, tcpd->fwd->nextseq)
745     &&  (flags&(TH_RST))==0 ){
746         if(!tcpd->ta){
747             tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE, tcpd);
748         }
749         tcpd->ta->flags|=TCP_A_LOST_PACKET;
750
751         /* Disable BiF until an ACK is seen in the other direction */   
752         tcpd->fwd->valid_bif = 0; 
753     }
754
755
756     /* KEEP ALIVE
757      * a keepalive contains 0 or 1 bytes of data and starts one byte prior
758      * to what should be the next sequence number.
759      * SYN/FIN/RST segments are never keepalives
760      */
761 /*QQQ tested */
762     if( (seglen==0||seglen==1)
763     &&  seq==(tcpd->fwd->nextseq-1)
764     &&  (flags&(TH_SYN|TH_FIN|TH_RST))==0 ){
765         if(!tcpd->ta){
766             tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE, tcpd);
767         }
768         tcpd->ta->flags|=TCP_A_KEEP_ALIVE;
769     }
770
771     /* WINDOW UPDATE
772      * A window update is a 0 byte segment with the same SEQ/ACK numbers as
773      * the previous seen segment and with a new window value
774      */
775     if( seglen==0
776     &&  window
777     &&  window!=tcpd->fwd->window
778     &&  seq==tcpd->fwd->nextseq
779     &&  ack==tcpd->fwd->lastack
780     &&  (flags&(TH_SYN|TH_FIN|TH_RST))==0 ){
781         if(!tcpd->ta){
782             tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE, tcpd);
783         }
784         tcpd->ta->flags|=TCP_A_WINDOW_UPDATE;
785     }
786
787
788     /* WINDOW FULL
789      * If we know the window scaling
790      * and if this segment contains data ang goes all the way to the
791      * edge of the advertized window
792      * then we mark it as WINDOW FULL
793      * SYN/RST/FIN packets are never WINDOW FULL
794      */
795 /*QQQ tested*/
796     if( seglen>0
797     &&  tcpd->fwd->win_scale!=-1
798     &&  tcpd->rev->win_scale!=-1
799     &&  (seq+seglen)==(tcpd->rev->lastack+(tcpd->rev->window<<tcpd->rev->win_scale))
800     &&  (flags&(TH_SYN|TH_FIN|TH_RST))==0 ){
801         if(!tcpd->ta){
802             tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE, tcpd);
803         }
804         tcpd->ta->flags|=TCP_A_WINDOW_FULL;
805     }
806
807
808     /* KEEP ALIVE ACK
809      * It is a keepalive ack if it repeats the previous ACK and if
810      * the last segment in the reverse direction was a keepalive
811      */
812 /*QQQ tested*/
813     if( seglen==0
814     &&  window
815     &&  window==tcpd->fwd->window
816     &&  seq==tcpd->fwd->nextseq
817     &&  ack==tcpd->fwd->lastack
818     && (tcpd->rev->lastsegmentflags&TCP_A_KEEP_ALIVE)
819     &&  (flags&(TH_SYN|TH_FIN|TH_RST))==0 ){
820         if(!tcpd->ta){
821             tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE, tcpd);
822         }
823         tcpd->ta->flags|=TCP_A_KEEP_ALIVE_ACK;
824         goto finished_fwd;
825     }
826
827
828     /* ZERO WINDOW PROBE ACK
829      * It is a zerowindowprobe ack if it repeats the previous ACK and if
830      * the last segment in the reverse direction was a zerowindowprobe
831      * It also repeats the previous zero window indication
832      */
833 /*QQQ tested*/
834     if( seglen==0
835     &&  window==0
836     &&  window==tcpd->fwd->window
837     &&  seq==tcpd->fwd->nextseq
838     &&  ack==tcpd->fwd->lastack
839     && (tcpd->rev->lastsegmentflags&TCP_A_ZERO_WINDOW_PROBE)
840     &&  (flags&(TH_SYN|TH_FIN|TH_RST))==0 ){
841         if(!tcpd->ta){
842             tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE, tcpd);
843         }
844         tcpd->ta->flags|=TCP_A_ZERO_WINDOW_PROBE_ACK;
845         goto finished_fwd;
846     }
847
848
849     /* DUPLICATE ACK
850      * It is a duplicate ack if window/seq/ack is the same as the previous
851      * segment and if the segment length is 0
852      */
853     if( seglen==0
854     &&  window
855     &&  window==tcpd->fwd->window
856     &&  seq==tcpd->fwd->nextseq
857     &&  ack==tcpd->fwd->lastack
858     &&  (flags&(TH_SYN|TH_FIN|TH_RST))==0 ){
859         tcpd->fwd->dupacknum++;
860         if(!tcpd->ta){
861             tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE, tcpd);
862         }
863         tcpd->ta->flags|=TCP_A_DUPLICATE_ACK;
864         tcpd->ta->dupack_num=tcpd->fwd->dupacknum;
865         tcpd->ta->dupack_frame=tcpd->fwd->lastnondupack;
866     }
867
868
869
870 finished_fwd:
871     /* If this was NOT a dupack we must reset the dupack counters */
872     if( (!tcpd->ta) || !(tcpd->ta->flags&TCP_A_DUPLICATE_ACK) ){
873         tcpd->fwd->lastnondupack=pinfo->fd->num;
874         tcpd->fwd->dupacknum=0;
875     }
876
877
878     /* ACKED LOST PACKET
879      * If this segment acks beyond the nextseqnum in the other direction
880      * then that means we have missed packets going in the
881      * other direction
882      *
883      * We only check this if we have actually seen some seq numbers
884      * in the other direction.
885      */
886     if( tcpd->rev->nextseq
887     &&  GT_SEQ(ack, tcpd->rev->nextseq )
888     &&  (flags&(TH_ACK))!=0 ){
889 /*QQQ tested*/
890         if(!tcpd->ta){
891             tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE, tcpd);
892         }
893         tcpd->ta->flags|=TCP_A_ACK_LOST_PACKET;
894         /* update nextseq in the other direction so we dont get
895          * this indication again.
896          */
897         tcpd->rev->nextseq=ack;
898     }
899
900
901     /* RETRANSMISSION/FAST RETRANSMISSION/OUT-OF-ORDER
902      * If the segments contains data and if it does not advance
903      * sequence number it must be either of these three.
904      * Only test for this if we know what the seq number should be
905      * (tcpd->fwd->nextseq)
906      *
907      * Note that a simple KeepAlive is not a retransmission
908      */
909     if( seglen>0
910     &&  tcpd->fwd->nextseq
911     &&  (LT_SEQ(seq, tcpd->fwd->nextseq)) ){
912         guint64 t;
913
914         if(tcpd->ta && (tcpd->ta->flags&TCP_A_KEEP_ALIVE) ){
915             goto finished_checking_retransmission_type;
916         }
917
918         /* If there were >=2 duplicate ACKs in the reverse direction
919          * (there might be duplicate acks missing from the trace)
920          * and if this sequence number matches those ACKs
921          * and if the packet occurs within 20ms of the last
922          * duplicate ack
923          * then this is a fast retransmission
924          */
925         t=(pinfo->fd->abs_ts.secs-tcpd->rev->lastacktime.secs)*1000000000;
926         t=t+(pinfo->fd->abs_ts.nsecs)-tcpd->rev->lastacktime.nsecs;
927         if( tcpd->rev->dupacknum>=2
928         &&  tcpd->rev->lastack==seq
929         &&  t<20000000 ){
930             if(!tcpd->ta){
931                 tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE, tcpd);
932             }
933             tcpd->ta->flags|=TCP_A_FAST_RETRANSMISSION;
934             goto finished_checking_retransmission_type;
935         }
936
937         /* If the segment came <3ms since the segment with the highest
938          * seen sequence number, then it is an OUT-OF-ORDER segment.
939          *   (3ms is an arbitrary number)
940          */
941         t=(pinfo->fd->abs_ts.secs-tcpd->fwd->nextseqtime.secs)*1000000000;
942         t=t+(pinfo->fd->abs_ts.nsecs)-tcpd->fwd->nextseqtime.nsecs;
943         if( t<3000000 ){
944             if(!tcpd->ta){
945                 tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE, tcpd);
946             }
947             tcpd->ta->flags|=TCP_A_OUT_OF_ORDER;
948             goto finished_checking_retransmission_type;
949         }
950
951         /* Then it has to be a generic retransmission */
952         if(!tcpd->ta){
953             tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE, tcpd);
954         }
955         tcpd->ta->flags|=TCP_A_RETRANSMISSION;
956         nstime_delta(&tcpd->ta->rto_ts, &pinfo->fd->abs_ts, &tcpd->fwd->nextseqtime);
957         tcpd->ta->rto_frame=tcpd->fwd->nextseqframe;
958     }
959 finished_checking_retransmission_type:
960
961
962         nextseq = seq+seglen;
963         if (seglen || flags&(TH_SYN|TH_FIN)) {
964         /* add this new sequence number to the fwd list */
965         TCP_UNACKED_NEW(ual);
966         ual->next=tcpd->fwd->segments;
967         tcpd->fwd->segments=ual;
968         ual->frame=pinfo->fd->num;
969         ual->seq=seq;
970         ual->ts=pinfo->fd->abs_ts;
971
972         /* next sequence number is seglen bytes away, plus SYN/FIN which counts as one byte */
973         if( (flags&(TH_SYN|TH_FIN)) ){
974         nextseq+=1;
975             }
976             ual->nextseq=nextseq;
977         }
978
979     /* Store the highest number seen so far for nextseq so we can detect
980      * when we receive segments that arrive with a "hole"
981      * If we dont have anything since before, just store what we got.
982      * ZeroWindowProbes are special and dont really advance the nextseq
983      */
984     if(GT_SEQ(nextseq, tcpd->fwd->nextseq) || !tcpd->fwd->nextseq) {
985         if( !tcpd->ta || !(tcpd->ta->flags&TCP_A_ZERO_WINDOW_PROBE) ){
986             tcpd->fwd->nextseq=nextseq;
987             tcpd->fwd->nextseqframe=pinfo->fd->num;
988             tcpd->fwd->nextseqtime.secs=pinfo->fd->abs_ts.secs;
989             tcpd->fwd->nextseqtime.nsecs=pinfo->fd->abs_ts.nsecs;
990         }
991     }
992
993
994     /* remember what the ack/window is so we can track window updates and retransmissions */
995     tcpd->fwd->window=window;
996     tcpd->fwd->lastack=ack;
997     tcpd->fwd->lastacktime.secs=pinfo->fd->abs_ts.secs;
998     tcpd->fwd->lastacktime.nsecs=pinfo->fd->abs_ts.nsecs;
999
1000
1001     /* if there were any flags set for this segment we need to remember them
1002      * we only remember the flags for the very last segment though.
1003      */
1004     if(tcpd->ta){
1005         tcpd->fwd->lastsegmentflags=tcpd->ta->flags;
1006     } else {
1007         tcpd->fwd->lastsegmentflags=0;
1008     }
1009
1010
1011     /* remove all segments this ACKs and we dont need to keep around any more
1012      */
1013     ackcount=0;
1014     prevual = NULL;
1015     ual = tcpd->rev->segments;
1016     while(ual){
1017         tcp_unacked_t *tmpual;
1018
1019         /* If this ack matches the segment, process accordingly */
1020         if(ack==ual->nextseq){
1021             tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE, tcpd);
1022             tcpd->ta->frame_acked=ual->frame;
1023             nstime_delta(&tcpd->ta->ts, &pinfo->fd->abs_ts, &ual->ts);
1024         }
1025         /* If this acknowledges a segment prior to this one, leave this segment alone and move on */
1026         else if (GT_SEQ(ual->nextseq,ack)){
1027             prevual = ual;
1028             ual = ual->next;
1029             continue;
1030         }
1031
1032         /* This segment is old, or an exact match.  Delete the segment from the list */
1033         ackcount++;
1034         tmpual=ual->next;
1035
1036         if (tcpd->rev->scps_capable) {
1037           /* Track largest segment successfully sent for SNACK analysis*/
1038           if ((ual->nextseq - ual->seq) > tcpd->fwd->maxsizeacked){
1039             tcpd->fwd->maxsizeacked = (ual->nextseq - ual->seq);
1040           }
1041         }
1042
1043         if (!prevual){
1044             tcpd->rev->segments = tmpual;
1045             TCP_UNACKED_FREE(ual);
1046             ual = tmpual;
1047         }
1048         else{
1049             prevual->next = tmpual;
1050             TCP_UNACKED_FREE(ual);
1051             ual = tmpual;
1052         }
1053     }
1054
1055     /* how many bytes of data are there in flight after this frame
1056      * was sent
1057      */
1058     ual=tcpd->fwd->segments;
1059     if (tcp_track_bytes_in_flight && seglen!=0 && ual && tcpd->fwd->valid_bif) {
1060         guint32 first_seq, last_seq, in_flight;
1061
1062         first_seq = ual->seq - tcpd->fwd->base_seq;
1063         last_seq = ual->nextseq - tcpd->fwd->base_seq;
1064         while (ual) {
1065             if ((ual->nextseq-tcpd->fwd->base_seq)>last_seq) {
1066                 last_seq = ual->nextseq-tcpd->fwd->base_seq;
1067             }
1068             if ((ual->seq-tcpd->fwd->base_seq)<first_seq) {
1069                 first_seq = ual->seq-tcpd->fwd->base_seq;
1070             }
1071             ual = ual->next;
1072         }
1073         in_flight = last_seq-first_seq;
1074
1075         if (in_flight>0 && in_flight<2000000000) {
1076             if(!tcpd->ta){
1077                 tcp_analyze_get_acked_struct(pinfo->fd->num, TRUE, tcpd);
1078             }
1079             tcpd->ta->bytes_in_flight = in_flight;
1080         }
1081     }
1082
1083 }
1084
1085 /*
1086  * Prints results of the sequence number analysis concerning tcp segments
1087  * retransmitted or out-of-order
1088  */
1089 static void
1090 tcp_sequence_number_analysis_print_retransmission(packet_info * pinfo,
1091                           tvbuff_t * tvb,
1092                           proto_tree * flags_tree,
1093                           struct tcp_acked *ta
1094                           )
1095 {
1096     proto_item * flags_item;
1097
1098     /* TCP Rentransmission */
1099     if (ta->flags & TCP_A_RETRANSMISSION) {
1100         flags_item=proto_tree_add_none_format(flags_tree,
1101                                               hf_tcp_analysis_retransmission,
1102                                               tvb, 0, 0,
1103                                               "This frame is a (suspected) "
1104                                               "retransmission"
1105             );
1106         PROTO_ITEM_SET_GENERATED(flags_item);
1107         expert_add_info_format(pinfo, flags_item, PI_SEQUENCE, PI_NOTE,
1108                                "Retransmission (suspected)");
1109
1110         col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[TCP Retransmission] ");
1111
1112         if (ta->rto_ts.secs || ta->rto_ts.nsecs) {
1113             flags_item = proto_tree_add_time(flags_tree, hf_tcp_analysis_rto,
1114                                              tvb, 0, 0, &ta->rto_ts);
1115             PROTO_ITEM_SET_GENERATED(flags_item);
1116             flags_item=proto_tree_add_uint(flags_tree, hf_tcp_analysis_rto_frame,
1117                                            tvb, 0, 0, ta->rto_frame);
1118             PROTO_ITEM_SET_GENERATED(flags_item);
1119         }
1120     }
1121     /* TCP Fast Rentransmission */
1122     if (ta->flags & TCP_A_FAST_RETRANSMISSION) {
1123         flags_item=proto_tree_add_none_format(flags_tree,
1124                                               hf_tcp_analysis_fast_retransmission,
1125                                               tvb, 0, 0,
1126                                               "This frame is a (suspected) fast"
1127                                               " retransmission"
1128             );
1129         PROTO_ITEM_SET_GENERATED(flags_item);
1130         expert_add_info_format(pinfo, flags_item, PI_SEQUENCE, PI_WARN,
1131                                "Fast retransmission (suspected)");
1132         flags_item=proto_tree_add_none_format(flags_tree,
1133                                               hf_tcp_analysis_retransmission,
1134                                               tvb, 0, 0,
1135                                               "This frame is a (suspected) "
1136                                               "retransmission"
1137             );
1138         PROTO_ITEM_SET_GENERATED(flags_item);
1139         col_prepend_fence_fstr(pinfo->cinfo, COL_INFO,
1140                                "[TCP Fast Retransmission] ");
1141     }
1142     /* TCP Out-Of-Order */
1143     if (ta->flags & TCP_A_OUT_OF_ORDER) {
1144         flags_item=proto_tree_add_none_format(flags_tree,
1145                                               hf_tcp_analysis_out_of_order,
1146                                               tvb, 0, 0,
1147                                               "This frame is a (suspected) "
1148                                               "out-of-order segment"
1149             );
1150         PROTO_ITEM_SET_GENERATED(flags_item);
1151         expert_add_info_format(pinfo, flags_item, PI_SEQUENCE, PI_WARN,
1152                                "Out-Of-Order segment");
1153         col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[TCP Out-Of-Order] ");
1154     }
1155 }
1156
1157 /* Prints results of the sequence number analysis concerning reused ports */
1158 static void
1159 tcp_sequence_number_analysis_print_reused(packet_info * pinfo,
1160                       tvbuff_t * tvb,
1161                       proto_tree * flags_tree,
1162                       struct tcp_acked *ta
1163                       )
1164 {
1165     proto_item * flags_item;
1166
1167     /* TCP Ports Reused */
1168     if (ta->flags & TCP_A_REUSED_PORTS) {
1169         flags_item=proto_tree_add_none_format(flags_tree,
1170                                               hf_tcp_analysis_reused_ports,
1171                                               tvb, 0, 0,
1172                                               "A new tcp session is started with the same "
1173                                               "ports as an earlier session in this trace"
1174             );
1175         PROTO_ITEM_SET_GENERATED(flags_item);
1176         expert_add_info_format(pinfo, flags_item, PI_SEQUENCE, PI_NOTE,
1177                                "TCP Port numbers reused for new session");
1178         col_prepend_fence_fstr(pinfo->cinfo, COL_INFO,
1179                                "[TCP Port numbers reused] ");
1180     }
1181 }
1182
1183 /* Prints results of the sequence number analysis concerning lost tcp segments */
1184 static void
1185 tcp_sequence_number_analysis_print_lost(packet_info * pinfo,
1186                     tvbuff_t * tvb,
1187                     proto_tree * flags_tree,
1188                     struct tcp_acked *ta
1189                     )
1190 {
1191     proto_item * flags_item;
1192
1193     /* TCP Lost Segment */
1194     if (ta->flags & TCP_A_LOST_PACKET) {
1195         flags_item=proto_tree_add_none_format(flags_tree,
1196                                               hf_tcp_analysis_lost_packet,
1197                                               tvb, 0, 0,
1198                                               "A segment before this frame was "
1199                                               "lost"
1200             );
1201         PROTO_ITEM_SET_GENERATED(flags_item);
1202         expert_add_info_format(pinfo, flags_item, PI_SEQUENCE, PI_WARN,
1203                                "Previous segment lost (common at capture start)");
1204         col_prepend_fence_fstr(pinfo->cinfo, COL_INFO,
1205                                "[TCP Previous segment lost] ");
1206     }
1207     /* TCP Ack lost segment */
1208     if (ta->flags & TCP_A_ACK_LOST_PACKET) {
1209         flags_item=proto_tree_add_none_format(flags_tree,
1210                                               hf_tcp_analysis_ack_lost_packet,
1211                                               tvb, 0, 0,
1212                                               "This frame ACKs a segment we have "
1213                                               "not seen (lost?)"
1214             );
1215         PROTO_ITEM_SET_GENERATED(flags_item);
1216         expert_add_info_format(pinfo, flags_item, PI_SEQUENCE, PI_WARN,
1217                                "ACKed lost segment (common at capture start)");
1218         col_prepend_fence_fstr(pinfo->cinfo, COL_INFO,
1219                                "[TCP ACKed lost segment] ");
1220     }
1221 }
1222
1223 /* Prints results of the sequence number analysis concerning tcp window */
1224 static void
1225 tcp_sequence_number_analysis_print_window(packet_info * pinfo,
1226                       tvbuff_t * tvb,
1227                       proto_tree * flags_tree,
1228                       struct tcp_acked *ta
1229                       )
1230 {
1231     proto_item * flags_item;
1232
1233     /* TCP Window Update */
1234     if (ta->flags & TCP_A_WINDOW_UPDATE) {
1235         flags_item=proto_tree_add_none_format(flags_tree,
1236                                               hf_tcp_analysis_window_update,
1237                                               tvb, 0, 0,
1238                                               "This is a tcp window update"
1239             );
1240         PROTO_ITEM_SET_GENERATED(flags_item);
1241         expert_add_info_format(pinfo, flags_item, PI_SEQUENCE, PI_CHAT,
1242                                "Window update");
1243         col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[TCP Window Update] ");
1244     }
1245     /* TCP Full Window */
1246     if (ta->flags & TCP_A_WINDOW_FULL) {
1247         flags_item=proto_tree_add_none_format(flags_tree,
1248                                               hf_tcp_analysis_window_full,
1249                                               tvb, 0, 0,
1250                                               "The transmission window is now "
1251                                               "completely full"
1252             );
1253         PROTO_ITEM_SET_GENERATED(flags_item);
1254         expert_add_info_format(pinfo, flags_item, PI_SEQUENCE, PI_WARN,
1255                                "Window is full");
1256         col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[TCP Window Full] ");
1257     }
1258 }
1259
1260 /* Prints results of the sequence number analysis concerning tcp keepalive */
1261 static void
1262 tcp_sequence_number_analysis_print_keepalive(packet_info * pinfo,
1263                       tvbuff_t * tvb,
1264                       proto_tree * flags_tree,
1265                       struct tcp_acked *ta
1266                       )
1267 {
1268     proto_item * flags_item;
1269
1270     /*TCP Keep Alive */
1271     if (ta->flags & TCP_A_KEEP_ALIVE){
1272         flags_item=proto_tree_add_none_format(flags_tree,
1273                                               hf_tcp_analysis_keep_alive,
1274                                               tvb, 0, 0,
1275                                               "This is a TCP keep-alive segment"
1276             );
1277         PROTO_ITEM_SET_GENERATED(flags_item);
1278         expert_add_info_format(pinfo, flags_item, PI_SEQUENCE, PI_NOTE,
1279                                "Keep-Alive");
1280         col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[TCP Keep-Alive] ");
1281     }
1282     /* TCP Ack Keep Alive */
1283     if (ta->flags & TCP_A_KEEP_ALIVE_ACK) {
1284         flags_item=proto_tree_add_none_format(flags_tree,
1285                                               hf_tcp_analysis_keep_alive_ack,
1286                                               tvb, 0, 0,
1287                                               "This is an ACK to a TCP keep-alive "
1288                                               "segment"
1289             );
1290         PROTO_ITEM_SET_GENERATED(flags_item);
1291         expert_add_info_format(pinfo, flags_item, PI_SEQUENCE, PI_NOTE,
1292                                "Keep-Alive ACK");
1293         col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[TCP Keep-Alive ACK] ");
1294     }
1295 }
1296
1297 /* Prints results of the sequence number analysis concerning tcp duplicate ack */
1298 static void
1299 tcp_sequence_number_analysis_print_duplicate(packet_info * pinfo,
1300                           tvbuff_t * tvb,
1301                           proto_tree * flags_tree,
1302                           struct tcp_acked *ta,
1303                           proto_tree * tree
1304                         )
1305 {
1306     proto_item * flags_item;
1307
1308     /* TCP Duplicate ACK */
1309     if (ta->dupack_num) {
1310         if (ta->flags & TCP_A_DUPLICATE_ACK ) {
1311             flags_item=proto_tree_add_none_format(flags_tree,
1312                                                   hf_tcp_analysis_duplicate_ack,
1313                                                   tvb, 0, 0,
1314                                                   "This is a TCP duplicate ack"
1315                 );
1316             PROTO_ITEM_SET_GENERATED(flags_item);
1317             col_prepend_fence_fstr(pinfo->cinfo, COL_INFO,
1318                                    "[TCP Dup ACK %u#%u] ",
1319                                    ta->dupack_frame,
1320                                    ta->dupack_num
1321                 );
1322
1323         }
1324         flags_item=proto_tree_add_uint(tree, hf_tcp_analysis_duplicate_ack_num,
1325                                        tvb, 0, 0, ta->dupack_num);
1326         PROTO_ITEM_SET_GENERATED(flags_item);
1327         flags_item=proto_tree_add_uint(tree, hf_tcp_analysis_duplicate_ack_frame,
1328                                        tvb, 0, 0, ta->dupack_frame);
1329         PROTO_ITEM_SET_GENERATED(flags_item);
1330         expert_add_info_format(pinfo, flags_item, PI_SEQUENCE, PI_NOTE,
1331                                "Duplicate ACK (#%u)",
1332                                ta->dupack_num
1333             );
1334     }
1335 }
1336
1337 /* Prints results of the sequence number analysis concerning tcp zero window */
1338 static void
1339 tcp_sequence_number_analysis_print_zero_window(packet_info * pinfo,
1340                           tvbuff_t * tvb,
1341                           proto_tree * flags_tree,
1342                           struct tcp_acked *ta
1343                         )
1344 {
1345     proto_item * flags_item;
1346
1347     /* TCP Zero Window Probe */
1348     if (ta->flags & TCP_A_ZERO_WINDOW_PROBE) {
1349         flags_item=proto_tree_add_none_format(flags_tree,
1350                                               hf_tcp_analysis_zero_window_probe,
1351                                               tvb, 0, 0,
1352                                               "This is a TCP zero-window-probe"
1353             );
1354         PROTO_ITEM_SET_GENERATED(flags_item);
1355         expert_add_info_format(pinfo, flags_item, PI_SEQUENCE, PI_NOTE,
1356                                "Zero window probe");
1357         col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[TCP ZeroWindowProbe] ");
1358     }
1359     /* TCP Zero Window */
1360     if (ta->flags&TCP_A_ZERO_WINDOW) {
1361         flags_item=proto_tree_add_none_format(flags_tree,
1362                                               hf_tcp_analysis_zero_window,
1363                                               tvb, 0, 0,
1364                                               "This is a ZeroWindow segment"
1365             );
1366         PROTO_ITEM_SET_GENERATED(flags_item);
1367         expert_add_info_format(pinfo, flags_item, PI_SEQUENCE, PI_WARN,
1368                                "Zero window");
1369         col_prepend_fence_fstr(pinfo->cinfo, COL_INFO, "[TCP ZeroWindow] ");
1370     }
1371     /* TCP Zero Window Probe Ack */
1372     if (ta->flags & TCP_A_ZERO_WINDOW_PROBE_ACK) {
1373         flags_item=proto_tree_add_none_format(flags_tree,
1374                                               hf_tcp_analysis_zero_window_probe_ack,
1375                                               tvb, 0, 0,
1376                                               "This is an ACK to a TCP zero-window-probe"
1377             );
1378         PROTO_ITEM_SET_GENERATED(flags_item);
1379         expert_add_info_format(pinfo, flags_item, PI_SEQUENCE, PI_NOTE,
1380                                "Zero window probe ACK");
1381         col_prepend_fence_fstr(pinfo->cinfo, COL_INFO,
1382                                "[TCP ZeroWindowProbeAck] ");
1383     }
1384 }
1385
1386
1387 /* Prints results of the sequence number analysis concerning how many bytes of data are in flight */
1388 static void
1389 tcp_sequence_number_analysis_print_bytes_in_flight(packet_info * pinfo _U_,
1390                           tvbuff_t * tvb _U_,
1391                           proto_tree * flags_tree _U_,
1392                           struct tcp_acked *ta
1393                         )
1394 {
1395     proto_item * flags_item;
1396
1397     if (tcp_track_bytes_in_flight) {
1398         flags_item=proto_tree_add_uint(flags_tree,
1399                                        hf_tcp_analysis_bytes_in_flight,
1400                                        tvb, 0, 0, ta->bytes_in_flight);
1401
1402         PROTO_ITEM_SET_GENERATED(flags_item);
1403     }
1404 }
1405
1406 static void
1407 tcp_print_sequence_number_analysis(packet_info *pinfo, tvbuff_t *tvb, proto_tree *parent_tree, struct tcp_analysis *tcpd)
1408 {
1409     struct tcp_acked *ta = NULL;
1410     proto_item *item;
1411     proto_tree *tree;
1412     proto_tree *flags_tree=NULL;
1413
1414     if (!tcpd) {
1415         return;
1416     }
1417     if(!tcpd->ta){
1418         tcp_analyze_get_acked_struct(pinfo->fd->num, FALSE, tcpd);
1419     }
1420     ta=tcpd->ta;
1421     if(!ta){
1422         return;
1423     }
1424
1425     item=proto_tree_add_text(parent_tree, tvb, 0, 0, "SEQ/ACK analysis");
1426     PROTO_ITEM_SET_GENERATED(item);
1427     tree=proto_item_add_subtree(item, ett_tcp_analysis);
1428
1429     /* encapsulate all proto_tree_add_xxx in ifs so we only print what
1430        data we actually have */
1431     if(ta->frame_acked){
1432         item = proto_tree_add_uint(tree, hf_tcp_analysis_acks_frame,
1433             tvb, 0, 0, ta->frame_acked);
1434             PROTO_ITEM_SET_GENERATED(item);
1435
1436         /* only display RTT if we actually have something we are acking */
1437         if( ta->ts.secs || ta->ts.nsecs ){
1438             item = proto_tree_add_time(tree, hf_tcp_analysis_ack_rtt,
1439             tvb, 0, 0, &ta->ts);
1440                 PROTO_ITEM_SET_GENERATED(item);
1441         }
1442     }
1443
1444     if(ta->bytes_in_flight) {
1445         /* print results for amount of data in flight */
1446         tcp_sequence_number_analysis_print_bytes_in_flight(pinfo, tvb, tree, ta);
1447     }
1448
1449     if(ta->flags){
1450         item = proto_tree_add_item(tree, hf_tcp_analysis_flags, tvb, 0, 0, FALSE);
1451         PROTO_ITEM_SET_GENERATED(item);
1452         flags_tree=proto_item_add_subtree(item, ett_tcp_analysis);
1453
1454         /* print results for reused tcp ports */
1455         tcp_sequence_number_analysis_print_reused(pinfo, tvb, flags_tree, ta);
1456
1457         /* print results for retransmission and out-of-order segments */
1458         tcp_sequence_number_analysis_print_retransmission(pinfo, tvb, flags_tree, ta);
1459
1460         /* print results for lost tcp segments */
1461         tcp_sequence_number_analysis_print_lost(pinfo, tvb, flags_tree, ta);
1462
1463         /* print results for tcp window information */
1464         tcp_sequence_number_analysis_print_window(pinfo, tvb, flags_tree, ta);
1465
1466         /* print results for tcp keep alive information */
1467         tcp_sequence_number_analysis_print_keepalive(pinfo, tvb, flags_tree, ta);
1468
1469         /* print results for tcp duplicate acks */
1470         tcp_sequence_number_analysis_print_duplicate(pinfo, tvb, flags_tree, ta, tree);
1471
1472         /* print results for tcp zero window  */
1473         tcp_sequence_number_analysis_print_zero_window(pinfo, tvb, flags_tree, ta);
1474
1475     }
1476
1477 }
1478
1479 static void
1480 print_tcp_fragment_tree(fragment_data *ipfd_head, proto_tree *tree, proto_tree *tcp_tree, packet_info *pinfo, tvbuff_t *next_tvb)
1481 {
1482     proto_item *tcp_tree_item, *frag_tree_item;
1483
1484     /*
1485      * The subdissector thought it was completely
1486      * desegmented (although the stuff at the
1487      * end may, in turn, require desegmentation),
1488      * so we show a tree with all segments.
1489      */
1490     show_fragment_tree(ipfd_head, &tcp_segment_items,
1491         tree, pinfo, next_tvb, &frag_tree_item);
1492     /*
1493      * The toplevel fragment subtree is now
1494      * behind all desegmented data; move it
1495      * right behind the TCP tree.
1496      */
1497     tcp_tree_item = proto_tree_get_parent(tcp_tree);
1498     if(frag_tree_item && tcp_tree_item) {
1499         proto_tree_move_item(tree, tcp_tree_item, frag_tree_item);
1500     }
1501 }
1502
1503 /* **************************************************************************
1504  * End of tcp sequence number analysis
1505  * **************************************************************************/
1506
1507
1508 /* Minimum TCP header length. */
1509 #define TCPH_MIN_LEN            20
1510
1511 /* Desegmentation of TCP streams */
1512 /* table to hold defragmented TCP streams */
1513 static GHashTable *tcp_fragment_table = NULL;
1514 static void
1515 tcp_fragment_init(void)
1516 {
1517     fragment_table_init(&tcp_fragment_table);
1518 }
1519
1520 /* functions to trace tcp segments */
1521 /* Enable desegmenting of TCP streams */
1522 static gboolean tcp_desegment = TRUE;
1523
1524 static void
1525 desegment_tcp(tvbuff_t *tvb, packet_info *pinfo, int offset,
1526               guint32 seq, guint32 nxtseq,
1527               guint32 sport, guint32 dport,
1528               proto_tree *tree, proto_tree *tcp_tree,
1529               struct tcp_analysis *tcpd)
1530 {
1531     struct tcpinfo *tcpinfo = pinfo->private_data;
1532     fragment_data *ipfd_head;
1533     int last_fragment_len;
1534     gboolean must_desegment;
1535     gboolean called_dissector;
1536     int another_pdu_follows;
1537     int deseg_offset;
1538     guint32 deseg_seq;
1539     gint nbytes;
1540     proto_item *item;
1541     struct tcp_multisegment_pdu *msp;
1542     gboolean cleared_writable = col_get_writable(pinfo->cinfo);
1543
1544 again:
1545     ipfd_head=NULL;
1546     last_fragment_len=0;
1547     must_desegment = FALSE;
1548     called_dissector = FALSE;
1549     another_pdu_follows = 0;
1550     msp=NULL;
1551
1552     /*
1553      * Initialize these to assume no desegmentation.
1554      * If that's not the case, these will be set appropriately
1555      * by the subdissector.
1556      */
1557     pinfo->desegment_offset = 0;
1558     pinfo->desegment_len = 0;
1559
1560     /*
1561      * Initialize this to assume that this segment will just be
1562      * added to the middle of a desegmented chunk of data, so
1563      * that we should show it all as data.
1564      * If that's not the case, it will be set appropriately.
1565      */
1566     deseg_offset = offset;
1567
1568     /* find the most previous PDU starting before this sequence number */
1569     if (tcpd) {
1570         msp = se_tree_lookup32_le(tcpd->fwd->multisegment_pdus, seq-1);
1571     }
1572     if(msp && msp->seq<=seq && msp->nxtpdu>seq){
1573         int len;
1574
1575         if(!pinfo->fd->flags.visited){
1576             msp->last_frame=pinfo->fd->num;
1577             msp->last_frame_time=pinfo->fd->abs_ts;
1578         }
1579
1580         /* OK, this PDU was found, which means the segment continues
1581            a higher-level PDU and that we must desegment it.
1582         */
1583         if(msp->flags&MSP_FLAGS_REASSEMBLE_ENTIRE_SEGMENT){
1584             /* The dissector asked for the entire segment */
1585             len=tvb_length_remaining(tvb, offset);
1586         } else {
1587             len=MIN(nxtseq, msp->nxtpdu) - seq;
1588         }
1589         last_fragment_len = len;
1590
1591         ipfd_head = fragment_add(tvb, offset, pinfo, msp->first_frame,
1592             tcp_fragment_table,
1593             seq - msp->seq,
1594             len,
1595             (LT_SEQ (nxtseq,msp->nxtpdu)) );
1596
1597         if(msp->flags&MSP_FLAGS_REASSEMBLE_ENTIRE_SEGMENT){
1598             msp->flags&=(~MSP_FLAGS_REASSEMBLE_ENTIRE_SEGMENT);
1599
1600             /* If we consumed the entire segment there is no
1601              * other pdu starting anywhere inside this segment.
1602              * So update nxtpdu to point at least to the start
1603              * of the next segment.
1604              * (If the subdissector asks for even more data we
1605              * will advance nxtpdu even furhter later down in
1606              * the code.)
1607              */
1608             msp->nxtpdu=nxtseq;
1609         }
1610
1611         if( (msp->nxtpdu<nxtseq)
1612         &&  (msp->nxtpdu>=seq)
1613         &&  (len>0) ){
1614             another_pdu_follows=msp->nxtpdu-seq;
1615         }
1616     } else {
1617         /* This segment was not found in our table, so it doesn't
1618            contain a continuation of a higher-level PDU.
1619            Call the normal subdissector.
1620         */
1621
1622         /*
1623          * Supply the sequence number of this segment. We set this here
1624          * because this segment could be after another in the same packet,
1625          * in which case seq was incremented at the end of the loop.
1626          */
1627         tcpinfo->seq = seq;
1628
1629         process_tcp_payload(tvb, offset, pinfo, tree, tcp_tree,
1630                 sport, dport, 0, 0, FALSE, tcpd);
1631         called_dissector = TRUE;
1632
1633         /* Did the subdissector ask us to desegment some more data
1634            before it could handle the packet?
1635            If so we have to create some structures in our table but
1636            this is something we only do the first time we see this
1637            packet.
1638         */
1639         if(pinfo->desegment_len) {
1640             if (!pinfo->fd->flags.visited)
1641                 must_desegment = TRUE;
1642
1643             /*
1644              * Set "deseg_offset" to the offset in "tvb"
1645              * of the first byte of data that the
1646              * subdissector didn't process.
1647              */
1648             deseg_offset = offset + pinfo->desegment_offset;
1649         }
1650
1651         /* Either no desegmentation is necessary, or this is
1652            segment contains the beginning but not the end of
1653            a higher-level PDU and thus isn't completely
1654            desegmented.
1655         */
1656         ipfd_head = NULL;
1657     }
1658
1659
1660     /* is it completely desegmented? */
1661     if(ipfd_head){
1662         /*
1663          * Yes, we think it is.
1664          * We only call subdissector for the last segment.
1665          * Note that the last segment may include more than what
1666          * we needed.
1667          */
1668         if(ipfd_head->reassembled_in==pinfo->fd->num){
1669             /*
1670              * OK, this is the last segment.
1671              * Let's call the subdissector with the desegmented
1672              * data.
1673              */
1674             tvbuff_t *next_tvb;
1675             int old_len;
1676
1677             /* create a new TVB structure for desegmented data */
1678             next_tvb = tvb_new_child_real_data(tvb, ipfd_head->data,
1679                     ipfd_head->datalen, ipfd_head->datalen);
1680
1681
1682             /* add desegmented data to the data source list */
1683             add_new_data_source(pinfo, next_tvb, "Reassembled TCP");
1684
1685             /*
1686              * Supply the sequence number of the first of the
1687              * reassembled bytes.
1688              */
1689             tcpinfo->seq = msp->seq;
1690
1691             /* indicate that this is reassembled data */
1692             tcpinfo->is_reassembled = TRUE;
1693
1694             /* call subdissector */
1695             process_tcp_payload(next_tvb, 0, pinfo, tree,
1696                 tcp_tree, sport, dport, 0, 0, FALSE, tcpd);
1697             called_dissector = TRUE;
1698
1699             /*
1700              * OK, did the subdissector think it was completely
1701              * desegmented, or does it think we need even more
1702              * data?
1703              */
1704             old_len=(int)(tvb_reported_length(next_tvb)-last_fragment_len);
1705             if(pinfo->desegment_len &&
1706                 pinfo->desegment_offset<=old_len){
1707                 /*
1708                  * "desegment_len" isn't 0, so it needs more
1709                  * data for something - and "desegment_offset"
1710                  * is before "old_len", so it needs more data
1711                  * to dissect the stuff we thought was
1712                  * completely desegmented (as opposed to the
1713                  * stuff at the beginning being completely
1714                  * desegmented, but the stuff at the end
1715                  * being a new higher-level PDU that also
1716                  * needs desegmentation).
1717                  */
1718                 fragment_set_partial_reassembly(pinfo,msp->first_frame,tcp_fragment_table);
1719                 /* Update msp->nxtpdu to point to the new next
1720                  * pdu boundary.
1721                  */
1722                 if(pinfo->desegment_len==DESEGMENT_ONE_MORE_SEGMENT){
1723                     /* We want reassembly of at least one
1724                      * more segment so set the nxtpdu
1725                      * boundary to one byte into the next
1726                      * segment.
1727                      * This means that the next segment
1728                      * will complete reassembly even if it
1729                      * is only one single byte in length.
1730                      */
1731                     msp->nxtpdu=seq+tvb_reported_length_remaining(tvb, offset) + 1;
1732                     msp->flags|=MSP_FLAGS_REASSEMBLE_ENTIRE_SEGMENT;
1733                 } else {
1734                     msp->nxtpdu=seq + last_fragment_len + pinfo->desegment_len;
1735                 }
1736                 /* Since we need at least some more data
1737                  * there can be no pdu following in the
1738                  * tail of this segment.
1739                  */
1740                 another_pdu_follows=0;
1741                 offset += last_fragment_len;
1742                 seq += last_fragment_len;
1743                 if (tvb_length_remaining(tvb, offset) > 0)
1744                     goto again;
1745             } else {
1746                 /*
1747                  * Show the stuff in this TCP segment as
1748                  * just raw TCP segment data.
1749                  */
1750                 nbytes = another_pdu_follows > 0
1751                     ? another_pdu_follows
1752                     : tvb_reported_length_remaining(tvb, offset);
1753                 proto_tree_add_text(tcp_tree, tvb, offset, nbytes,
1754                     "TCP segment data (%u byte%s)", nbytes,
1755                     plurality(nbytes, "", "s"));
1756
1757                 print_tcp_fragment_tree(ipfd_head, tree, tcp_tree, pinfo, next_tvb);
1758
1759                 /* Did the subdissector ask us to desegment
1760                    some more data?  This means that the data
1761                    at the beginning of this segment completed
1762                    a higher-level PDU, but the data at the
1763                    end of this segment started a higher-level
1764                    PDU but didn't complete it.
1765
1766                    If so, we have to create some structures
1767                    in our table, but this is something we
1768                    only do the first time we see this packet.
1769                 */
1770                 if(pinfo->desegment_len) {
1771                     if (!pinfo->fd->flags.visited)
1772                         must_desegment = TRUE;
1773
1774                     /* The stuff we couldn't dissect
1775                        must have come from this segment,
1776                        so it's all in "tvb".
1777
1778                        "pinfo->desegment_offset" is
1779                        relative to the beginning of
1780                        "next_tvb"; we want an offset
1781                        relative to the beginning of "tvb".
1782
1783                        First, compute the offset relative
1784                        to the *end* of "next_tvb" - i.e.,
1785                        the number of bytes before the end
1786                        of "next_tvb" at which the
1787                        subdissector stopped.  That's the
1788                        length of "next_tvb" minus the
1789                        offset, relative to the beginning
1790                        of "next_tvb, at which the
1791                        subdissector stopped.
1792                     */
1793                     deseg_offset =
1794                         ipfd_head->datalen - pinfo->desegment_offset;
1795
1796                     /* "tvb" and "next_tvb" end at the
1797                        same byte of data, so the offset
1798                        relative to the end of "next_tvb"
1799                        of the byte at which we stopped
1800                        is also the offset relative to
1801                        the end of "tvb" of the byte at
1802                        which we stopped.
1803
1804                        Convert that back into an offset
1805                        relative to the beginninng of
1806                        "tvb", by taking the length of
1807                        "tvb" and subtracting the offset
1808                        relative to the end.
1809                     */
1810                     deseg_offset=tvb_reported_length(tvb) - deseg_offset;
1811                 }
1812             }
1813         }
1814     }
1815
1816     if (must_desegment) {
1817         /* If the dissector requested "reassemble until FIN"
1818          * just set this flag for the flow and let reassembly
1819          * proceed at normal.  We will check/pick up these
1820          * reassembled PDUs later down in dissect_tcp() when checking
1821          * for the FIN flag.
1822          */
1823         if(tcpd && pinfo->desegment_len==DESEGMENT_UNTIL_FIN) {
1824         tcpd->fwd->flags|=TCP_FLOW_REASSEMBLE_UNTIL_FIN;
1825         }
1826         /*
1827          * The sequence number at which the stuff to be desegmented
1828          * starts is the sequence number of the byte at an offset
1829          * of "deseg_offset" into "tvb".
1830          *
1831          * The sequence number of the byte at an offset of "offset"
1832          * is "seq", i.e. the starting sequence number of this
1833          * segment, so the sequence number of the byte at
1834          * "deseg_offset" is "seq + (deseg_offset - offset)".
1835          */
1836         deseg_seq = seq + (deseg_offset - offset);
1837
1838         if(tcpd && ((nxtseq - deseg_seq) <= 1024*1024)
1839         &&  (!pinfo->fd->flags.visited) ){
1840         if(pinfo->desegment_len==DESEGMENT_ONE_MORE_SEGMENT){
1841             /* The subdissector asked to reassemble using the
1842              * entire next segment.
1843              * Just ask reassembly for one more byte
1844              * but set this msp flag so we can pick it up
1845              * above.
1846              */
1847             msp = pdu_store_sequencenumber_of_next_pdu(pinfo,
1848                 deseg_seq, nxtseq+1, tcpd->fwd->multisegment_pdus);
1849             msp->flags|=MSP_FLAGS_REASSEMBLE_ENTIRE_SEGMENT;
1850         } else {
1851             msp = pdu_store_sequencenumber_of_next_pdu(pinfo,
1852                 deseg_seq, nxtseq+pinfo->desegment_len, tcpd->fwd->multisegment_pdus);
1853         }
1854
1855         /* add this segment as the first one for this new pdu */
1856         fragment_add(tvb, deseg_offset, pinfo, msp->first_frame,
1857             tcp_fragment_table,
1858             0,
1859             nxtseq - deseg_seq,
1860             LT_SEQ(nxtseq, msp->nxtpdu));
1861         }
1862     }
1863
1864     if (!called_dissector || pinfo->desegment_len != 0) {
1865         if (ipfd_head != NULL && ipfd_head->reassembled_in != 0 &&
1866             !(ipfd_head->flags & FD_PARTIAL_REASSEMBLY)) {
1867             /*
1868              * We know what frame this PDU is reassembled in;
1869              * let the user know.
1870              */
1871             item=proto_tree_add_uint(tcp_tree, hf_tcp_reassembled_in,
1872                 tvb, 0, 0, ipfd_head->reassembled_in);
1873             PROTO_ITEM_SET_GENERATED(item);
1874         }
1875
1876         /*
1877          * Either we didn't call the subdissector at all (i.e.,
1878          * this is a segment that contains the middle of a
1879          * higher-level PDU, but contains neither the beginning
1880          * nor the end), or the subdissector couldn't dissect it
1881          * all, as some data was missing (i.e., it set
1882          * "pinfo->desegment_len" to the amount of additional
1883          * data it needs).
1884          */
1885         if (pinfo->desegment_offset == 0) {
1886             /*
1887              * It couldn't, in fact, dissect any of it (the
1888              * first byte it couldn't dissect is at an offset
1889              * of "pinfo->desegment_offset" from the beginning
1890              * of the payload, and that's 0).
1891              * Just mark this as TCP.
1892              */
1893             col_set_str(pinfo->cinfo, COL_PROTOCOL, "TCP");
1894             col_set_str(pinfo->cinfo, COL_INFO, "[TCP segment of a reassembled PDU]");
1895         }
1896
1897         /*
1898          * Show what's left in the packet as just raw TCP segment
1899          * data.
1900          * XXX - remember what protocol the last subdissector
1901          * was, and report it as a continuation of that, instead?
1902          */
1903         nbytes = tvb_reported_length_remaining(tvb, deseg_offset);
1904         proto_tree_add_text(tcp_tree, tvb, deseg_offset, -1,
1905             "TCP segment data (%u byte%s)", nbytes,
1906             plurality(nbytes, "", "s"));
1907     }
1908     pinfo->can_desegment=0;
1909     pinfo->desegment_offset = 0;
1910     pinfo->desegment_len = 0;
1911
1912     if(another_pdu_follows){
1913         /* there was another pdu following this one. */
1914         pinfo->can_desegment=2;
1915         /* we also have to prevent the dissector from changing the
1916          * PROTOCOL and INFO colums since what follows may be an
1917          * incomplete PDU and we dont want it be changed back from
1918          *  <Protocol>   to <TCP>
1919          * XXX There is no good way to block the PROTOCOL column
1920          * from being changed yet so we set the entire row unwritable.
1921          * The flag cleared_writable stores the initial state.
1922          */
1923         col_set_fence(pinfo->cinfo, COL_INFO);
1924         cleared_writable |= col_get_writable(pinfo->cinfo);
1925         col_set_writable(pinfo->cinfo, FALSE);
1926         offset += another_pdu_follows;
1927         seq += another_pdu_follows;
1928         goto again;
1929     } else {
1930         /* remove any blocking set above otherwise the
1931          * proto,colinfo tap will break
1932          */
1933         if(cleared_writable){
1934             col_set_writable(pinfo->cinfo, TRUE);
1935         }
1936     }
1937 }
1938
1939 /*
1940  * Loop for dissecting PDUs within a TCP stream; assumes that a PDU
1941  * consists of a fixed-length chunk of data that contains enough information
1942  * to determine the length of the PDU, followed by rest of the PDU.
1943  *
1944  * The first three arguments are the arguments passed to the dissector
1945  * that calls this routine.
1946  *
1947  * "proto_desegment" is the dissector's flag controlling whether it should
1948  * desegment PDUs that cross TCP segment boundaries.
1949  *
1950  * "fixed_len" is the length of the fixed-length part of the PDU.
1951  *
1952  * "get_pdu_len()" is a routine called to get the length of the PDU from
1953  * the fixed-length part of the PDU; it's passed "pinfo", "tvb" and "offset".
1954  *
1955  * "dissect_pdu()" is the routine to dissect a PDU.
1956  */
1957 void
1958 tcp_dissect_pdus(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
1959                  gboolean proto_desegment, guint fixed_len,
1960                  guint (*get_pdu_len)(packet_info *, tvbuff_t *, int),
1961                  dissector_t dissect_pdu)
1962 {
1963     volatile int offset = 0;
1964     int offset_before;
1965     guint length_remaining;
1966     guint plen;
1967     guint length;
1968     tvbuff_t *next_tvb;
1969     proto_item *item=NULL;
1970     void *pd_save;
1971
1972     while (tvb_reported_length_remaining(tvb, offset) != 0) {
1973         /*
1974          * We use "tvb_ensure_length_remaining()" to make sure there actually
1975          * *is* data remaining.  The protocol we're handling could conceivably
1976          * consists of a sequence of fixed-length PDUs, and therefore the
1977          * "get_pdu_len" routine might not actually fetch anything from
1978          * the tvbuff, and thus might not cause an exception to be thrown if
1979          * we've run past the end of the tvbuff.
1980          *
1981          * This means we're guaranteed that "length_remaining" is positive.
1982          */
1983         length_remaining = tvb_ensure_length_remaining(tvb, offset);
1984
1985         /*
1986          * Can we do reassembly?
1987          */
1988         if (proto_desegment && pinfo->can_desegment) {
1989             /*
1990              * Yes - is the fixed-length part of the PDU split across segment
1991              * boundaries?
1992              */
1993             if (length_remaining < fixed_len) {
1994                 /*
1995                  * Yes.  Tell the TCP dissector where the data for this message
1996                  * starts in the data it handed us, and how many more bytes we
1997                  * need, and return.
1998                  */
1999                 pinfo->desegment_offset = offset;
2000                 pinfo->desegment_len = DESEGMENT_ONE_MORE_SEGMENT;
2001                 return;
2002             }
2003         }
2004
2005         /*
2006          * Get the length of the PDU.
2007          */
2008         plen = (*get_pdu_len)(pinfo, tvb, offset);
2009         if (plen < fixed_len) {
2010             /*
2011              * Either:
2012              *
2013              *  1) the length value extracted from the fixed-length portion
2014              *     doesn't include the fixed-length portion's length, and
2015              *     was so large that, when the fixed-length portion's
2016              *     length was added to it, the total length overflowed;
2017              *
2018              *  2) the length value extracted from the fixed-length portion
2019              *     includes the fixed-length portion's length, and the value
2020              *     was less than the fixed-length portion's length, i.e. it
2021              *     was bogus.
2022              *
2023              * Report this as a bounds error.
2024              */
2025             show_reported_bounds_error(tvb, pinfo, tree);
2026             return;
2027         }
2028
2029         /* 
2030          * Do not display the the PDU length if it crosses the boundary of the 
2031          * packet and no more packets are available
2032          */
2033         if ( length_remaining >= plen || pinfo->fd->next != NULL )
2034         {
2035                 /*
2036                  * Display the PDU length as a field
2037                  */
2038                 item=proto_tree_add_uint(pinfo->tcp_tree, hf_tcp_pdu_size, 
2039                                 tvb, offset, plen, plen);
2040                 PROTO_ITEM_SET_GENERATED(item);
2041         }else{
2042                 item = proto_tree_add_text(pinfo->tcp_tree, tvb, offset, -1, 
2043                         "PDU Size: %u cut short at %u",plen,length_remaining);
2044                 PROTO_ITEM_SET_GENERATED(item);
2045         }
2046
2047
2048         /* give a hint to TCP where the next PDU starts
2049          * so that it can attempt to find it in case it starts
2050          * somewhere in the middle of a segment.
2051          */
2052         if(!pinfo->fd->flags.visited && tcp_analyze_seq){
2053             guint remaining_bytes;
2054             remaining_bytes=tvb_reported_length_remaining(tvb, offset);
2055             if(plen>remaining_bytes){
2056                 pinfo->want_pdu_tracking=2;
2057                 pinfo->bytes_until_next_pdu=plen-remaining_bytes;
2058             }
2059         }
2060
2061         /*
2062          * Can we do reassembly?
2063          */
2064         if (proto_desegment && pinfo->can_desegment) {
2065             /*
2066              * Yes - is the PDU split across segment boundaries?
2067              */
2068             if (length_remaining < plen) {
2069                 /*
2070                  * Yes.  Tell the TCP dissector where the data for this message
2071                  * starts in the data it handed us, and how many more bytes we
2072                  * need, and return.
2073                  */
2074                 pinfo->desegment_offset = offset;
2075                 pinfo->desegment_len = plen - length_remaining;
2076                 return;
2077             }
2078         }
2079
2080         /*
2081          * Construct a tvbuff containing the amount of the payload we have
2082          * available.  Make its reported length the amount of data in the PDU.
2083          *
2084          * XXX - if reassembly isn't enabled. the subdissector will throw a
2085          * BoundsError exception, rather than a ReportedBoundsError exception.
2086          * We really want a tvbuff where the length is "length", the reported
2087          * length is "plen", and the "if the snapshot length were infinite"
2088          * length is the minimum of the reported length of the tvbuff handed
2089          * to us and "plen", with a new type of exception thrown if the offset
2090          * is within the reported length but beyond that third length, with
2091          * that exception getting the "Unreassembled Packet" error.
2092          */
2093         length = length_remaining;
2094         if (length > plen)
2095             length = plen;
2096         next_tvb = tvb_new_subset(tvb, offset, length, plen);
2097
2098         /*
2099          * Dissect the PDU.
2100          *
2101          * Catch the ReportedBoundsError exception; if this particular message
2102          * happens to get a ReportedBoundsError exception, that doesn't mean
2103          * that we should stop dissecting PDUs within this frame or chunk of
2104          * reassembled data.
2105          *
2106          * If it gets a BoundsError, we can stop, as there's nothing more to
2107          * see, so we just re-throw it.
2108          */
2109         pd_save = pinfo->private_data;
2110         TRY {
2111             (*dissect_pdu)(next_tvb, pinfo, tree);
2112         }
2113         CATCH(BoundsError) {
2114             RETHROW;
2115         }
2116         CATCH(ReportedBoundsError) {
2117             /*  Restore the private_data structure in case one of the
2118              *  called dissectors modified it (and, due to the exception,
2119              *  was unable to restore it).
2120              */
2121             pinfo->private_data = pd_save;
2122             show_reported_bounds_error(tvb, pinfo, tree);
2123         }
2124         ENDTRY;
2125
2126         /*
2127          * Step to the next PDU.
2128          * Make sure we don't overflow.
2129          */
2130         offset_before = offset;
2131         offset += plen;
2132         if (offset <= offset_before)
2133             break;
2134     }
2135 }
2136
2137 static void
2138 tcp_info_append_uint(packet_info *pinfo, const char *abbrev, guint32 val)
2139 {
2140     col_append_fstr(pinfo->cinfo, COL_INFO, " %s=%u", abbrev, val);
2141 }
2142
2143 /* Supports the reporting the contents of a parsed SCPS capabilities vector */
2144 static void
2145 tcp_info_append_str(packet_info *pinfo, const char *abbrev, const char *val)
2146 {
2147     col_append_fstr(pinfo->cinfo, COL_INFO, " %s[%s]", abbrev, val);
2148 }
2149
2150
2151 static void
2152 dissect_tcpopt_sack_perm(const ip_tcp_opt *optp _U_, tvbuff_t *tvb,
2153     int offset, guint optlen, packet_info *pinfo, proto_tree *opt_tree)
2154 {
2155     proto_item *hidden_item;
2156     hidden_item = proto_tree_add_boolean(opt_tree, hf_tcp_option_sack_perm, tvb, offset,
2157                                          optlen, TRUE);
2158     tcp_info_append_uint(pinfo, "SACK_PERM", TRUE);
2159 }
2160
2161 static void
2162 dissect_tcpopt_maxseg(const ip_tcp_opt *optp, tvbuff_t *tvb,
2163     int offset, guint optlen, packet_info *pinfo, proto_tree *opt_tree)
2164 {
2165     proto_item *hidden_item;
2166     guint16 mss;
2167
2168     mss = tvb_get_ntohs(tvb, offset + 2);
2169     hidden_item = proto_tree_add_boolean(opt_tree, hf_tcp_option_mss, tvb, offset,
2170                                          optlen, TRUE);
2171     PROTO_ITEM_SET_HIDDEN(hidden_item);
2172     proto_tree_add_uint_format(opt_tree, hf_tcp_option_mss_val, tvb, offset,
2173                                optlen, mss, "%s: %u bytes", optp->name, mss);
2174     tcp_info_append_uint(pinfo, "MSS", mss);
2175 }
2176
2177 /* The window scale extension is defined in RFC 1323 */
2178 static void
2179 dissect_tcpopt_wscale(const ip_tcp_opt *optp _U_, tvbuff_t *tvb,
2180     int offset, guint optlen _U_, packet_info *pinfo, proto_tree *opt_tree)
2181 {
2182     guint8 val, shift;
2183     proto_item *wscale_pi, *gen_pi;
2184     proto_tree *wscale_tree;
2185     struct tcp_analysis *tcpd=NULL;
2186
2187     tcpd=get_tcp_conversation_data(NULL,pinfo);
2188
2189     wscale_pi = proto_tree_add_text(opt_tree, tvb, offset, 3, "Window scale: ");
2190     wscale_tree = proto_item_add_subtree(wscale_pi, ett_tcp_option_wscale);
2191
2192     proto_tree_add_item(wscale_tree, hf_tcp_option_kind, tvb, offset, 1, ENC_NA);
2193     offset += 1;
2194
2195     proto_tree_add_item(wscale_tree, hf_tcp_option_len, tvb, offset, 1, ENC_NA);
2196     offset += 1;
2197
2198     proto_tree_add_item(wscale_tree, hf_tcp_option_wscale_shift, tvb, offset, 1,
2199                         ENC_NA);
2200     shift = tvb_get_guint8(tvb, offset);
2201
2202     gen_pi = proto_tree_add_uint(wscale_tree, hf_tcp_option_wscale_multiplier, tvb,
2203                                  offset, 1, 1 << shift);
2204     PROTO_ITEM_SET_GENERATED(gen_pi);
2205     val = tvb_get_guint8(tvb, offset);
2206
2207     proto_item_append_text(wscale_pi, "%u (multiply by %u)", val, 1 << shift);
2208
2209     tcp_info_append_uint(pinfo, "WS", 1 << shift);
2210
2211     if(!pinfo->fd->flags.visited && tcp_analyze_seq && tcp_window_scaling){
2212         pdu_store_window_scale_option(shift, tcpd);
2213     }
2214 }
2215
2216 static void
2217 dissect_tcpopt_sack(const ip_tcp_opt *optp, tvbuff_t *tvb,
2218     int offset, guint optlen, packet_info *pinfo, proto_tree *opt_tree)
2219 {
2220     proto_tree *field_tree = NULL;
2221     proto_item *tf=NULL;
2222     proto_item *hidden_item;
2223     guint32 leftedge, rightedge;
2224     struct tcp_analysis *tcpd=NULL;
2225     guint32 base_ack=0;
2226
2227     if(tcp_analyze_seq && tcp_relative_seq){
2228         /* find(or create if needed) the conversation for this tcp session */
2229         tcpd=get_tcp_conversation_data(NULL,pinfo);
2230
2231         if (tcpd) {
2232             base_ack=tcpd->rev->base_seq;
2233         }
2234     }
2235
2236     tf = proto_tree_add_text(opt_tree, tvb, offset,      optlen, "%s:", optp->name);
2237     offset += 2;    /* skip past type and length */
2238     optlen -= 2;    /* subtract size of type and length */
2239     while (optlen > 0) {
2240         if (field_tree == NULL) {
2241             /* Haven't yet made a subtree out of this option.  Do so. */
2242             field_tree = proto_item_add_subtree(tf, *optp->subtree_index);
2243             hidden_item = proto_tree_add_boolean(field_tree, hf_tcp_option_sack, tvb,
2244                                                  offset, optlen, TRUE);
2245             PROTO_ITEM_SET_HIDDEN(hidden_item);
2246         }
2247         if (optlen < 4) {
2248             proto_tree_add_text(field_tree, tvb, offset,      optlen,
2249                                 "(suboption would go past end of option)");
2250             break;
2251         }
2252         leftedge = tvb_get_ntohl(tvb, offset)-base_ack;
2253         proto_tree_add_uint_format(field_tree, hf_tcp_option_sack_sle, tvb,
2254                                    offset, 4, leftedge,
2255                                    "left edge = %u%s", leftedge,
2256                                    tcp_relative_seq ? " (relative)" : "");
2257
2258         optlen -= 4;
2259         if (optlen < 4) {
2260             proto_tree_add_text(field_tree, tvb, offset,      optlen,
2261                                 "(suboption would go past end of option)");
2262             break;
2263         }
2264         /* XXX - check whether it goes past end of packet */
2265         rightedge = tvb_get_ntohl(tvb, offset + 4)-base_ack;
2266         optlen -= 4;
2267         proto_tree_add_uint_format(field_tree, hf_tcp_option_sack_sre, tvb,
2268                                    offset+4, 4, rightedge,
2269                                    "right edge = %u%s", rightedge,
2270                                    tcp_relative_seq ? " (relative)" : "");
2271         tcp_info_append_uint(pinfo, "SLE", leftedge);
2272         tcp_info_append_uint(pinfo, "SRE", rightedge);
2273         proto_item_append_text(field_tree, " %u-%u", leftedge, rightedge);
2274         offset += 8;
2275     }
2276 }
2277
2278 static void
2279 dissect_tcpopt_echo(const ip_tcp_opt *optp, tvbuff_t *tvb,
2280     int offset, guint optlen, packet_info *pinfo, proto_tree *opt_tree)
2281 {
2282     proto_item *hidden_item;
2283     guint32 echo;
2284
2285     echo = tvb_get_ntohl(tvb, offset + 2);
2286     hidden_item = proto_tree_add_boolean(opt_tree, hf_tcp_option_echo, tvb, offset,
2287                                          optlen, TRUE);
2288     PROTO_ITEM_SET_HIDDEN(hidden_item);
2289     proto_tree_add_text(opt_tree, tvb, offset,      optlen,
2290                         "%s: %u", optp->name, echo);
2291     tcp_info_append_uint(pinfo, "ECHO", echo);
2292 }
2293
2294 static void
2295 dissect_tcpopt_timestamp(const ip_tcp_opt *optp _U_, tvbuff_t *tvb,
2296     int offset, guint optlen _U_, packet_info *pinfo, proto_tree *opt_tree)
2297 {
2298     proto_item *ti;
2299     proto_tree *ts_tree;
2300     guint32 ts_val, ts_ecr;
2301
2302     ti = proto_tree_add_text(opt_tree, tvb, offset, 10, "Timestamps: ");
2303     ts_tree = proto_item_add_subtree(ti, ett_tcp_option_timestamp);
2304
2305     proto_tree_add_item(ts_tree, hf_tcp_option_kind, tvb, offset, 1, ENC_NA);
2306     offset += 1;
2307
2308     proto_tree_add_item(ts_tree, hf_tcp_option_len, tvb, offset, 1, ENC_NA);
2309     offset += 1;
2310
2311     proto_tree_add_item(ts_tree,  hf_tcp_option_timestamp_tsval, tvb, offset,
2312                         4, ENC_BIG_ENDIAN);
2313     ts_val = tvb_get_ntohl(tvb, offset);
2314     offset += 4;
2315
2316     proto_tree_add_item(ts_tree,  hf_tcp_option_timestamp_tsecr, tvb, offset,
2317                         4, ENC_BIG_ENDIAN);
2318     ts_ecr = tvb_get_ntohl(tvb, offset);
2319     offset += 4;
2320
2321     proto_item_append_text(ti, "TSval %u, TSecr %u", ts_val, ts_ecr);
2322     tcp_info_append_uint(pinfo, "TSval", ts_val);
2323     tcp_info_append_uint(pinfo, "TSecr", ts_ecr);
2324 }
2325
2326 static void
2327 dissect_tcpopt_cc(const ip_tcp_opt *optp, tvbuff_t *tvb,
2328     int offset, guint optlen, packet_info *pinfo, proto_tree *opt_tree)
2329 {
2330     proto_item *hidden_item;
2331     guint32 cc;
2332
2333     cc = tvb_get_ntohl(tvb, offset + 2);
2334     hidden_item = proto_tree_add_boolean(opt_tree, hf_tcp_option_cc, tvb, offset,
2335                                          optlen, TRUE);
2336     PROTO_ITEM_SET_HIDDEN(hidden_item);
2337     proto_tree_add_text(opt_tree, tvb, offset,      optlen,
2338                         "%s: %u", optp->name, cc);
2339     tcp_info_append_uint(pinfo, "CC", cc);
2340 }
2341
2342 static void
2343 dissect_tcpopt_qs(const ip_tcp_opt *optp, tvbuff_t *tvb,
2344     int offset, guint optlen, packet_info *pinfo, proto_tree *opt_tree)
2345 {
2346     /* Quick-Start TCP option, as defined by RFC4782 */
2347     static const value_string qs_rates[] = {
2348         { 0, "0 bit/s"},
2349         { 1, "80 kbit/s"},
2350         { 2, "160 kbit/s"},
2351         { 3, "320 kbit/s"},
2352         { 4, "640 kbit/s"},
2353         { 5, "1.28 Mbit/s"},
2354         { 6, "2.56 Mbit/s"},
2355         { 7, "5.12 Mbit/s"},
2356         { 8, "10.24 Mbit/s"},
2357         { 9, "20.48 Mbit/s"},
2358         {10, "40.96 Mbit/s"},
2359         {11, "81.92 Mbit/s"},
2360         {12, "163.84 Mbit/s"},
2361         {13, "327.68 Mbit/s"},
2362         {14, "655.36 Mbit/s"},
2363         {15, "1.31072 Gbit/s"},
2364         {0, NULL}
2365     };
2366         static value_string_ext qs_rates_ext = VALUE_STRING_EXT_INIT(qs_rates);
2367
2368     proto_item *hidden_item;
2369
2370     guint8 rate = tvb_get_guint8(tvb, offset + 2) & 0x0f;
2371
2372     hidden_item = proto_tree_add_boolean(opt_tree, hf_tcp_option_qs, tvb, offset,
2373                                          optlen, TRUE);
2374     PROTO_ITEM_SET_HIDDEN(hidden_item);
2375     proto_tree_add_text(opt_tree, tvb, offset,      optlen,
2376                         "%s: Rate response, %s, TTL diff %u ", optp->name,
2377                         val_to_str_ext(rate, &qs_rates_ext, "Unknown"),
2378                         tvb_get_guint8(tvb, offset + 3));
2379     col_append_fstr(pinfo->cinfo, COL_INFO, " QSresp=%s", val_to_str_ext(rate, &qs_rates_ext, "Unknown"));
2380 }
2381
2382
2383 static void
2384 dissect_tcpopt_scps(const ip_tcp_opt *optp, tvbuff_t *tvb,
2385             int offset, guint optlen, packet_info *pinfo,
2386             proto_tree *opt_tree)
2387 {
2388     struct tcp_analysis *tcpd;
2389     proto_tree *field_tree = NULL;
2390     tcp_flow_t *flow;
2391     int         direction;
2392     proto_item *tf = NULL, *hidden_item;
2393     gchar       flags[64] = "<None>";
2394     gchar      *fstr[] = {"BETS", "SNACK1", "SNACK2", "COMP", "NLTS", "RESV1", "RESV2", "RESV3"};
2395     gint        i, bpos;
2396     guint8      capvector;
2397     guint8      connid;
2398
2399     tcpd = get_tcp_conversation_data(NULL,pinfo);
2400
2401     /* check direction and get ua lists */
2402     direction=CMP_ADDRESS(&pinfo->src, &pinfo->dst);
2403
2404     /* if the addresses are equal, match the ports instead */
2405     if(direction==0) {
2406         direction= (pinfo->srcport > pinfo->destport) ? 1 : -1;
2407     }
2408
2409     if(direction>=0)
2410         flow =&(tcpd->flow1);
2411     else
2412         flow =&(tcpd->flow2);
2413
2414     /* If the option length == 4, this is a real SCPS capability option
2415      * See "CCSDS 714.0-B-2 (CCSDS Recommended Standard for SCPS Transport Protocol
2416      * (SCPS-TP)" Section 3.2.3 for definition.
2417      */
2418     if (optlen == 4) {
2419         capvector = tvb_get_guint8(tvb, offset + 2);
2420         flags[0] = '\0';
2421
2422         /* Decode the capabilities vector for display */
2423         for (i = 0; i < 5; i++) {
2424             bpos = 128 >> i;
2425             if (capvector & bpos) {
2426                 if (flags[0]) {
2427                     g_strlcat(flags, ", ", 64);
2428                 }
2429                 g_strlcat(flags, fstr[i], 64);
2430             }
2431         }
2432
2433         /* If lossless header compression is offered, there will be a
2434          * single octet connectionId following the capabilities vector
2435          */
2436         if (capvector & 0x10)
2437             connid    = tvb_get_guint8(tvb, offset + 3);
2438         else
2439             connid    = 0;
2440
2441         tf = proto_tree_add_uint_format(opt_tree, hf_tcp_option_scps_vector, tvb,
2442                                         offset, optlen, capvector,
2443                                         "%s: 0x%02x (%s)",
2444                                         optp->name, capvector, flags);
2445         hidden_item = proto_tree_add_boolean(opt_tree, hf_tcp_option_scps,
2446                                              tvb, offset, optlen, TRUE);
2447         PROTO_ITEM_SET_HIDDEN(hidden_item);
2448
2449         field_tree = proto_item_add_subtree(tf, ett_tcp_option_scps);
2450
2451         proto_tree_add_boolean(field_tree, hf_tcp_scpsoption_flags_bets, tvb,
2452                                offset + 13, 1, capvector);
2453         proto_tree_add_boolean(field_tree, hf_tcp_scpsoption_flags_snack1, tvb,
2454                                offset + 13, 1, capvector);
2455         proto_tree_add_boolean(field_tree, hf_tcp_scpsoption_flags_snack2, tvb,
2456                                offset + 13, 1, capvector);
2457         proto_tree_add_boolean(field_tree, hf_tcp_scpsoption_flags_compress, tvb,
2458                                offset + 13, 1, capvector);
2459         proto_tree_add_boolean(field_tree, hf_tcp_scpsoption_flags_nlts, tvb,
2460                                offset + 13, 1, capvector);
2461         proto_tree_add_boolean(field_tree, hf_tcp_scpsoption_flags_resv1, tvb,
2462                                offset + 13, 1, capvector);
2463         proto_tree_add_boolean(field_tree, hf_tcp_scpsoption_flags_resv2, tvb,
2464                                offset + 13, 1, capvector);
2465         proto_tree_add_boolean(field_tree, hf_tcp_scpsoption_flags_resv3, tvb,
2466                                offset + 13, 1, capvector);
2467
2468         tcp_info_append_str(pinfo, "SCPS", flags);
2469
2470         flow->scps_capable = 1;
2471
2472         if (connid)
2473             tcp_info_append_uint(pinfo, "Connection ID", connid);
2474     }
2475     else {
2476         /* The option length != 4, so this is an infamous "extended capabilities
2477          * option. See "CCSDS 714.0-B-2 (CCSDS Recommended Standard for SCPS
2478          * Transport Protocol (SCPS-TP)" Section 3.2.5 for definition.
2479          *
2480          *  As the format of this option is only partially defined (it is
2481          * a community (or more likely vendor) defined format beyond that, so
2482          * at least for now, we only parse the standardized portion of the option.
2483          */
2484         guint8 local_offset = 2;
2485         guint8 binding_space;
2486         guint8 extended_cap_length;
2487
2488         if (flow->scps_capable != 1) {
2489             /* There was no SCPS capabilities option preceeding this */
2490             tf = proto_tree_add_uint_format(opt_tree, hf_tcp_option_scps_vector,
2491                                             tvb, offset, optlen, 0, "%s: (%d %s)",
2492                                             "Illegal SCPS Extended Capabilities",
2493                                             (optlen),
2494                                             "bytes");
2495         }
2496         else {
2497             tf = proto_tree_add_uint_format(opt_tree, hf_tcp_option_scps_vector,
2498                                             tvb, offset, optlen, 0, "%s: (%d %s)",
2499                                             "SCPS Extended Capabilities",
2500                                             (optlen),
2501                                             "bytes");
2502             field_tree=proto_item_add_subtree(tf, ett_tcp_option_scps_extended);
2503             /* There may be multiple binding spaces included in a single option,
2504              * so we will semi-parse each of the stacked binding spaces - skipping
2505              * over the octets following the binding space identifier and length.
2506              */
2507
2508             while (optlen > local_offset) {
2509
2510                 /* 1st octet is Extended Capability Binding Space */
2511                 binding_space = tvb_get_guint8(tvb, (offset + local_offset));
2512
2513                 /* 2nd octet (upper 4-bits) has binding space length in 16-bit words.
2514                  * As defined by the specification, this length is exclusive of the
2515                  * octets containing the extended capability type and length
2516                  */
2517
2518                 extended_cap_length =
2519                     (tvb_get_guint8(tvb, (offset + local_offset + 1)) >> 4);
2520
2521                 /* Convert the extended capabilities length into bytes for display */
2522                 extended_cap_length = (extended_cap_length << 1);
2523
2524                 proto_tree_add_text(field_tree, tvb, offset + local_offset, 2,
2525                                     "\tBinding Space %u",
2526                                     binding_space);
2527                 hidden_item = proto_tree_add_uint(field_tree, hf_tcp_option_scps_binding,
2528                                                   tvb, (offset + local_offset), 1,
2529                                                   binding_space);
2530
2531                 PROTO_ITEM_SET_HIDDEN(hidden_item);
2532
2533                 /* Step past the binding space and length octets */
2534                 local_offset += 2;
2535
2536                 proto_tree_add_text(field_tree, tvb, offset + local_offset,
2537                                     extended_cap_length,
2538                                     "\tBinding Space Data (%u bytes)",
2539                                     extended_cap_length);
2540
2541                 tcp_info_append_uint(pinfo, "EXCAP", binding_space);
2542
2543                 /* Step past the Extended capability data
2544                  * Treat the extended capability data area as opaque;
2545                  * If one desires to parse the extended capability data
2546                  * (say, in a vendor aware build of wireshark), it would
2547                  * be trigged here.
2548                  */
2549                 local_offset += extended_cap_length;
2550             }
2551         }
2552     }
2553 }
2554
2555 static void
2556 dissect_tcpopt_user_to(const ip_tcp_opt *optp, tvbuff_t *tvb,
2557     int offset, guint optlen, packet_info *pinfo, proto_tree *opt_tree)
2558 {
2559     proto_item *hidden_item, *tf;
2560     proto_tree *field_tree;
2561     gboolean g;
2562     guint16 to;
2563
2564     g = tvb_get_ntohs(tvb, offset + 2) & 0x8000;
2565     to = tvb_get_ntohs(tvb, offset + 2) & 0x7FFF;
2566     hidden_item = proto_tree_add_boolean(opt_tree, hf_tcp_option_user_to, tvb, offset,
2567                                          optlen, TRUE);
2568     PROTO_ITEM_SET_HIDDEN(hidden_item);
2569
2570     tf = proto_tree_add_uint_format(opt_tree, hf_tcp_option_user_to_val, tvb, offset,
2571                                optlen, to, "%s: %u %s", optp->name, to, g ? "minutes" : "seconds");
2572     field_tree = proto_item_add_subtree(tf, *optp->subtree_index);
2573     proto_tree_add_item(field_tree, hf_tcp_option_user_to_granularity, tvb, offset + 2, 2, FALSE);
2574     proto_tree_add_item(field_tree, hf_tcp_option_user_to_val, tvb, offset + 2, 2, FALSE);
2575
2576     tcp_info_append_uint(pinfo, "USER_TO", to);
2577 }
2578
2579 /* This is called for SYN+ACK packets and the purpose is to verify that
2580  * the SCPS capabilities option has been successfully negotiated for the flow.
2581  * If the SCPS capabilities option was offered by only one party, the
2582  * proactively set scps_capable attribute of the flow (set upon seeing
2583  * the first instance of the SCPS option) is revoked.
2584  */
2585 static void
2586 verify_scps(packet_info *pinfo,  proto_item *tf_syn, struct tcp_analysis *tcpd)
2587 {
2588     tf_syn = 0x0;
2589
2590     if(tcpd) {
2591         if ((!(tcpd->flow1.scps_capable)) || (!(tcpd->flow2.scps_capable))) {
2592             tcpd->flow1.scps_capable = 0;
2593             tcpd->flow2.scps_capable = 0;
2594         }
2595         else {
2596             expert_add_info_format(pinfo, tf_syn, PI_SEQUENCE, PI_NOTE,
2597                                    "Connection establish request (SYN-ACK): SCPS Capabilities Negotiated");
2598         }
2599     }
2600 }
2601
2602 /* See "CCSDS 714.0-B-2 (CCSDS Recommended Standard for SCPS
2603  * Transport Protocol (SCPS-TP)" Section 3.5 for definition of the SNACK option
2604  */
2605 static void
2606 dissect_tcpopt_snack(const ip_tcp_opt *optp, tvbuff_t *tvb,
2607             int offset, guint optlen, packet_info *pinfo,
2608             proto_tree *opt_tree)
2609 {
2610     struct tcp_analysis *tcpd=NULL;
2611     guint16 relative_hole_offset;
2612     guint16 relative_hole_size;
2613     guint16 base_mss = 0;
2614     guint32 ack;
2615     guint32 hole_start;
2616     guint32 hole_end;
2617     char    null_modifier[] = "\0";
2618     char    relative_modifier[] = "(relative)";
2619     char   *modifier = null_modifier;
2620     proto_item *hidden_item;
2621
2622     tcpd = get_tcp_conversation_data(NULL,pinfo);
2623
2624     /* The SNACK option reports missing data with a granualarity of segments. */
2625     relative_hole_offset = tvb_get_ntohs(tvb, offset + 2);
2626     relative_hole_size = tvb_get_ntohs(tvb, offset + 4);
2627
2628     hidden_item = proto_tree_add_boolean(opt_tree, hf_tcp_option_snack, tvb,
2629                                          offset, optlen, TRUE);
2630     PROTO_ITEM_SET_HIDDEN(hidden_item);
2631
2632     hidden_item = proto_tree_add_uint(opt_tree, hf_tcp_option_snack_offset,
2633                                       tvb, offset, optlen, relative_hole_offset);
2634     PROTO_ITEM_SET_HIDDEN(hidden_item);
2635
2636     hidden_item = proto_tree_add_uint(opt_tree, hf_tcp_option_snack_size,
2637                                       tvb, offset, optlen, relative_hole_size);
2638     PROTO_ITEM_SET_HIDDEN(hidden_item);
2639     proto_tree_add_text(opt_tree, tvb, offset, optlen,
2640                         "%s: Offset %u, Size %u", optp->name,
2641                         relative_hole_offset, relative_hole_size);
2642
2643     ack   = tvb_get_ntohl(tvb, 8);
2644
2645     if (tcp_relative_seq) {
2646         ack -= tcpd->rev->base_seq;
2647         modifier = relative_modifier;
2648     }
2649
2650     /* To aid analysis, we can use a simple but generally effective heuristic
2651      * to report the most likely boundaries of the missing data.  If the
2652      * flow is scps_capable, we track the maximum sized segment that was
2653      * acknowledged by the receiver and use that as the reporting granularity.
2654      * This may be different from the negotiated MTU due to PMTUD or flows
2655      * that do not send max-sized segments.
2656      */
2657     base_mss = tcpd->fwd->maxsizeacked;
2658
2659     if (base_mss) {
2660         /* Scale the reported offset and hole size by the largest segment acked */
2661         hole_start = ack + (base_mss * relative_hole_offset);
2662         hole_end   = hole_start + (base_mss * relative_hole_size);
2663
2664         hidden_item = proto_tree_add_uint(opt_tree, hf_tcp_option_snack_le,
2665                                           tvb, offset, optlen, hole_start);
2666         PROTO_ITEM_SET_HIDDEN(hidden_item);
2667
2668         hidden_item = proto_tree_add_uint(opt_tree, hf_tcp_option_snack_re,
2669                                           tvb, offset, optlen, hole_end);
2670         PROTO_ITEM_SET_HIDDEN(hidden_item);
2671         proto_tree_add_text(opt_tree, tvb, offset, optlen,
2672                             "\tMissing Sequence %u - %u %s",
2673                             hole_start, hole_end, modifier);
2674
2675         tcp_info_append_uint(pinfo, "SNLE", hole_start);
2676         tcp_info_append_uint(pinfo, "SNRE", hole_end);
2677
2678         expert_add_info_format(pinfo, NULL, PI_SEQUENCE, PI_NOTE,
2679                                "SNACK Sequence %u - %u %s",
2680                                hole_start, hole_end, modifier);
2681     }
2682 }
2683
2684 static void
2685 dissect_tcpopt_mood(const ip_tcp_opt _U_*optp, tvbuff_t *tvb,
2686             int offset, guint optlen, packet_info *pinfo,
2687             proto_tree *opt_tree)
2688 {
2689     /* Mood TCP option, as defined by RFC5841 */
2690
2691     static const string_string mood_type[] = {
2692         { ":)",  "Happy" },
2693         { ":(",  "Sad" },
2694         { ":D",  "Amused" },
2695         { "%(",  "Confused" },
2696         { ":o",  "Bored" },
2697         { ":O",  "Surprised" },
2698         { ":P",  "Silly" },
2699         { ":@",  "Frustrated" },
2700         { ">:@", "Angry" },
2701         { ":|",  "Apathetic" },
2702         { ";)",  "Sneaky" },
2703         { ">:)", "Evil" },
2704         { NULL, NULL }
2705     };
2706
2707     proto_item *hidden_item;
2708     proto_item *mood_item;
2709     gchar *mood;
2710     mood = tvb_get_ephemeral_string(tvb, offset + 2, optlen-2);
2711
2712     hidden_item = proto_tree_add_boolean(opt_tree, hf_tcp_option_mood, tvb, offset+2, optlen-2, TRUE);
2713
2714     PROTO_ITEM_SET_HIDDEN(hidden_item);
2715
2716     mood_item = proto_tree_add_string_format_value(opt_tree, hf_tcp_option_mood_val, tvb, offset+2, optlen-2, mood,"%s (%s)", mood, str_to_str(mood, mood_type, "Unknown") );
2717     tcp_info_append_str(pinfo, "Mood", mood);
2718
2719     expert_add_info_format(pinfo, mood_item, PI_PROTOCOL, PI_NOTE, "The packet Mood is %s (%s) (RFC 5841)", mood, str_to_str(mood, mood_type, "Unknown"));
2720
2721 }
2722 static const ip_tcp_opt tcpopts[] = {
2723     {
2724         TCPOPT_EOL,
2725         "End of Option List (EOL)",
2726         NULL,
2727         NO_LENGTH,
2728         0,
2729         NULL,
2730     },
2731     {
2732         TCPOPT_NOP,
2733         "No-Operation (NOP)",
2734         NULL,
2735         NO_LENGTH,
2736         0,
2737         NULL,
2738     },
2739     {
2740         TCPOPT_MSS,
2741         "Maximum segment size",
2742         NULL,
2743         FIXED_LENGTH,
2744         TCPOLEN_MSS,
2745         dissect_tcpopt_maxseg
2746     },
2747     {
2748         TCPOPT_WINDOW,
2749         "Window scale",
2750         NULL,
2751         FIXED_LENGTH,
2752         TCPOLEN_WINDOW,
2753         dissect_tcpopt_wscale
2754     },
2755     {
2756         TCPOPT_SACK_PERM,
2757         "SACK permitted",
2758         NULL,
2759         FIXED_LENGTH,
2760         TCPOLEN_SACK_PERM,
2761         dissect_tcpopt_sack_perm,
2762     },
2763     {
2764         TCPOPT_SACK,
2765         "SACK",
2766         &ett_tcp_option_sack,
2767         VARIABLE_LENGTH,
2768         TCPOLEN_SACK_MIN,
2769         dissect_tcpopt_sack
2770     },
2771     {
2772         TCPOPT_ECHO,
2773         "Echo",
2774         NULL,
2775         FIXED_LENGTH,
2776         TCPOLEN_ECHO,
2777         dissect_tcpopt_echo
2778     },
2779     {
2780         TCPOPT_ECHOREPLY,
2781         "Echo reply",
2782         NULL,
2783         FIXED_LENGTH,
2784         TCPOLEN_ECHOREPLY,
2785         dissect_tcpopt_echo
2786     },
2787     {
2788         TCPOPT_TIMESTAMP,
2789         "Timestamps",
2790         NULL,
2791         FIXED_LENGTH,
2792         TCPOLEN_TIMESTAMP,
2793         dissect_tcpopt_timestamp
2794     },
2795     {
2796         TCPOPT_CC,
2797         "CC",
2798         NULL,
2799         FIXED_LENGTH,
2800         TCPOLEN_CC,
2801         dissect_tcpopt_cc
2802     },
2803     {
2804         TCPOPT_CCNEW,
2805         "CC.NEW",
2806         NULL,
2807         FIXED_LENGTH,
2808         TCPOLEN_CCNEW,
2809         dissect_tcpopt_cc
2810     },
2811     {
2812         TCPOPT_CCECHO,
2813         "CC.ECHO",
2814         NULL,
2815         FIXED_LENGTH,
2816         TCPOLEN_CCECHO,
2817         dissect_tcpopt_cc
2818     },
2819     {
2820         TCPOPT_MD5,
2821         "TCP MD5 signature",
2822         NULL,
2823         FIXED_LENGTH,
2824         TCPOLEN_MD5,
2825         NULL
2826     },
2827     {
2828         TCPOPT_SCPS,
2829         "SCPS capabilities",
2830         &ett_tcp_option_scps,
2831         VARIABLE_LENGTH,
2832         TCPOLEN_SCPS,
2833         dissect_tcpopt_scps
2834     },
2835     {
2836         TCPOPT_SNACK,
2837         "Selective Negative Acknowledgement",
2838         NULL,
2839         FIXED_LENGTH,
2840         TCPOLEN_SNACK,
2841         dissect_tcpopt_snack
2842     },
2843     {
2844         TCPOPT_RECBOUND,
2845         "SCPS record boundary",
2846         NULL,
2847         FIXED_LENGTH,
2848         TCPOLEN_RECBOUND,
2849         NULL
2850     },
2851     {
2852         TCPOPT_CORREXP,
2853         "SCPS corruption experienced",
2854         NULL,
2855         FIXED_LENGTH,
2856         TCPOLEN_CORREXP,
2857         NULL
2858     },
2859     {
2860         TCPOPT_MOOD,
2861         "Packet Mood",
2862         NULL,
2863         VARIABLE_LENGTH,
2864         TCPOLEN_MOOD_MIN,
2865         dissect_tcpopt_mood
2866     },
2867     {
2868         TCPOPT_QS,
2869         "Quick-Start",
2870         NULL,
2871         FIXED_LENGTH,
2872         TCPOLEN_QS,
2873         dissect_tcpopt_qs
2874     },
2875     {
2876         TCPOPT_USER_TO,
2877         "User Timeout",
2878         &ett_tcp_option_user_to,
2879         FIXED_LENGTH,
2880         TCPOLEN_USER_TO,
2881         dissect_tcpopt_user_to
2882     }
2883 };
2884
2885 #define N_TCP_OPTS  (sizeof tcpopts / sizeof tcpopts[0])
2886
2887 /* Determine if there is a sub-dissector and call it; return TRUE
2888    if there was a sub-dissector, FALSE otherwise.
2889
2890    This has been separated into a stand alone routine to other protocol
2891    dissectors can call to it, e.g., SOCKS. */
2892
2893 static gboolean try_heuristic_first = FALSE;
2894
2895
2896 /* this function can be called with tcpd==NULL as from the msproxy dissector */
2897 gboolean
2898 decode_tcp_ports(tvbuff_t *tvb, int offset, packet_info *pinfo,
2899     proto_tree *tree, int src_port, int dst_port,
2900     struct tcp_analysis *tcpd)
2901 {
2902     tvbuff_t *next_tvb;
2903     int low_port, high_port;
2904     int save_desegment_offset;
2905     guint32 save_desegment_len;
2906
2907     /* dont call subdissectors for keepalive or zerowindowprobes
2908      * even though they do contain payload "data"
2909      * keeaplives just contain garbage and zwp contain too little data (1 byte)
2910      * so why bother.
2911      */
2912     if(tcpd && tcpd->ta){
2913         if(tcpd->ta->flags&(TCP_A_ZERO_WINDOW_PROBE|TCP_A_KEEP_ALIVE)){
2914             return TRUE;
2915         }
2916     }
2917
2918     next_tvb = tvb_new_subset_remaining(tvb, offset);
2919
2920 /* determine if this packet is part of a conversation and call dissector */
2921 /* for the conversation if available */
2922
2923     if (try_conversation_dissector(&pinfo->src, &pinfo->dst, PT_TCP,
2924                                    src_port, dst_port, next_tvb, pinfo, tree)){
2925         pinfo->want_pdu_tracking -= !!(pinfo->want_pdu_tracking);
2926         return TRUE;
2927     }
2928
2929     if (try_heuristic_first) {
2930         /* do lookup with the heuristic subdissector table */
2931         save_desegment_offset = pinfo->desegment_offset;
2932         save_desegment_len = pinfo->desegment_len;
2933         if (dissector_try_heuristic(heur_subdissector_list, next_tvb, pinfo, tree)){
2934             pinfo->want_pdu_tracking -= !!(pinfo->want_pdu_tracking);
2935             return TRUE;
2936         }
2937         /*
2938          * They rejected the packet; make sure they didn't also request
2939          * desegmentation (we could just override the request, but
2940          * rejecting a packet *and* requesting desegmentation is a sign
2941          * of the dissector's code needing clearer thought, so we fail
2942          * so that the problem is made more obvious).
2943          */
2944         DISSECTOR_ASSERT(save_desegment_offset == pinfo->desegment_offset &&
2945                          save_desegment_len == pinfo->desegment_len);
2946     }
2947
2948     /* Do lookups with the subdissector table.
2949        We try the port number with the lower value first, followed by the
2950        port number with the higher value.  This means that, for packets
2951        where a dissector is registered for *both* port numbers:
2952
2953        1) we pick the same dissector for traffic going in both directions;
2954
2955        2) we prefer the port number that's more likely to be the right
2956        one (as that prefers well-known ports to reserved ports);
2957
2958        although there is, of course, no guarantee that any such strategy
2959        will always pick the right port number.
2960
2961        XXX - we ignore port numbers of 0, as some dissectors use a port
2962        number of 0 to disable the port. */
2963     if (src_port > dst_port) {
2964         low_port = dst_port;
2965         high_port = src_port;
2966     } else {
2967         low_port = src_port;
2968         high_port = dst_port;
2969     }
2970     if (low_port != 0 &&
2971         dissector_try_port(subdissector_table, low_port, next_tvb, pinfo, tree)){
2972         pinfo->want_pdu_tracking -= !!(pinfo->want_pdu_tracking);
2973         return TRUE;
2974     }
2975     if (high_port != 0 &&
2976         dissector_try_port(subdissector_table, high_port, next_tvb, pinfo, tree)){
2977         pinfo->want_pdu_tracking -= !!(pinfo->want_pdu_tracking);
2978         return TRUE;
2979     }
2980
2981     if (!try_heuristic_first) {
2982         /* do lookup with the heuristic subdissector table */
2983         save_desegment_offset = pinfo->desegment_offset;
2984         save_desegment_len = pinfo->desegment_len;
2985         if (dissector_try_heuristic(heur_subdissector_list, next_tvb, pinfo, tree)){
2986             pinfo->want_pdu_tracking -= !!(pinfo->want_pdu_tracking);
2987             return TRUE;
2988         }
2989         /*
2990          * They rejected the packet; make sure they didn't also request
2991          * desegmentation (we could just override the request, but
2992          * rejecting a packet *and* requesting desegmentation is a sign
2993          * of the dissector's code needing clearer thought, so we fail
2994          * so that the problem is made more obvious).
2995          */
2996         DISSECTOR_ASSERT(save_desegment_offset == pinfo->desegment_offset &&
2997                          save_desegment_len == pinfo->desegment_len);
2998     }
2999
3000     /* Oh, well, we don't know this; dissect it as data. */
3001     call_dissector(data_handle,next_tvb, pinfo, tree);
3002
3003     pinfo->want_pdu_tracking -= !!(pinfo->want_pdu_tracking);
3004     return FALSE;
3005 }
3006
3007 static void
3008 process_tcp_payload(tvbuff_t *tvb, volatile int offset, packet_info *pinfo,
3009     proto_tree *tree, proto_tree *tcp_tree, int src_port, int dst_port,
3010     guint32 seq, guint32 nxtseq, gboolean is_tcp_segment,
3011     struct tcp_analysis *tcpd)
3012 {
3013     pinfo->want_pdu_tracking=0;
3014
3015     TRY {
3016         if(is_tcp_segment){
3017             /*qqq   see if it is an unaligned PDU */
3018             if(tcpd && tcp_analyze_seq && (!tcp_desegment)){
3019                 if(seq || nxtseq){
3020                     offset=scan_for_next_pdu(tvb, tcp_tree, pinfo, offset,
3021                         seq, nxtseq, tcpd->fwd->multisegment_pdus);
3022                 }
3023             }
3024         }
3025         /* if offset is -1 this means that this segment is known
3026          * to be fully inside a previously detected pdu
3027          * so we dont even need to try to dissect it either.
3028          */
3029         if( (offset!=-1) &&
3030             decode_tcp_ports(tvb, offset, pinfo, tree, src_port,
3031                 dst_port, tcpd) ){
3032             /*
3033              * We succeeded in handing off to a subdissector.
3034              *
3035              * Is this a TCP segment or a reassembled chunk of
3036              * TCP payload?
3037              */
3038             if(is_tcp_segment){
3039                 /* if !visited, check want_pdu_tracking and
3040                    store it in table */
3041                 if(tcpd && (!pinfo->fd->flags.visited) &&
3042                     tcp_analyze_seq && pinfo->want_pdu_tracking){
3043                     if(seq || nxtseq){
3044                         pdu_store_sequencenumber_of_next_pdu(
3045                             pinfo,
3046                             seq,
3047                             nxtseq+pinfo->bytes_until_next_pdu,
3048                             tcpd->fwd->multisegment_pdus);
3049                     }
3050                 }
3051             }
3052         }
3053     }
3054     CATCH_ALL {
3055         /* We got an exception. At this point the dissection is
3056          * completely aborted and execution will be transfered back
3057          * to (probably) the frame dissector.
3058          * Here we have to place whatever we want the dissector
3059          * to do before aborting the tcp dissection.
3060          */
3061         /*
3062          * Is this a TCP segment or a reassembled chunk of TCP
3063          * payload?
3064          */
3065         if(is_tcp_segment){
3066             /*
3067              * It's from a TCP segment.
3068              *
3069              * if !visited, check want_pdu_tracking and store it
3070              * in table
3071              */
3072             if(tcpd && (!pinfo->fd->flags.visited) && tcp_analyze_seq && pinfo->want_pdu_tracking){
3073                 if(seq || nxtseq){
3074                     pdu_store_sequencenumber_of_next_pdu(pinfo,
3075                         seq,
3076                         nxtseq+pinfo->bytes_until_next_pdu,
3077                         tcpd->fwd->multisegment_pdus);
3078                 }
3079             }
3080         }
3081         RETHROW;
3082     }
3083     ENDTRY;
3084 }
3085
3086 void
3087 dissect_tcp_payload(tvbuff_t *tvb, packet_info *pinfo, int offset, guint32 seq,
3088             guint32 nxtseq, guint32 sport, guint32 dport,
3089             proto_tree *tree, proto_tree *tcp_tree,
3090             struct tcp_analysis *tcpd)
3091 {
3092     gboolean save_fragmented;
3093
3094     /* Can we desegment this segment? */
3095     if (pinfo->can_desegment) {
3096         /* Yes. */
3097         desegment_tcp(tvb, pinfo, offset, seq, nxtseq, sport, dport, tree,
3098                       tcp_tree, tcpd);
3099     } else {
3100         /* No - just call the subdissector.
3101            Mark this as fragmented, so if somebody throws an exception,
3102            we don't report it as a malformed frame. */
3103         save_fragmented = pinfo->fragmented;
3104         pinfo->fragmented = TRUE;
3105         process_tcp_payload(tvb, offset, pinfo, tree, tcp_tree, sport, dport,
3106                             seq, nxtseq, TRUE, tcpd);
3107         pinfo->fragmented = save_fragmented;
3108     }
3109 }
3110
3111 static void
3112 dissect_tcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
3113 {
3114     guint8  th_off_x2; /* combines th_off and th_x2 */
3115     guint16 th_sum;
3116     guint16 th_urp;
3117     proto_tree *tcp_tree = NULL, *field_tree = NULL;
3118     proto_item *ti = NULL, *tf, *hidden_item;
3119     int        offset = 0;
3120     emem_strbuf_t *flags_strbuf = ep_strbuf_new_label("<None>");
3121     const gchar *flags[] = {"FIN", "SYN", "RST", "PSH", "ACK", "URG", "ECN", "CWR", "NS"};
3122     gint       i;
3123     guint      bpos;
3124     guint      optlen;
3125     guint32    nxtseq = 0;
3126     guint      reported_len;
3127     vec_t      cksum_vec[4];
3128     guint32    phdr[2];
3129     guint16    computed_cksum;
3130     guint16    real_window;
3131     guint      length_remaining;
3132     gboolean   desegment_ok;
3133     struct tcpinfo tcpinfo;
3134     struct tcpheader *tcph;
3135     proto_item *tf_syn = NULL, *tf_fin = NULL, *tf_rst = NULL, *scaled_pi;
3136     conversation_t *conv=NULL;
3137     struct tcp_analysis *tcpd=NULL;
3138     struct tcp_per_packet_data_t *tcppd=NULL;
3139     proto_item *item;
3140     proto_tree *checksum_tree;
3141
3142     tcph=ep_alloc(sizeof(struct tcpheader));
3143     SET_ADDRESS(&tcph->ip_src, pinfo->src.type, pinfo->src.len, pinfo->src.data);
3144     SET_ADDRESS(&tcph->ip_dst, pinfo->dst.type, pinfo->dst.len, pinfo->dst.data);
3145
3146     col_set_str(pinfo->cinfo, COL_PROTOCOL, "TCP");
3147
3148     /* Clear out the Info column. */
3149     col_clear(pinfo->cinfo, COL_INFO);
3150
3151     tcph->th_sport = tvb_get_ntohs(tvb, offset);
3152     tcph->th_dport = tvb_get_ntohs(tvb, offset + 2);
3153     col_append_fstr(pinfo->cinfo, COL_INFO, "%s > %s",
3154                     get_tcp_port(tcph->th_sport), get_tcp_port(tcph->th_dport));
3155     if (tree) {
3156         if (tcp_summary_in_tree) {
3157             ti = proto_tree_add_protocol_format(tree, proto_tcp, tvb, 0, -1,
3158                                                 "Transmission Control Protocol, Src Port: %s (%u), Dst Port: %s (%u)",
3159                                                 get_tcp_port(tcph->th_sport), tcph->th_sport,
3160                                                 get_tcp_port(tcph->th_dport), tcph->th_dport);
3161         }
3162         else {
3163             ti = proto_tree_add_item(tree, proto_tcp, tvb, 0, -1, FALSE);
3164         }
3165         tcp_tree = proto_item_add_subtree(ti, ett_tcp);
3166         pinfo->tcp_tree=tcp_tree;
3167
3168         proto_tree_add_uint_format(tcp_tree, hf_tcp_srcport, tvb, offset, 2, tcph->th_sport,
3169                                    "Source port: %s (%u)", get_tcp_port(tcph->th_sport), tcph->th_sport);
3170         proto_tree_add_uint_format(tcp_tree, hf_tcp_dstport, tvb, offset + 2, 2, tcph->th_dport,
3171                                    "Destination port: %s (%u)", get_tcp_port(tcph->th_dport), tcph->th_dport);
3172         hidden_item = proto_tree_add_uint(tcp_tree, hf_tcp_port, tvb, offset, 2, tcph->th_sport);
3173         PROTO_ITEM_SET_HIDDEN(hidden_item);
3174         hidden_item = proto_tree_add_uint(tcp_tree, hf_tcp_port, tvb, offset + 2, 2, tcph->th_dport);
3175         PROTO_ITEM_SET_HIDDEN(hidden_item);
3176
3177         /*  If we're dissecting the headers of a TCP packet in an ICMP packet
3178          *  then go ahead and put the sequence numbers in the tree now (because
3179          *  they won't be put in later because the ICMP packet only contains up
3180          *  to the sequence number).
3181          *  We should only need to do this for IPv4 since IPv6 will hopefully