When doing a capture, decode enough of the incoming packets to correctly
[obnox/wireshark/wip.git] / ethereal.c
1 /* ethereal.c
2  *
3  * $Id: ethereal.c,v 1.21 1999/02/09 00:35:35 guy Exp $
4  *
5  * Ethereal - Network traffic analyzer
6  * By Gerald Combs <gerald@zing.org>
7  * Copyright 1998 Gerald Combs
8  *
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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  *
24  *
25  * To do:
26  * - Live browser/capture display
27  * - Graphs
28  * - Get AIX to work
29  * - Check for end of packet in dissect_* routines.
30  * - Playback window
31  * - Multiple window support
32  * - Add cut/copy/paste
33  * - Handle snoop files
34  * - Fix progress/status bar glitches?  (GTK+ bug?)
35  * - Create header parsing routines
36  * - Check fopens, freads, fwrites
37  * - Make byte view scrollbars automatic?
38  * - Make byte view selections more fancy?
39  *
40  */
41
42 #ifdef HAVE_CONFIG_H
43 # include "config.h"
44 #endif
45
46 #include <gtk/gtk.h>
47 #include <pcap.h> /* needed for capture.h */
48
49 #include <stdlib.h>
50 #include <stdio.h>
51 #include <string.h>
52 #include <unistd.h>
53 #include <sys/types.h>
54 #include <sys/stat.h>
55 #include <fcntl.h>
56 #include <netinet/in.h>
57
58 #ifdef NEED_SNPRINTF_H
59 # ifdef HAVE_STDARG_H
60 #  include <stdarg.h>
61 # else
62 #  include <varargs.h>
63 # endif
64 # include "snprintf.h"
65 #endif
66
67 #include "ethereal.h"
68 #include "packet.h"
69 #include "capture.h"
70 #include "file.h"
71 #include "menu.h"
72 #include "etypes.h"
73 #include "prefs.h"
74 #include "column.h"
75 #include "print.h"
76 #include "resolv.h"
77 #include "follow.h"
78 #include "util.h"
79
80 FILE        *data_out_file = NULL;
81 packet_info  pi;
82 capture_file cf;
83 GtkWidget   *file_sel, *packet_list, *tree_view, *byte_view, *prog_bar,
84             *info_bar;
85 GdkFont     *m_r_font, *m_b_font;
86 guint        main_ctx, file_ctx;
87 frame_data  *fd;
88 gint         start_capture = 0;
89 gchar        comp_info_str[256];
90
91 ts_type timestamp_type = RELATIVE;
92
93 GtkStyle *item_style;
94
95 #define E_DFILTER_TE_KEY "display_filter_te"
96
97 /* About Ethereal window */
98 void
99 about_ethereal( GtkWidget *w, gpointer data ) {
100   simple_dialog(ESD_TYPE_INFO, NULL,
101                 "GNU Ethereal - network protocol analyzer\n"
102                 "Version %s (C) 1998 Gerald Combs <gerald@zing.org>\n"
103                 "Compiled with %s\n\n"
104                 "Contributors:\n"
105                 "Gilbert Ramirez Jr. <gram@verdict.uthscsa.edu>\n"
106                 "Hannes R. Boehm     <hannes@boehm.org>\n"
107                 "Mike Hall           <mlh@io.com>\n"
108                 "Bobo Rajec          <bobo@bsp-consulting.sk>\n"
109                 "Laurent Deniel      <deniel@worldnet.fr>\n"
110                 "Don Lafontaine      <lafont02@cn.ca>\n"
111                 "Guy Harris          <guy@netapp.com>\n"
112                 "Simon Wilkinson     <sxw@dcs.ed.ac.uk>\n"
113                 "Joerg Mayer         <jmayer@telemation.de>\n\n"
114                 "See http://ethereal.zing.org for more information",
115                 VERSION, comp_info_str);
116 }
117
118 /* Things to do when the OK button is pressed */
119 void
120 file_sel_ok_cb(GtkWidget *w, GtkFileSelection *fs) {
121   gchar     *cf_name;
122   int        err;
123   GtkWidget *filter_te = NULL;
124
125   /* Gilbert --- I added this if statement. Is this right? */
126   if (w)
127         filter_te = gtk_object_get_data(GTK_OBJECT(w), E_DFILTER_TE_KEY);
128
129   cf_name = g_strdup(gtk_file_selection_get_filename(GTK_FILE_SELECTION (fs)));
130   gtk_widget_hide(GTK_WIDGET (fs));
131   gtk_widget_destroy(GTK_WIDGET (fs));
132
133   if (w && cf.dfilter) {
134           g_free(cf.dfilter);
135           cf.dfilter = g_strdup(gtk_entry_get_text(GTK_ENTRY(filter_te)));
136   }
137   if ((err = load_cap_file(cf_name, &cf)) == 0)
138     chdir(cf_name);
139   g_free(cf_name);
140 }
141
142 /* Update the progress bar */
143 gint
144 file_progress_cb(gpointer p) {
145   gtk_progress_bar_update(GTK_PROGRESS_BAR(prog_bar),
146     (gfloat) ftell(cf.fh) / (gfloat) cf.f_len);
147   return TRUE;
148 }
149
150 /* Follow a TCP stream */
151 void
152 follow_stream_cb( GtkWidget *w, gpointer data ) {
153   char filename1[128];
154   GtkWidget *streamwindow, *box, *text, *vscrollbar, *table;
155   GtkWidget *filter_te = NULL;
156
157   if (w)
158         filter_te = gtk_object_get_data(GTK_OBJECT(w), E_DFILTER_TE_KEY);
159
160   if( pi.ipproto == 6 ) {
161     /* we got tcp so we can follow */
162     /* check to see if we are using a filter */
163     if( cf.dfilter != NULL ) {
164       /* get rid of this one */
165       g_free( cf.dfilter );
166       cf.dfilter = NULL;
167     }
168     /* create a new one and set the display filter entry accordingly */
169     cf.dfilter = build_follow_filter( &pi );
170     if (filter_te)
171             gtk_entry_set_text(GTK_ENTRY(filter_te), cf.dfilter);
172     /* reload so it goes in effect. Also we set data_out_file which 
173        tells the tcp code to output the data */
174     close_cap_file( &cf, info_bar, file_ctx);
175     strcpy( filename1, tmpnam(NULL) );
176     data_out_file = fopen( filename1, "a" );
177     if( data_out_file == NULL ) {
178       fprintf( stderr, "Could not open tmp file %s\n", filename1 );
179     }
180     reset_tcp_reassembly();
181     load_cap_file( cf.filename, &cf );
182     /* the data_out_file should now be full of the streams information */
183     fclose( data_out_file );
184     /* the filename1 file now has all the text that was in the session */
185     streamwindow = gtk_window_new( GTK_WINDOW_TOPLEVEL);
186     gtk_widget_set_name( streamwindow, "TCP stream window" );
187     gtk_signal_connect( GTK_OBJECT(streamwindow), "delete_event",
188                         NULL, "WM destroy" );
189     gtk_signal_connect( GTK_OBJECT(streamwindow), "destroy",
190                         NULL, "WM destroy" );
191     gtk_window_set_title( GTK_WINDOW(streamwindow), "Contents of TCP stream" );
192     gtk_widget_set_usize( GTK_WIDGET(streamwindow), DEF_WIDTH, DEF_HEIGHT );
193     gtk_container_border_width( GTK_CONTAINER(streamwindow), 2 );
194     /* setup the container */
195     box = gtk_vbox_new( FALSE, 0 );
196     gtk_container_add( GTK_CONTAINER(streamwindow), box );
197     gtk_widget_show( box );
198     /* set up the table we attach to */
199     table = gtk_table_new( 1, 2, FALSE );
200     gtk_table_set_col_spacing( GTK_TABLE(table), 0, 2);
201     gtk_box_pack_start( GTK_BOX(box), table, TRUE, TRUE, 0 );
202     gtk_widget_show( table );
203     /* create a text box */
204     text = gtk_text_new( NULL, NULL );
205     gtk_text_set_editable( GTK_TEXT(text), FALSE);
206     gtk_table_attach( GTK_TABLE(table), text, 0, 1, 0, 1,
207                       GTK_EXPAND | GTK_SHRINK | GTK_FILL,
208                       GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0 );
209     gtk_widget_show(text);
210     /* create the scrollbar */
211     vscrollbar = gtk_vscrollbar_new( GTK_TEXT(text)->vadj );
212     gtk_table_attach( GTK_TABLE(table), vscrollbar, 1, 2, 0, 1,
213                       GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0 );
214     gtk_widget_show( vscrollbar );
215     gtk_widget_realize( text );
216     /* stop the updates while we fill the text box */
217     gtk_text_freeze( GTK_TEXT(text) );
218     data_out_file = NULL;
219     data_out_file = fopen( filename1, "r" );
220     if( data_out_file ) {
221       char buffer[1024];
222       int nchars;
223       while( 1 ) {
224         nchars = fread( buffer, 1, 1024, data_out_file );
225         gtk_text_insert( GTK_TEXT(text), m_r_font, NULL, NULL, buffer, nchars );
226         if( nchars < 1024 ) {
227           break;
228         }
229       }
230       fclose( data_out_file );
231       unlink( filename1 );
232     }
233     gtk_text_thaw( GTK_TEXT(text) );
234     data_out_file = NULL;
235     gtk_widget_show( streamwindow );
236     if( cf.dfilter != NULL ) {
237       g_free( cf.dfilter );
238       cf.dfilter = NULL;
239     }
240   } else {
241     simple_dialog(ESD_TYPE_WARN, NULL,
242       "Error following stream.  Please make\n"
243       "sure you have a TCP packet selected.");
244   }
245 }
246
247 /* Open a file */
248 void
249 file_open_cmd_cb(GtkWidget *w, gpointer data) {
250   file_sel = gtk_file_selection_new ("Ethereal: Open Capture File");
251   
252   /* Connect the ok_button to file_ok_sel_cb function and pass along the
253      pointer to the filter entry */
254   gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_sel)->ok_button),
255     "clicked", (GtkSignalFunc) file_sel_ok_cb, file_sel );
256
257   /* Gilbert --- I added this if statement. Is this right? */
258   if (w)
259   gtk_object_set_data(GTK_OBJECT(GTK_FILE_SELECTION(file_sel)->ok_button),
260     E_DFILTER_TE_KEY, gtk_object_get_data(GTK_OBJECT(w), E_DFILTER_TE_KEY));
261
262   /* Connect the cancel_button to destroy the widget */
263   gtk_signal_connect_object(GTK_OBJECT (GTK_FILE_SELECTION
264     (file_sel)->cancel_button), "clicked", (GtkSignalFunc)
265     gtk_widget_destroy, GTK_OBJECT (file_sel));
266
267   gtk_file_selection_set_filename(GTK_FILE_SELECTION(file_sel), "");
268
269   gtk_widget_show(file_sel);
270 }
271
272 /* Close a file */
273 void
274 file_close_cmd_cb(GtkWidget *widget, gpointer data) {
275   close_cap_file(&cf, info_bar, file_ctx);
276 #ifdef USE_ITEM
277   set_menu_sensitivity("/File/Close", FALSE);
278   set_menu_sensitivity("/File/Reload", FALSE);
279 #else
280   set_menu_sensitivity("<Main>/File/Close", FALSE);
281   set_menu_sensitivity("<Main>/File/Reload", FALSE);
282 #endif
283 }
284
285 /* Reload a file using the current display filter */
286 void
287 file_reload_cmd_cb(GtkWidget *w, gpointer data) {
288   GtkWidget *filter_te = gtk_object_get_data(GTK_OBJECT(w), E_DFILTER_TE_KEY);
289
290   if (cf.dfilter) g_free(cf.dfilter);
291   cf.dfilter = g_strdup(gtk_entry_get_text(GTK_ENTRY(filter_te)));
292   load_cap_file(cf.filename, &cf);
293 }
294
295 /* Print a packet */
296 void
297 file_print_cmd_cb(GtkWidget *widget, gpointer data) {
298     print_tree(cf.pd, fd, GTK_TREE(tree_view));
299 }
300
301 /* What to do when a list item is selected/unselected */
302 void
303 packet_list_select_cb(GtkWidget *w, gint row, gint col, gpointer evt) {
304   GList      *l;
305
306 #ifdef WITH_WIRETAP
307   if (cf.wth) return; 
308 #else
309   if (cf.pfh) return;
310 #endif
311   blank_packetinfo();
312   gtk_text_freeze(GTK_TEXT(byte_view));
313   gtk_text_set_point(GTK_TEXT(byte_view), 0);
314   gtk_text_forward_delete(GTK_TEXT(byte_view),
315     gtk_text_get_length(GTK_TEXT(byte_view)));
316   l = g_list_nth(cf.plist, row);
317   if (l) {
318     fd = (frame_data *) l->data;
319     fseek(cf.fh, fd->file_off, SEEK_SET);
320     fread(cf.pd, sizeof(guint8), fd->cap_len, cf.fh);
321     dissect_packet(cf.pd, fd, GTK_TREE(tree_view));
322     packet_hex_print(GTK_TEXT(byte_view), cf.pd, fd->cap_len, -1, -1);
323   }
324   gtk_text_thaw(GTK_TEXT(byte_view));
325 }
326
327 void
328 packet_list_unselect_cb(GtkWidget *w, gint row, gint col, gpointer evt) {
329   gtk_text_freeze(GTK_TEXT(byte_view));
330   gtk_text_set_point(GTK_TEXT(byte_view), 0);
331   gtk_text_forward_delete(GTK_TEXT(byte_view),
332     gtk_text_get_length(GTK_TEXT(byte_view)));
333   gtk_text_thaw(GTK_TEXT(byte_view));
334   gtk_tree_clear_items(GTK_TREE(tree_view), 0,
335     g_list_length(GTK_TREE(tree_view)->children));
336 }
337
338 void
339 tree_view_cb(GtkWidget *w) {
340   gint       start = -1, len = -1;
341
342   if (GTK_TREE(w)->selection) {
343     start = (gint) gtk_object_get_data(GTK_OBJECT(GTK_TREE(w)->selection->data),
344       E_TREEINFO_START_KEY);
345     len   = (gint) gtk_object_get_data(GTK_OBJECT(GTK_TREE(w)->selection->data),
346       E_TREEINFO_LEN_KEY);
347   }
348
349   gtk_text_freeze(GTK_TEXT(byte_view));
350   gtk_text_set_point(GTK_TEXT(byte_view), 0);
351   gtk_text_forward_delete(GTK_TEXT(byte_view),
352     gtk_text_get_length(GTK_TEXT(byte_view)));
353   packet_hex_print(GTK_TEXT(byte_view), cf.pd, fd->cap_len, start, len);
354   gtk_text_thaw(GTK_TEXT(byte_view));
355 }
356
357 void
358 file_quit_cmd_cb (GtkWidget *widget, gpointer data) {
359   gtk_exit(0);
360 }
361
362 void blank_packetinfo() {
363   pi.srcip    = 0;
364   pi.destip   = 0;
365   pi.ipproto  = 0;
366   pi.srcport  = 0;
367   pi.destport = 0;
368 }
369
370 /* Things to do when the OK button is pressed */
371 void
372 main_realize_cb(GtkWidget *w, gpointer data) {
373   gchar  *cf_name = (gchar *) data;
374   int     err;
375   
376   if (cf_name) {
377     err = load_cap_file(cf_name, &cf);
378     cf_name[0] = '\0';
379   }
380   if (start_capture) {
381     if (cf.save_file)
382       capture(1);
383     else
384       capture(0);
385     start_capture = 0;
386   }
387 }
388
389 void 
390 print_usage(void) {
391
392   fprintf(stderr, "This is GNU %s %s, compiled with %s\n", PACKAGE,
393   VERSION, comp_info_str);
394   fprintf(stderr, "%s [-v] [-b bold font] [-B byte view height] [-c count] [-h]\n",
395           PACKAGE);
396   fprintf(stderr, "         [-i interface] [-m medium font] [-n] [-P packet list height]\n");
397   fprintf(stderr, "         [-r infile] [-s snaplen] [-t <time stamp format>]\n");
398   fprintf(stderr, "         [-T tree view height] [-w savefile] \n");
399 }
400
401 /* And now our feature presentation... [ fade to music ] */
402 int
403 main(int argc, char *argv[])
404 {
405   int                  opt, i;
406   extern char         *optarg;
407   GtkWidget           *window, *main_vbox, *menubar, *u_pane, *l_pane,
408                       *bv_table, *bv_hscroll, *bv_vscroll, *stat_hbox, 
409                       *tv_scrollw, *filter_bt, *filter_te;
410   GtkStyle            *pl_style;
411 #ifdef GTK_HAVE_FEATURES_1_1_0
412   GtkAccelGroup *accel;
413 #else
414   GtkAcceleratorTable *accel;
415 #endif
416
417 #ifdef GTK_HAVE_FEATURES_1_1_4
418   GtkWidget     *packet_sw;
419 #endif
420   gint                 pl_size = 280, tv_size = 95, bv_size = 75;
421   gchar               *rc_file, *cf_name = NULL;
422   gchar               *medium_font = MONO_MEDIUM_FONT;
423   gchar               *bold_font = MONO_BOLD_FONT;
424   e_prefs             *prefs;
425   gint                *col_fmt;
426   gchar              **col_title;
427
428   /* Let GTK get its args */
429   gtk_init (&argc, &argv);
430
431   prefs = read_prefs();
432     
433   /* Initialize the capture file struct */
434   cf.plist     = NULL;
435 #ifdef WITH_WIRETAP
436   cf.wth       = NULL;
437 #else
438   cf.pfh       = NULL;
439 #endif
440   cf.fh        = NULL;
441   cf.dfilter   = NULL;
442   cf.cfilter   = NULL;
443   cf.iface     = NULL;
444   cf.save_file = NULL;
445   cf.snap      = 68;
446   cf.count     = 0;
447   cf.cinfo.num_cols = prefs->num_cols;
448   cf.cinfo.fmt_matx = (gboolean **) g_malloc(sizeof(gboolean *) *
449     cf.cinfo.num_cols);
450   cf.cinfo.col_data = (gchar **) g_malloc(sizeof(gchar *) *
451     cf.cinfo.num_cols);
452
453   /* Assemble the compile-time options */
454   snprintf(comp_info_str, 256,
455 #ifdef GTK_MAJOR_VERSION
456     "GTK+ %d.%d.%d and %s", GTK_MAJOR_VERSION, GTK_MINOR_VERSION,
457     GTK_MICRO_VERSION,
458 #else
459     "GTK+ (version unknown) and %s",
460 #endif
461 #ifdef WITH_WIRETAP
462     "wiretap");
463 #else
464     "libpcap");
465 #endif
466
467   /* Now get our args */
468   while ((opt = getopt(argc, argv, "b:B:c:hi:m:nP:r:s:t:T:w:v")) != EOF) {
469     switch (opt) {
470       case 'b':        /* Bold font */
471         bold_font = g_strdup(optarg);
472         break;
473       case 'B':        /* Byte view pane height */
474         bv_size = atoi(optarg);
475         break;
476       case 'c':        /* Capture xxx packets */
477         cf.count = atoi(optarg);
478         break;
479       case 'h':        /* Print help and exit */
480         print_usage();
481         exit(0);
482         break;
483       case 'i':        /* Use interface xxx */
484         cf.iface = g_strdup(optarg);
485         break;
486       case 'm':        /* Medium font */
487         medium_font = g_strdup(optarg);
488         break;
489       case 'n':        /* No name resolution */
490         g_resolving_actif = 0;
491         break;
492       case 'k':        /* Start capture immediately */
493         start_capture = 1;
494         break;
495       case 'P':        /* Packet list pane height */
496         pl_size = atoi(optarg);
497         break;
498       case 'r':        /* Read capture file xxx */
499         cf_name = g_strdup(optarg);
500         break;
501       case 's':        /* Set the snapshot (capture) length */
502         cf.snap = atoi(optarg);
503         break;
504       case 't':        /* Time stamp type */
505         if (strcmp(optarg, "r") == 0)
506           timestamp_type = RELATIVE;
507         else if (strcmp(optarg, "a") == 0)
508           timestamp_type = ABSOLUTE;
509         else if (strcmp(optarg, "d") == 0)
510           timestamp_type = DELTA;
511         else {
512           fprintf(stderr, "ethereal: Invalid time stamp type \"%s\"\n",
513             optarg);
514           fprintf(stderr, "It must be \"r\" for relative, \"a\" for absolute,\n");
515           fprintf(stderr, "or \"d\" for delta.\n");
516           exit(1);
517         }
518         break;
519       case 'T':        /* Tree view pane height */
520         tv_size = atoi(optarg);
521         break;
522       case 'v':        /* Show version and exit */
523         printf("%s %s, with %s\n", PACKAGE, VERSION, comp_info_str);
524         exit(0);
525         break;
526       case 'w':        /* Write capture file xxx */
527         cf.save_file = g_strdup(optarg);
528         break;
529     }
530   }
531
532   /* Build the column format array */  
533   col_fmt   = (gint *) g_malloc(sizeof(gint) * cf.cinfo.num_cols);
534   col_title = (gchar **) g_malloc(sizeof(gchar *) * cf.cinfo.num_cols);
535   
536   for (i = 0; i < cf.cinfo.num_cols; i++) {
537     col_fmt[i]   = get_column_format(i);
538     col_title[i] = g_strdup(get_column_title(i));
539     cf.cinfo.fmt_matx[i] = (gboolean *) g_malloc0(sizeof(gboolean) *
540       NUM_COL_FMTS);
541     get_column_format_matches(cf.cinfo.fmt_matx[i], col_fmt[i]);
542     cf.cinfo.col_data[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
543   }
544
545   if (cf.snap < 1)
546     cf.snap = 4096;
547   else if (cf.snap < 68)
548     cf.snap = 68;
549   
550   rc_file = (gchar *) g_malloc(strlen(getenv("HOME")) + strlen(RC_FILE) + 4);
551   sprintf(rc_file, "%s/%s", getenv("HOME"), RC_FILE);
552   gtk_rc_parse(rc_file);
553
554   if ((m_r_font = gdk_font_load(medium_font)) == NULL) {
555     fprintf(stderr, "Error font %s not found (use -m option)\n", medium_font);
556     exit(1);
557   }
558
559   if ((m_b_font = gdk_font_load(bold_font)) == NULL) {
560     fprintf(stderr, "Error font %s not found (use -b option)\n", bold_font);
561     exit(1);
562   }
563
564   /* Main window */  
565   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
566   gtk_widget_set_name(window, "main window");
567   gtk_signal_connect(GTK_OBJECT(window), "delete_event",
568     GTK_SIGNAL_FUNC(file_quit_cmd_cb), "WM destroy");
569   gtk_signal_connect(GTK_OBJECT(window), "destroy", 
570     GTK_SIGNAL_FUNC(file_quit_cmd_cb), "WM destroy");
571   gtk_signal_connect(GTK_OBJECT (window), "realize",
572     GTK_SIGNAL_FUNC(main_realize_cb), cf_name);
573   gtk_window_set_title(GTK_WINDOW(window), "The Ethereal Network Analyzer");
574   gtk_widget_set_usize(GTK_WIDGET(window), DEF_WIDTH, -1);
575   gtk_window_set_policy(GTK_WINDOW(window), TRUE, TRUE, FALSE);
576
577   /* Container for menu bar, paned windows and progress/info box */
578   main_vbox = gtk_vbox_new(FALSE, 1);
579   gtk_container_border_width(GTK_CONTAINER(main_vbox), 1);
580   gtk_container_add(GTK_CONTAINER(window), main_vbox);
581   gtk_widget_show(main_vbox);
582
583   /* Menu bar */
584   get_main_menu(&menubar, &accel);
585 #ifdef GTK_HAVE_FEATURES_1_1_0
586   gtk_window_add_accel_group(GTK_WINDOW(window), accel);
587 #else
588   gtk_window_add_accelerator_table(GTK_WINDOW(window), accel);
589 #endif
590   gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0);
591   gtk_widget_show(menubar);
592
593   /* Panes for the packet list, tree, and byte view */
594   u_pane = gtk_vpaned_new();
595   gtk_paned_gutter_size(GTK_PANED(u_pane), (GTK_PANED(u_pane))->handle_size);
596   l_pane = gtk_vpaned_new();
597   gtk_paned_gutter_size(GTK_PANED(l_pane), (GTK_PANED(l_pane))->handle_size);
598   gtk_container_add(GTK_CONTAINER(main_vbox), u_pane);
599   gtk_widget_show(u_pane);
600   gtk_paned_add2 (GTK_PANED(u_pane), l_pane);
601   gtk_widget_show(l_pane);
602
603   /* Packet list */
604   packet_list = gtk_clist_new_with_titles(cf.cinfo.num_cols, col_title);
605   gtk_clist_column_titles_passive(GTK_CLIST(packet_list));
606 #ifdef GTK_HAVE_FEATURES_1_1_4
607   packet_sw = gtk_scrolled_window_new(NULL, NULL);
608   gtk_widget_show(packet_sw);
609   gtk_container_add(GTK_CONTAINER(packet_sw), packet_list);
610 #endif
611   pl_style = gtk_style_new();
612   gdk_font_unref(pl_style->font);
613   pl_style->font = m_r_font;
614   gtk_widget_set_style(packet_list, pl_style);
615   gtk_widget_set_name(packet_list, "packet list");
616   gtk_signal_connect(GTK_OBJECT(packet_list), "select_row",
617     GTK_SIGNAL_FUNC(packet_list_select_cb), NULL);
618   gtk_signal_connect(GTK_OBJECT(packet_list), "unselect_row",
619     GTK_SIGNAL_FUNC(packet_list_unselect_cb), NULL);
620   for (i = 0; i < cf.cinfo.num_cols; i++) {
621     gtk_clist_set_column_width(GTK_CLIST(packet_list), i,
622       get_column_width(get_column_format(i), pl_style->font));
623     if (col_fmt[i] == COL_NUMBER)
624       gtk_clist_set_column_justification(GTK_CLIST(packet_list), i, 
625         GTK_JUSTIFY_RIGHT);
626   }
627   gtk_widget_set_usize(packet_list, -1, pl_size);
628 #ifdef GTK_HAVE_FEATURES_1_1_4
629   gtk_paned_add1(GTK_PANED(u_pane), packet_sw);
630 #else
631   gtk_paned_add1(GTK_PANED(u_pane), packet_list);
632 #endif
633   gtk_widget_show(packet_list);
634   
635   /* Tree view */
636   tv_scrollw = gtk_scrolled_window_new(NULL, NULL);
637   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(tv_scrollw),
638     GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
639   gtk_paned_add1(GTK_PANED(l_pane), tv_scrollw);
640   gtk_widget_set_usize(tv_scrollw, -1, tv_size);
641   gtk_widget_show(tv_scrollw);
642   
643   tree_view = gtk_tree_new();
644 #ifdef GTK_HAVE_FEATURES_1_1_4
645   gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(tv_scrollw),
646                   tree_view);
647 #else
648   gtk_container_add(GTK_CONTAINER(tv_scrollw), tree_view);
649 #endif
650   gtk_tree_set_selection_mode(GTK_TREE(tree_view), GTK_SELECTION_SINGLE);
651   gtk_tree_set_view_lines(GTK_TREE(tree_view), FALSE);
652   gtk_tree_set_view_mode(GTK_TREE(tree_view), TRUE);
653   gtk_signal_connect(GTK_OBJECT(tree_view), "selection_changed",
654     GTK_SIGNAL_FUNC(tree_view_cb), NULL);
655   gtk_widget_show(tree_view);
656
657   item_style = gtk_style_new();
658   gdk_font_unref(item_style->font);
659   item_style->font = m_r_font;
660
661   /* Byte view */
662   bv_table = gtk_table_new (2, 2, FALSE);
663   gtk_paned_add2(GTK_PANED(l_pane), bv_table);
664   gtk_widget_set_usize(bv_table, -1, bv_size);
665   gtk_widget_show(bv_table);
666
667   byte_view = gtk_text_new(NULL, NULL);
668   gtk_text_set_editable(GTK_TEXT(byte_view), FALSE);
669   gtk_text_set_word_wrap(GTK_TEXT(byte_view), FALSE);
670   gtk_table_attach (GTK_TABLE (bv_table), byte_view, 0, 1, 0, 1,
671     GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0);
672   gtk_widget_show(byte_view);
673
674   bv_hscroll = gtk_hscrollbar_new(GTK_TEXT(byte_view)->hadj);
675   gtk_table_attach(GTK_TABLE(bv_table), bv_hscroll, 0, 1, 1, 2,
676     GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
677   gtk_widget_show (bv_hscroll);
678
679   bv_vscroll = gtk_vscrollbar_new(GTK_TEXT(byte_view)->vadj);
680   gtk_table_attach(GTK_TABLE(bv_table), bv_vscroll, 1, 2, 0, 1,
681     GTK_FILL, GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0);
682   gtk_widget_show(bv_vscroll);
683   
684   /* Progress/filter/info box */
685   stat_hbox = gtk_hbox_new(FALSE, 1);
686   gtk_container_border_width(GTK_CONTAINER(stat_hbox), 0);
687   gtk_box_pack_start(GTK_BOX(main_vbox), stat_hbox, FALSE, TRUE, 0);
688   gtk_widget_show(stat_hbox);
689
690   prog_bar = gtk_progress_bar_new();  
691   gtk_box_pack_start(GTK_BOX(stat_hbox), prog_bar, FALSE, TRUE, 3);
692   gtk_widget_show(prog_bar);
693
694   filter_bt = gtk_button_new_with_label("Filter:");
695   gtk_signal_connect(GTK_OBJECT(filter_bt), "clicked",
696     GTK_SIGNAL_FUNC(prefs_cb), (gpointer) E_PR_PG_FILTER);
697   gtk_box_pack_start(GTK_BOX(stat_hbox), filter_bt, FALSE, TRUE, 0);
698   gtk_widget_show(filter_bt);
699 #ifdef WITH_WIRETAP
700   gtk_widget_set_sensitive(filter_bt, FALSE);
701 #endif
702   
703   filter_te = gtk_entry_new();
704   gtk_object_set_data(GTK_OBJECT(filter_bt), E_FILT_TE_PTR_KEY, filter_te);
705   gtk_box_pack_start(GTK_BOX(stat_hbox), filter_te, TRUE, TRUE, 3);
706   gtk_widget_show(filter_te);
707 #ifdef WITH_WIRETAP
708   gtk_widget_set_sensitive(filter_te, FALSE);
709   gtk_entry_set_text(GTK_ENTRY(filter_te), "<unavailable>");
710 #endif
711
712   set_menu_object_data("<Main>/File/Open", E_DFILTER_TE_KEY, filter_te);
713   set_menu_object_data("<Main>/File/Reload", E_DFILTER_TE_KEY, filter_te);
714   set_menu_object_data("<Main>/Tools/Follow TCP Stream", E_DFILTER_TE_KEY,
715     filter_te);
716
717   info_bar = gtk_statusbar_new();
718   main_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "main");
719   file_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "file");
720   gtk_statusbar_push(GTK_STATUSBAR(info_bar), main_ctx, DEF_READY_MESSAGE);
721   gtk_box_pack_start(GTK_BOX(stat_hbox), info_bar, TRUE, TRUE, 0);
722   gtk_widget_show(info_bar);
723
724   gtk_widget_show(window);
725   gtk_main();
726
727   exit(0);
728 }