Stuart Stanley's ISIS dissection support.
[obnox/wireshark/wip.git] / packet-tcp.c
1 /* packet-tcp.c
2  * Routines for TCP packet disassembly
3  *
4  * $Id: packet-tcp.c,v 1.54 1999/12/09 20:54:32 guy Exp $
5  *
6  * Ethereal - Network traffic analyzer
7  * By Gerald Combs <gerald@zing.org>
8  * Copyright 1998 Gerald Combs
9  *
10  * 
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * as published by the Free Software Foundation; either version 2
14  * of the License, or (at your option) any later version.
15  * 
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  * 
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  */
25
26 #ifdef HAVE_CONFIG_H
27 # include "config.h"
28 #endif
29
30 #ifdef HAVE_SYS_TYPES_H
31 # include <sys/types.h>
32 #endif
33
34 #ifdef HAVE_NETINET_IN_H
35 # include <netinet/in.h>
36 #endif
37
38 #include <stdio.h>
39 #include <glib.h>
40 #include "globals.h"
41 #include "resolv.h"
42 #include "follow.h"
43 #include "util.h"
44
45 #ifdef NEED_SNPRINTF_H
46 # ifdef HAVE_STDARG_H
47 #  include <stdarg.h>
48 # else
49 #  include <varargs.h>
50 # endif
51 # include "snprintf.h"
52 #endif
53
54 #ifdef HAVE_DLFCN_H
55 #include "plugins.h"
56 #endif
57
58 #ifndef __PACKET_IP_H__
59 #include "packet-ip.h"
60 #endif
61
62 extern FILE* data_out_file;
63
64 static gchar info_str[COL_MAX_LEN];
65 static int   info_len;
66
67 static int proto_tcp = -1;
68 static int hf_tcp_srcport = -1;
69 static int hf_tcp_dstport = -1;
70 static int hf_tcp_port = -1;
71 static int hf_tcp_seq = -1;
72 static int hf_tcp_ack = -1;
73 static int hf_tcp_hdr_len = -1;
74 static int hf_tcp_flags = -1;
75 static int hf_tcp_flags_urg = -1;
76 static int hf_tcp_flags_ack = -1;
77 static int hf_tcp_flags_push = -1;
78 static int hf_tcp_flags_reset = -1;
79 static int hf_tcp_flags_syn = -1;
80 static int hf_tcp_flags_fin = -1;
81 static int hf_tcp_window_size = -1;
82 static int hf_tcp_checksum = -1;
83 static int hf_tcp_urgent_pointer = -1;
84
85 static gint ett_tcp = -1;
86 static gint ett_tcp_flags = -1;
87 static gint ett_tcp_options = -1;
88 static gint ett_tcp_option_sack = -1;
89
90 /* TCP Ports */
91
92 #define TCP_PORT_FTPDATA                20
93 #define TCP_PORT_FTP                    21
94 #define TCP_PORT_TELNET                 23
95 #define TCP_PORT_SMTP                   25
96 #define TCP_PORT_HTTP                   80
97 #define TCP_PORT_TACACS                 49
98 #define TCP_PORT_POP                    110
99 #define TCP_PORT_NNTP                   119
100 #define TCP_PORT_NTP                    123
101 #define TCP_PORT_NBSS                   139
102 #define TCP_PORT_IMAP                   143
103 #define TCP_PORT_BGP                    179
104 #define TCP_PORT_LDAP                   389
105 #define TCP_PORT_SRVLOC                 427
106 #define TCP_PORT_PRINTER                515
107 #define TCP_PORT_NCP                    524
108 #define TCP_PORT_RTSP                   554
109 #define TCP_PORT_MAPI                   1065
110 #define TCP_PORT_TNS                    1521
111 #define TCP_PORT_PPTP                   1723
112 #define TCP_PORT_PROXY_HTTP             3128
113 #define TCP_PORT_PROXY_ADMIN_HTTP       3132
114 #define TCP_PORT_YHOO                   5050
115 #define TCP_ALT_PORT_HTTP               8080
116 #define TCP_PORT_IRC                    6667
117         /* good candidate for dynamic port specification */
118
119 /* TCP structs and definitions */
120
121 typedef struct _e_tcphdr {
122   guint16 th_sport;
123   guint16 th_dport;
124   guint32 th_seq;
125   guint32 th_ack;
126   guint8  th_off_x2; /* combines th_off and th_x2 */
127   guint8  th_flags;
128 #define TH_FIN  0x01
129 #define TH_SYN  0x02
130 #define TH_RST  0x04
131 #define TH_PUSH 0x08
132 #define TH_ACK  0x10
133 #define TH_URG  0x20
134   guint16 th_win;
135   guint16 th_sum;
136   guint16 th_urp;
137 } e_tcphdr;
138
139 /*
140  *      TCP option
141  */
142  
143 #define TCPOPT_NOP              1       /* Padding */
144 #define TCPOPT_EOL              0       /* End of options */
145 #define TCPOPT_MSS              2       /* Segment size negotiating */
146 #define TCPOPT_WINDOW           3       /* Window scaling */
147 #define TCPOPT_SACK_PERM        4       /* SACK Permitted */
148 #define TCPOPT_SACK             5       /* SACK Block */
149 #define TCPOPT_ECHO             6
150 #define TCPOPT_ECHOREPLY        7
151 #define TCPOPT_TIMESTAMP        8       /* Better RTT estimations/PAWS */
152 #define TCPOPT_CC               11
153 #define TCPOPT_CCNEW            12
154 #define TCPOPT_CCECHO           13
155
156 /*
157  *     TCP option lengths
158  */
159
160 #define TCPOLEN_MSS            4
161 #define TCPOLEN_WINDOW         3
162 #define TCPOLEN_SACK_PERM      2
163 #define TCPOLEN_SACK_MIN       2
164 #define TCPOLEN_ECHO           6
165 #define TCPOLEN_ECHOREPLY      6
166 #define TCPOLEN_TIMESTAMP      10
167 #define TCPOLEN_CC             6
168 #define TCPOLEN_CCNEW          6
169 #define TCPOLEN_CCECHO         6
170
171 static void
172 tcp_info_append_uint(const char *abbrev, guint32 val) {
173   int add_len = 0;
174   
175   if (info_len > 0)
176   if(info_len > 0)
177     add_len = snprintf(&info_str[info_len], COL_MAX_LEN - info_len, " %s=%u",
178       abbrev, val);
179   if (add_len > 0)
180     info_len += add_len;
181 }
182
183 static void
184 dissect_tcpopt_maxseg(const ip_tcp_opt *optp, const u_char *opd,
185     int offset, guint optlen, proto_tree *opt_tree)
186 {
187   proto_tree_add_text(opt_tree, offset,      optlen,
188                         "%s: %u bytes", optp->name, pntohs(opd));
189   tcp_info_append_uint("MSS", pntohs(opd));
190 }
191
192 static void
193 dissect_tcpopt_wscale(const ip_tcp_opt *optp, const u_char *opd,
194     int offset, guint optlen, proto_tree *opt_tree)
195 {
196   proto_tree_add_text(opt_tree, offset,      optlen,
197                         "%s: %u bytes", optp->name, *opd);
198   tcp_info_append_uint("WS", *opd);
199 }
200
201 static void
202 dissect_tcpopt_sack(const ip_tcp_opt *optp, const u_char *opd,
203     int offset, guint optlen, proto_tree *opt_tree)
204 {
205   proto_tree *field_tree = NULL;
206   proto_item *tf;
207   guint leftedge, rightedge;
208
209   tf = proto_tree_add_text(opt_tree, offset,      optlen, "%s:", optp->name);
210   offset += 2;  /* skip past type and length */
211   optlen -= 2;  /* subtract size of type and length */
212   while (optlen > 0) {
213     if (field_tree == NULL) {
214       /* Haven't yet made a subtree out of this option.  Do so. */
215       field_tree = proto_item_add_subtree(tf, *optp->subtree_index);
216     }
217     if (optlen < 4) {
218       proto_tree_add_text(field_tree, offset,      optlen,
219         "(suboption would go past end of option)");
220       break;
221     }
222     /* XXX - check whether it goes past end of packet */
223     leftedge = pntohl(opd);
224     opd += 4;
225     optlen -= 4;
226     if (optlen < 4) {
227       proto_tree_add_text(field_tree, offset,      optlen,
228         "(suboption would go past end of option)");
229       break;
230     }
231     /* XXX - check whether it goes past end of packet */
232     rightedge = pntohl(opd);
233     opd += 4;
234     optlen -= 4;
235     proto_tree_add_text(field_tree, offset,      8,
236         "left edge = %u, right edge = %u", leftedge, rightedge);
237     tcp_info_append_uint("SLE", leftedge);
238     tcp_info_append_uint("SRE", rightedge);
239     offset += 8;
240   }
241 }
242
243 static void
244 dissect_tcpopt_echo(const ip_tcp_opt *optp, const u_char *opd,
245     int offset, guint optlen, proto_tree *opt_tree)
246 {
247   proto_tree_add_text(opt_tree, offset,      optlen,
248                         "%s: %u", optp->name, pntohl(opd));
249   tcp_info_append_uint("ECHO", pntohl(opd));
250 }
251
252 static void
253 dissect_tcpopt_timestamp(const ip_tcp_opt *optp, const u_char *opd,
254     int offset, guint optlen, proto_tree *opt_tree)
255 {
256   proto_tree_add_text(opt_tree, offset,      optlen,
257     "%s: tsval %u, tsecr %u", optp->name, pntohl(opd), pntohl(opd + 4));
258   tcp_info_append_uint("TSV", pntohl(opd));
259   tcp_info_append_uint("TSER", pntohl(opd + 4));
260 }
261
262 static void
263 dissect_tcpopt_cc(const ip_tcp_opt *optp, const u_char *opd,
264     int offset, guint optlen, proto_tree *opt_tree)
265 {
266   proto_tree_add_text(opt_tree, offset,      optlen,
267                         "%s: %u", optp->name, pntohl(opd));
268   tcp_info_append_uint("CC", pntohl(opd));
269 }
270
271 static const ip_tcp_opt tcpopts[] = {
272   {
273     TCPOPT_EOL,
274     "EOL",
275     NULL,
276     NO_LENGTH,
277     0,
278     NULL,
279   },
280   {
281     TCPOPT_NOP,
282     "NOP",
283     NULL,
284     NO_LENGTH,
285     0,
286     NULL,
287   },
288   {
289     TCPOPT_MSS,
290     "Maximum segment size",
291     NULL,
292     FIXED_LENGTH,
293     TCPOLEN_MSS,
294     dissect_tcpopt_maxseg
295   },
296   {
297     TCPOPT_WINDOW,
298     "Window scale",
299     NULL,
300     FIXED_LENGTH,
301     TCPOLEN_WINDOW,
302     dissect_tcpopt_wscale
303   },
304   {
305     TCPOPT_SACK_PERM,
306     "SACK permitted",
307     NULL,
308     FIXED_LENGTH,
309     TCPOLEN_SACK_PERM,
310     NULL,
311   },
312   {
313     TCPOPT_SACK,
314     "SACK",
315     &ett_tcp_option_sack,
316     VARIABLE_LENGTH,
317     TCPOLEN_SACK_MIN,
318     dissect_tcpopt_sack
319   },
320   {
321     TCPOPT_ECHO,
322     "Echo",
323     NULL,
324     FIXED_LENGTH,
325     TCPOLEN_ECHO,
326     dissect_tcpopt_echo
327   },
328   {
329     TCPOPT_ECHOREPLY,
330     "Echo reply",
331     NULL,
332     FIXED_LENGTH,
333     TCPOLEN_ECHOREPLY,
334     dissect_tcpopt_echo
335   },
336   {
337     TCPOPT_TIMESTAMP,
338     "Time stamp",
339     NULL,
340     FIXED_LENGTH,
341     TCPOLEN_TIMESTAMP,
342     dissect_tcpopt_timestamp
343   },
344   {
345     TCPOPT_CC,
346     "CC",
347     NULL,
348     FIXED_LENGTH,
349     TCPOLEN_CC,
350     dissect_tcpopt_cc
351   },
352   {
353     TCPOPT_CCNEW,
354     "CC.NEW",
355     NULL,
356     FIXED_LENGTH,
357     TCPOPT_CCNEW,
358     dissect_tcpopt_cc
359   },
360   {
361     TCPOPT_CCECHO,
362     "CC.ECHO",
363     NULL,
364     FIXED_LENGTH,
365     TCPOLEN_CCECHO,
366     dissect_tcpopt_cc
367   }
368 };
369
370 #define N_TCP_OPTS      (sizeof tcpopts / sizeof tcpopts[0])
371
372 /* TCP flags flag */
373 static const true_false_string flags_set_truth = {
374   "Set",
375   "Not set"
376 };
377
378 void
379 dissect_tcp(const u_char *pd, int offset, frame_data *fd, proto_tree *tree) {
380   e_tcphdr   th;
381   proto_tree *tcp_tree = NULL, *field_tree = NULL;
382   proto_item *ti, *tf;
383   gchar      flags[64] = "<None>";
384   gchar     *fstr[] = {"FIN", "SYN", "RST", "PSH", "ACK", "URG"};
385   gint       fpos = 0, i;
386   guint      bpos;
387   guint      hlen;
388   guint      optlen;
389   guint      packet_max = pi.len;
390
391   /* To do: Check for {cap len,pkt len} < struct len */
392   /* Avoids alignment problems on many architectures. */
393   memcpy(&th, &pd[offset], sizeof(e_tcphdr));
394   th.th_sport = ntohs(th.th_sport);
395   th.th_dport = ntohs(th.th_dport);
396   th.th_win   = ntohs(th.th_win);
397   th.th_sum   = ntohs(th.th_sum);
398   th.th_urp   = ntohs(th.th_urp);
399   th.th_seq   = ntohl(th.th_seq);
400   th.th_ack   = ntohl(th.th_ack);
401   
402   info_len = 0;
403
404   if (check_col(fd, COL_PROTOCOL) || tree) {  
405     for (i = 0; i < 6; i++) {
406       bpos = 1 << i;
407       if (th.th_flags & bpos) {
408         if (fpos) {
409           strcpy(&flags[fpos], ", ");
410           fpos += 2;
411         }
412         strcpy(&flags[fpos], fstr[i]);
413         fpos += 3;
414       }
415     }
416     flags[fpos] = '\0';
417   }
418   
419   hlen = hi_nibble(th.th_off_x2) * 4;  /* TCP header length, in bytes */
420
421   if (check_col(fd, COL_PROTOCOL))
422     col_add_str(fd, COL_PROTOCOL, "TCP");
423   if (check_col(fd, COL_INFO)) {
424     /* Copy the data into info_str in case one of the option handling
425        routines needs to append to it. */
426     if (th.th_flags & TH_URG)
427       info_len = snprintf(info_str, COL_MAX_LEN, "%s > %s [%s] Seq=%u Ack=%u Win=%u Urg=%u",
428         get_tcp_port(th.th_sport), get_tcp_port(th.th_dport), flags,
429         th.th_seq, th.th_ack, th.th_win, th.th_urp);
430     else
431       info_len = snprintf(info_str, COL_MAX_LEN, "%s > %s [%s] Seq=%u Ack=%u Win=%u",
432         get_tcp_port(th.th_sport), get_tcp_port(th.th_dport), flags,
433         th.th_seq, th.th_ack, th.th_win);
434     /* The info column is actually written after the options are decoded */
435   }
436   
437   if (tree) {
438     ti = proto_tree_add_item_format(tree, proto_tcp, offset, hlen, NULL, "Transmission Control Protocol, Src Port: %s (%u), Dst Port: %s (%u), Seq: %u, Ack: %u", get_tcp_port(th.th_sport), th.th_sport, get_tcp_port(th.th_dport), th.th_dport, th.th_seq, th.th_ack);
439     tcp_tree = proto_item_add_subtree(ti, ett_tcp);
440     proto_tree_add_item_format(tcp_tree, hf_tcp_srcport, offset, 2, th.th_sport,
441         "Source port: %s (%u)", get_tcp_port(th.th_sport), th.th_sport);
442     proto_tree_add_item_format(tcp_tree, hf_tcp_dstport, offset + 2, 2, th.th_dport,
443         "Destination port: %s (%u)", get_tcp_port(th.th_dport), th.th_dport);
444     proto_tree_add_item_hidden(tcp_tree, hf_tcp_port, offset, 2, th.th_sport);
445     proto_tree_add_item_hidden(tcp_tree, hf_tcp_port, offset + 2, 2, th.th_dport);
446     proto_tree_add_item(tcp_tree, hf_tcp_seq, offset + 4, 4, th.th_seq);
447     if (th.th_flags & TH_ACK)
448       proto_tree_add_item(tcp_tree, hf_tcp_ack, offset + 8, 4, th.th_ack);
449     proto_tree_add_item_format(tcp_tree, hf_tcp_hdr_len, offset + 12, 1, hlen,
450         "Header length: %u bytes", hlen);
451     tf = proto_tree_add_item_format(tcp_tree, hf_tcp_flags, offset + 13, 1,
452         th.th_flags, "Flags: 0x%04x (%s)", th.th_flags, flags);
453     field_tree = proto_item_add_subtree(tf, ett_tcp_flags);
454     proto_tree_add_item(field_tree, hf_tcp_flags_urg, offset + 13, 1, th.th_flags);
455     proto_tree_add_item(field_tree, hf_tcp_flags_ack, offset + 13, 1, th.th_flags);
456     proto_tree_add_item(field_tree, hf_tcp_flags_push, offset + 13, 1, th.th_flags);
457     proto_tree_add_item(field_tree, hf_tcp_flags_reset, offset + 13, 1, th.th_flags);
458     proto_tree_add_item(field_tree, hf_tcp_flags_syn, offset + 13, 1, th.th_flags);
459     proto_tree_add_item(field_tree, hf_tcp_flags_fin, offset + 13, 1, th.th_flags);
460     proto_tree_add_item(tcp_tree, hf_tcp_window_size, offset + 14, 2, th.th_win);
461     proto_tree_add_item(tcp_tree, hf_tcp_checksum, offset + 16, 2, th.th_sum);
462     if (th.th_flags & TH_URG)
463       proto_tree_add_item(tcp_tree, hf_tcp_urgent_pointer, offset + 18, 2, th.th_urp);
464   }
465
466   /* Decode TCP options, if any. */
467   if (tree  && hlen > sizeof (e_tcphdr)) {
468     /* There's more than just the fixed-length header.  Decode the
469        options. */
470     optlen = hlen - sizeof (e_tcphdr); /* length of options, in bytes */
471     tf = proto_tree_add_text(tcp_tree, offset +  20, optlen,
472       "Options: (%d bytes)", optlen);
473     field_tree = proto_item_add_subtree(tf, ett_tcp_options);
474     dissect_ip_tcp_options(&pd[offset + 20], offset + 20, optlen,
475       tcpopts, N_TCP_OPTS, TCPOPT_EOL, field_tree);
476   }
477
478   if (check_col(fd, COL_INFO))
479     col_add_str(fd, COL_INFO, info_str);
480
481   /* Skip over header + options */
482   offset += hlen;
483
484   pi.ptype = PT_TCP;
485   pi.srcport = th.th_sport;
486   pi.destport = th.th_dport;
487   
488   /* Check the packet length to see if there's more data
489      (it could be an ACK-only packet) */
490   if (packet_max > offset) {
491
492     /* try to apply the plugins */
493 #ifdef HAVE_DLFCN_H
494     plugin *pt_plug = plugin_list;
495
496     if (pt_plug) {
497       while (pt_plug) {
498         if (pt_plug->enabled && !strcmp(pt_plug->protocol, "tcp") &&
499             tree && dfilter_apply(pt_plug->filter, tree, pd)) {
500           pt_plug->dissector(pd, offset, fd, tree);
501           goto reas;
502         }
503         pt_plug = pt_plug->next;
504       }
505     }
506 #endif
507
508     /* ONC RPC.  We can't base this on anything in the TCP header; we have
509        to look at the payload.  If "dissect_rpc()" returns TRUE, it was
510        an RPC packet, otherwise it's some other type of packet. */
511     if (dissect_rpc(pd, offset, fd, tree))
512       goto reas;
513
514     /* XXX - this should be handled the way UDP handles this, with a table
515        of port numbers to which stuff can be added */
516 #define PORT_IS(port)   (th.th_sport == port || th.th_dport == port)
517     if (PORT_IS(TCP_PORT_PRINTER))
518       dissect_lpd(pd, offset, fd, tree);
519     else if (PORT_IS(TCP_PORT_TELNET)) {
520       pi.match_port = TCP_PORT_TELNET;
521       dissect_telnet(pd, offset, fd, tree);
522     } else if (PORT_IS(TCP_PORT_FTPDATA)) {
523       pi.match_port = TCP_PORT_FTPDATA;
524       dissect_ftpdata(pd, offset, fd, tree);
525     } else if (PORT_IS(TCP_PORT_FTP)) {
526       pi.match_port = TCP_PORT_FTP;
527       dissect_ftp(pd, offset, fd, tree);
528     } else if (PORT_IS(TCP_PORT_POP)) {
529       pi.match_port = TCP_PORT_POP;
530       dissect_pop(pd, offset, fd, tree);
531     } else if (PORT_IS(TCP_PORT_IMAP)) {
532       pi.match_port = TCP_PORT_IMAP;
533       dissect_imap(pd, offset, fd, tree);
534     } else if (PORT_IS(TCP_PORT_NNTP)) {
535       pi.match_port = TCP_PORT_NNTP;
536       dissect_nntp(pd, offset, fd, tree);
537     } else if (PORT_IS(TCP_PORT_NTP)) {
538       pi.match_port = TCP_PORT_NTP;
539       dissect_ntp(pd, offset, fd, tree);
540     } else if (PORT_IS(TCP_PORT_PPTP)) {
541       pi.match_port = TCP_PORT_PPTP;
542       dissect_pptp(pd, offset, fd, tree);
543     } else if (PORT_IS(TCP_PORT_HTTP) || PORT_IS(TCP_ALT_PORT_HTTP)
544             || PORT_IS(631) || PORT_IS(TCP_PORT_PROXY_HTTP)
545             || PORT_IS(TCP_PORT_PROXY_ADMIN_HTTP))
546       dissect_http(pd, offset, fd, tree);
547     else if (PORT_IS(TCP_PORT_NBSS)) {
548       pi.match_port = TCP_PORT_NBSS;
549       dissect_nbss(pd, offset, fd, tree);
550     } else if (PORT_IS(TCP_PORT_RTSP))
551       dissect_rtsp(pd, offset, fd, tree);
552     else if (PORT_IS(TCP_PORT_BGP)) {
553       pi.match_port = TCP_PORT_BGP;
554       dissect_bgp(pd, offset, fd, tree);
555     } else if (PORT_IS(TCP_PORT_TACACS)) {
556       pi.match_port = TCP_PORT_TACACS;
557       dissect_tacplus(pd, offset, fd, tree);
558     } else if (PORT_IS(TCP_PORT_MAPI)) {
559       pi.match_port = TCP_PORT_MAPI;
560       dissect_mapi(pd, offset, fd, tree);
561     } else if (PORT_IS(TCP_PORT_TNS)) {
562       pi.match_port = TCP_PORT_TNS;
563       dissect_tns(pd, offset, fd, tree);
564     } else if (PORT_IS(TCP_PORT_IRC)) {
565       pi.match_port = TCP_PORT_IRC;
566       dissect_irc(pd, offset, fd, tree);
567     } else if (PORT_IS(TCP_PORT_LDAP)) {
568       pi.match_port = TCP_PORT_LDAP;
569       dissect_ldap(pd, offset, fd, tree);
570     } else if (PORT_IS(TCP_PORT_SRVLOC)) {
571       pi.match_port = TCP_PORT_SRVLOC;
572       dissect_srvloc(pd, offset, fd, tree);
573     } else if (PORT_IS(TCP_PORT_NCP)) {
574       pi.match_port = TCP_PORT_NCP;
575       dissect_ncp(pd, offset, fd, tree);
576     } else {
577         /* check existence of high level protocols */
578
579         if (memcmp(&pd[offset], "GIOP",  4) == 0) {
580           dissect_giop(pd, offset, fd, tree);
581         }
582         else if ( PORT_IS(TCP_PORT_YHOO) && 
583                 (memcmp(&pd[offset], "YPNS",  4) == 0 ||
584                         memcmp(&pd[offset], "YHOO",  4) == 0 )) {
585           dissect_yhoo(pd, offset, fd, tree);
586         }
587         else {
588           dissect_data(pd, offset, fd, tree);
589         }
590     }
591   }
592
593 reas:
594  
595   if( data_out_file ) {
596     reassemble_tcp( th.th_seq,          /* sequence number */
597         ( pi.len - offset ),            /* data length */
598         ( pd+offset ),                  /* data */
599         ( pi.captured_len - offset ),   /* captured data length */
600         ( th.th_flags & TH_SYN ),       /* is syn set? */
601         &pi.net_src,
602         &pi.net_dst,
603         pi.srcport,
604         pi.destport,
605         fd->rel_secs,
606         fd->rel_usecs);
607   }
608 }
609
610 void
611 proto_register_tcp(void)
612 {
613         static hf_register_info hf[] = {
614
615                 { &hf_tcp_srcport,
616                 { "Source Port",                "tcp.srcport", FT_UINT16, BASE_DEC, NULL, 0x0,
617                         "" }},
618
619                 { &hf_tcp_dstport,
620                 { "Destination Port",           "tcp.dstport", FT_UINT16, BASE_DEC, NULL, 0x0,
621                         "" }},
622
623                 { &hf_tcp_port,
624                 { "Source or Destination Port", "tcp.port", FT_UINT16, BASE_DEC, NULL, 0x0,
625                         "" }},
626
627                 { &hf_tcp_seq,
628                 { "Sequence number",            "tcp.seq", FT_UINT32, BASE_DEC, NULL, 0x0,
629                         "" }},
630
631                 { &hf_tcp_ack,
632                 { "Acknowledgement number",     "tcp.ack", FT_UINT32, BASE_DEC, NULL, 0x0,
633                         "" }},
634
635                 { &hf_tcp_hdr_len,
636                 { "Header Length",              "tcp.hdr_len", FT_UINT8, BASE_DEC, NULL, 0x0,
637                         "" }},
638
639                 { &hf_tcp_flags,
640                 { "Flags",                      "tcp.flags", FT_UINT8, BASE_HEX, NULL, 0x0,
641                         "" }},
642
643                 { &hf_tcp_flags_urg,
644                 { "Urgent",                     "tcp.flags.urg", FT_BOOLEAN, 8, TFS(&flags_set_truth), TH_URG,
645                         "" }},
646
647                 { &hf_tcp_flags_ack,
648                 { "Acknowledgment",             "tcp.flags.ack", FT_BOOLEAN, 8, TFS(&flags_set_truth), TH_ACK,
649                         "" }},
650
651                 { &hf_tcp_flags_push,
652                 { "Push",                       "tcp.flags.push", FT_BOOLEAN, 8, TFS(&flags_set_truth), TH_PUSH,
653                         "" }},
654
655                 { &hf_tcp_flags_reset,
656                 { "Reset",                      "tcp.flags.reset", FT_BOOLEAN, 8, TFS(&flags_set_truth), TH_RST,
657                         "" }},
658
659                 { &hf_tcp_flags_syn,
660                 { "Syn",                        "tcp.flags.syn", FT_BOOLEAN, 8, TFS(&flags_set_truth), TH_SYN,
661                         "" }},
662
663                 { &hf_tcp_flags_fin,
664                 { "Fin",                        "tcp.flags.fin", FT_BOOLEAN, 8, TFS(&flags_set_truth), TH_FIN,
665                         "" }},
666
667                 { &hf_tcp_window_size,
668                 { "Window size",                "tcp.window_size", FT_UINT16, BASE_DEC, NULL, 0x0,
669                         "" }},
670
671                 { &hf_tcp_checksum,
672                 { "Checksum",                   "tcp.checksum", FT_UINT16, BASE_HEX, NULL, 0x0,
673                         "" }},
674
675                 { &hf_tcp_urgent_pointer,
676                 { "Urgent pointer",             "tcp.urgent_pointer", FT_UINT16, BASE_DEC, NULL, 0x0,
677                         "" }},
678         };
679         static gint *ett[] = {
680                 &ett_tcp,
681                 &ett_tcp_flags,
682                 &ett_tcp_options,
683                 &ett_tcp_option_sack,
684         };
685
686         proto_tcp = proto_register_protocol ("Transmission Control Protocol", "tcp");
687         proto_register_field_array(proto_tcp, hf, array_length(hf));
688         proto_register_subtree_array(ett, array_length(ett));
689 }