- Added match_strval function to packet.c
[obnox/wireshark/wip.git] / ethereal.c
1 /* ethereal.c
2  *
3  * $Id: ethereal.c,v 1.5 1998/10/12 01:40:47 gerald 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>
48
49 #include <stdio.h>
50 #include <string.h>
51 #include <unistd.h>
52 #include <sys/types.h>
53 #include <sys/stat.h>
54 #include <fcntl.h>
55 #include <netinet/in.h>
56
57 #include "ethereal.h"
58 #include "capture.h"
59 #include "packet.h"
60 #include "file.h"
61 #include "menu.h"
62 #include "etypes.h"
63 #include "print.h"
64 #include "resolv.h"
65 #include "follow.h"
66 #include "util.h"
67 #include "prefs.h"
68
69 FILE        *data_out_file = NULL;
70 packet_info  pi;
71 capture_file cf;
72 GtkWidget   *file_sel, *packet_list, *tree_view, *byte_view, *prog_bar,
73             *info_bar;
74 GdkFont     *m_r_font, *m_b_font;
75 guint        main_ctx, file_ctx;
76 frame_data  *fd;
77 gint         start_capture = 0;
78
79 extern pr_opts printer_opts;
80
81 ts_type timestamp_type = RELATIVE;
82
83 #define E_DFILTER_TE_KEY "display_filter_te"
84
85 /* Things to do when the OK button is pressed */
86 void
87 file_sel_ok_cb(GtkWidget *w, GtkFileSelection *fs) {
88   gchar     *cf_name;
89   int        err;
90   GtkWidget *filter_te = gtk_object_get_data(GTK_OBJECT(w), E_DFILTER_TE_KEY);
91
92   cf_name = g_strdup(gtk_file_selection_get_filename(GTK_FILE_SELECTION (fs)));
93   gtk_widget_hide(GTK_WIDGET (fs));
94   gtk_widget_destroy(GTK_WIDGET (fs));
95
96   if (cf.dfilter) g_free(cf.dfilter);
97   cf.dfilter = g_strdup(gtk_entry_get_text(GTK_ENTRY(filter_te)));
98   if ((err = load_cap_file(cf_name, &cf)) == 0)
99     chdir(cf_name);
100   g_free(cf_name);
101 }
102
103 /* Update the progress bar */
104 gint
105 file_progress_cb(gpointer p) {
106   gtk_progress_bar_update(GTK_PROGRESS_BAR(prog_bar),
107     (gfloat) ftell(cf.fh) / (gfloat) cf.f_len);
108   return TRUE;
109 }
110
111 /* Follow a TCP stream */
112 void
113 follow_stream_cb( GtkWidget *w, gpointer data ) {
114   char filename1[128];
115   GtkWidget *streamwindow, *box, *text, *vscrollbar, *table;
116   GtkWidget *filter_te = gtk_object_get_data(GTK_OBJECT(w),
117     E_DFILTER_TE_KEY);
118   if( pi.ipproto == 6 ) {
119     /* we got tcp so we can follow */
120     /* check to see if we are using a filter */
121     if( cf.dfilter != NULL ) {
122       /* get rid of this one */
123       g_free( cf.dfilter );
124       cf.dfilter = NULL;
125     }
126     /* create a new one and set the display filter entry accordingly */
127     cf.dfilter = build_follow_filter( &pi );
128     gtk_entry_set_text(GTK_ENTRY(filter_te), cf.dfilter);
129     /* reload so it goes in effect. Also we set data_out_file which 
130        tells the tcp code to output the data */
131     close_cap_file( &cf, info_bar, file_ctx);
132     strcpy( filename1, tmpnam(NULL) );
133     data_out_file = fopen( filename1, "a" );
134     if( data_out_file == NULL ) {
135       fprintf( stderr, "Could not open tmp file %s\n", filename1 );
136     }
137     reset_tcp_reassembly();
138     load_cap_file( cf.filename, &cf );
139     /* the data_out_file should now be full of the streams information */
140     fclose( data_out_file );
141     /* the filename1 file now has all the text that was in the session */
142     streamwindow = gtk_window_new( GTK_WINDOW_TOPLEVEL);
143     gtk_widget_set_name( streamwindow, "TCP stream window" );
144     gtk_signal_connect( GTK_OBJECT(streamwindow), "delete_event",
145                         NULL, "WM destroy" );
146     gtk_signal_connect( GTK_OBJECT(streamwindow), "destroy",
147                         NULL, "WM destroy" );
148     gtk_window_set_title( GTK_WINDOW(streamwindow), "Contents of TCP stream" );
149     gtk_widget_set_usize( GTK_WIDGET(streamwindow), DEF_WIDTH, DEF_HEIGHT );
150     gtk_container_border_width( GTK_CONTAINER(streamwindow), 2 );
151     /* setup the container */
152     box = gtk_vbox_new( FALSE, 0 );
153     gtk_container_add( GTK_CONTAINER(streamwindow), box );
154     gtk_widget_show( box );
155     /* set up the table we attach to */
156     table = gtk_table_new( 1, 2, FALSE );
157     gtk_table_set_col_spacing( GTK_TABLE(table), 0, 2);
158     gtk_box_pack_start( GTK_BOX(box), table, TRUE, TRUE, 0 );
159     gtk_widget_show( table );
160     /* create a text box */
161     text = gtk_text_new( NULL, NULL );
162     gtk_text_set_editable( GTK_TEXT(text), FALSE);
163     gtk_table_attach( GTK_TABLE(table), text, 0, 1, 0, 1,
164                       GTK_EXPAND | GTK_SHRINK | GTK_FILL,
165                       GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0 );
166     gtk_widget_show(text);
167     /* create the scrollbar */
168     vscrollbar = gtk_vscrollbar_new( GTK_TEXT(text)->vadj );
169     gtk_table_attach( GTK_TABLE(table), vscrollbar, 1, 2, 0, 1,
170                       GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0 );
171     gtk_widget_show( vscrollbar );
172     gtk_widget_realize( text );
173     /* stop the updates while we fill the text box */
174     gtk_text_freeze( GTK_TEXT(text) );
175     data_out_file = NULL;
176     data_out_file = fopen( filename1, "r" );
177     if( data_out_file ) {
178       char buffer[1024];
179       int nchars;
180       while( 1 ) {
181         nchars = fread( buffer, 1, 1024, data_out_file );
182         gtk_text_insert( GTK_TEXT(text), m_r_font, NULL, NULL, buffer, nchars );
183         if( nchars < 1024 ) {
184           break;
185         }
186       }
187       fclose( data_out_file );
188       unlink( filename1 );
189     }
190     gtk_text_thaw( GTK_TEXT(text) );
191     data_out_file = NULL;
192     gtk_widget_show( streamwindow );
193     if( cf.dfilter != NULL ) {
194       g_free( cf.dfilter );
195       cf.dfilter = NULL;
196     }
197   } else {
198     simple_dialog(ESD_TYPE_WARN, NULL,
199       "Error following stream.  Please make\n"
200       "sure you have a TCP packet selected.");
201   }
202 }
203
204 /* Open a file */
205 void
206 file_open_cmd_cb(GtkWidget *w, gpointer data) {
207   file_sel = gtk_file_selection_new ("Ethereal: Open Capture File");
208   
209   /* Connect the ok_button to file_ok_sel_cb function and pass along the
210      pointer to the filter entry */
211   gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_sel)->ok_button),
212     "clicked", (GtkSignalFunc) file_sel_ok_cb, file_sel );
213   gtk_object_set_data(GTK_OBJECT(GTK_FILE_SELECTION(file_sel)->ok_button),
214     E_DFILTER_TE_KEY, gtk_object_get_data(GTK_OBJECT(w), E_DFILTER_TE_KEY));
215
216   /* Connect the cancel_button to destroy the widget */
217   gtk_signal_connect_object(GTK_OBJECT (GTK_FILE_SELECTION
218     (file_sel)->cancel_button), "clicked", (GtkSignalFunc)
219     gtk_widget_destroy, GTK_OBJECT (file_sel));
220
221   gtk_file_selection_set_filename(GTK_FILE_SELECTION(file_sel), "");
222
223   gtk_widget_show(file_sel);
224 }
225
226 /* Close a file */
227 void
228 file_close_cmd_cb(GtkWidget *widget, gpointer data) {
229   close_cap_file(&cf, info_bar, file_ctx);
230   set_menu_sensitivity("<Main>/File/Close", FALSE);
231   set_menu_sensitivity("<Main>/File/Reload", FALSE);
232 }
233
234 /* Reload a file using the current display filter */
235 void
236 file_reload_cmd_cb(GtkWidget *w, gpointer data) {
237   GtkWidget *filter_te = gtk_object_get_data(GTK_OBJECT(w), E_DFILTER_TE_KEY);
238
239   if (cf.dfilter) g_free(cf.dfilter);
240   cf.dfilter = g_strdup(gtk_entry_get_text(GTK_ENTRY(filter_te)));
241   load_cap_file(cf.filename, &cf);
242 }
243
244 /* Print a packet */
245 void
246 file_print_cmd_cb(GtkWidget *widget, gpointer data) {
247     print_tree(cf.pd, fd, GTK_TREE(tree_view));
248 }
249
250 /* What to do when a list item is selected/unselected */
251 void
252 packet_list_select_cb(GtkWidget *w, gint row, gint col, gpointer evt) {
253   GList      *l;
254   
255   blank_packetinfo();
256   gtk_text_freeze(GTK_TEXT(byte_view));
257   gtk_text_set_point(GTK_TEXT(byte_view), 0);
258   gtk_text_forward_delete(GTK_TEXT(byte_view),
259     gtk_text_get_length(GTK_TEXT(byte_view)));
260   l = g_list_nth(cf.plist, row);
261   if (l) {
262     fd = (frame_data *) l->data;
263     fseek(cf.fh, fd->file_off, SEEK_SET);
264     fread(cf.pd, sizeof(guint8), fd->cap_len, cf.fh);
265     dissect_packet(cf.pd, 0, 0, fd, GTK_TREE(tree_view));
266     packet_hex_print(GTK_TEXT(byte_view), cf.pd, fd->cap_len, -1, -1);
267   }
268   gtk_text_thaw(GTK_TEXT(byte_view));
269 }
270
271 void
272 packet_list_unselect_cb(GtkWidget *w, gint row, gint col, gpointer evt) {
273   gtk_text_freeze(GTK_TEXT(byte_view));
274   gtk_text_set_point(GTK_TEXT(byte_view), 0);
275   gtk_text_forward_delete(GTK_TEXT(byte_view),
276     gtk_text_get_length(GTK_TEXT(byte_view)));
277   gtk_text_thaw(GTK_TEXT(byte_view));
278   gtk_tree_clear_items(GTK_TREE(tree_view), 0,
279     g_list_length(GTK_TREE(tree_view)->children));
280 }
281
282 void
283 tree_view_cb(GtkWidget *w) {
284   gint       start = -1, len = -1;
285
286   if (GTK_TREE(w)->selection) {
287     start = (gint) gtk_object_get_data(GTK_OBJECT(GTK_TREE(w)->selection->data),
288       E_TREEINFO_START_KEY);
289     len   = (gint) gtk_object_get_data(GTK_OBJECT(GTK_TREE(w)->selection->data),
290       E_TREEINFO_LEN_KEY);
291   }
292
293   gtk_text_freeze(GTK_TEXT(byte_view));
294   gtk_text_set_point(GTK_TEXT(byte_view), 0);
295   gtk_text_forward_delete(GTK_TEXT(byte_view),
296     gtk_text_get_length(GTK_TEXT(byte_view)));
297   packet_hex_print(GTK_TEXT(byte_view), cf.pd, fd->cap_len, start, len);
298   gtk_text_thaw(GTK_TEXT(byte_view));
299 }
300
301 void
302 file_quit_cmd_cb (GtkWidget *widget, gpointer data) {
303   gtk_exit(0);
304 }
305
306 void blank_packetinfo() {
307   pi.srcip    = 0;
308   pi.destip   = 0;
309   pi.ipproto  = 0;
310   pi.srcport  = 0;
311   pi.destport = 0;
312 }
313
314 /* Things to do when the OK button is pressed */
315 void
316 main_realize_cb(GtkWidget *w, gpointer data) {
317   gchar  *cf_name = (gchar *) data;
318   int     err;
319   
320   if (cf_name) {
321     err = load_cap_file(cf_name, &cf);
322     cf_name[0] = '\0';
323   }
324   if (start_capture) {
325     if (cf.save_file)
326       capture(1);
327     else
328       capture(0);
329     start_capture = 0;
330   }
331 }
332
333 void 
334 print_usage(void) {
335
336   fprintf(stderr, "This is GNU %s %s\n", PACKAGE, VERSION);
337   fprintf(stderr, "%s [-v] [-b bold font] [-B byte view height] [-c count] [-h]\n",
338           PACKAGE);
339   fprintf(stderr, "         [-i interface] [-m medium font] [-n] [-P packet list height]\n");
340   fprintf(stderr, "         [-r infile] [-s snaplen] [-t <time stamp format>]\n");
341   fprintf(stderr, "         [-T tree view height] [-w savefile] \n");
342 }
343
344 int
345 main(int argc, char *argv[])
346 {
347   int                  opt;
348   extern char         *optarg;
349   GtkWidget           *window, *main_vbox, *menubar, *u_pane, *l_pane,
350                       *bv_table, *bv_hscroll, *bv_vscroll, *stat_hbox, 
351                       *tv_scrollw, *filter_bt, *filter_te;
352   GtkStyle            *pl_style;
353   GtkAcceleratorTable *accel;
354   gint                 col_width, pl_size = 280, tv_size = 95, bv_size = 75;
355   gchar               *rc_file, *cf_name = NULL;
356   gchar               *cl_title[] = {"No.", "Time", "Source", "Destination",
357                       "Protocol", "Info"};
358   gchar               *medium_font = MONO_MEDIUM_FONT;
359   gchar               *bold_font = MONO_BOLD_FONT;
360
361   /* Initialize the capture file struct */
362   cf.plist     = NULL;
363   cf.pfh       = NULL;
364   cf.fh        = NULL;
365   cf.dfilter   = NULL;
366   cf.cfilter   = NULL;
367   cf.iface     = NULL;
368   cf.save_file = NULL;
369   cf.snap      = 68;
370   cf.count     = 0;
371     
372   /* Let GTK get its args */
373   gtk_init (&argc, &argv);
374
375   /* Now get our args */
376   while ((opt = getopt(argc, argv, "b:B:c:hi:m:nP:r:s:t:T:w:v")) != EOF) {
377     switch (opt) {
378       case 'b':        /* Bold font */
379         bold_font = g_strdup(optarg);
380         break;
381       case 'B':        /* Byte view pane height */
382         bv_size = atoi(optarg);
383         break;
384       case 'c':        /* Capture xxx packets */
385         cf.count = atoi(optarg);
386         break;
387       case 'h':        /* Print help and exit */
388         print_usage();
389         exit(0);
390         break;
391       case 'i':        /* Use interface xxx */
392         cf.iface = g_strdup(optarg);
393         break;
394       case 'm':        /* Medium font */
395         medium_font = g_strdup(optarg);
396         break;
397       case 'n':        /* No name resolution */
398         g_resolving_actif = 0;
399         break;
400       case 'k':        /* Start capture immediately */
401         start_capture = 1;
402         break;
403       case 'P':        /* Packet list pane height */
404         pl_size = atoi(optarg);
405         break;
406       case 'r':        /* Read capture file xxx */
407         cf_name = g_strdup(optarg);
408         break;
409       case 's':        /* Set the snapshot (capture) length */
410         cf.snap = atoi(optarg);
411         break;
412       case 't':        /* Time stamp type */
413         if (strcmp(optarg, "r") == 0)
414           timestamp_type = RELATIVE;
415         else if (strcmp(optarg, "a") == 0)
416           timestamp_type = ABSOLUTE;
417         else if (strcmp(optarg, "d") == 0)
418           timestamp_type = DELTA;
419         else {
420           fprintf(stderr, "ethereal: Invalid time stamp type \"%s\"\n",
421             optarg);
422           fprintf(stderr, "It must be \"r\" for relative, \"a\" for absolute,\n");
423           fprintf(stderr, "or \"d\" for delta.\n");
424           exit(1);
425         }
426         break;
427       case 'T':        /* Tree view pane height */
428         tv_size = atoi(optarg);
429         break;
430       case 'v':        /* Show version and exit */
431         printf("%s %s\n", PACKAGE, VERSION);
432         exit(0);
433         break;
434       case 'w':        /* Write capture file xxx */
435         cf.save_file = g_strdup(optarg);
436         break;
437     }
438   }
439   
440   if (cf.snap < 1)
441     cf.snap = 4096;
442   else if (cf.snap < 68)
443     cf.snap = 68;
444   
445   rc_file = (gchar *) g_malloc(strlen(getenv("HOME")) + strlen(RC_FILE) + 4);
446   sprintf(rc_file, "%s/%s", getenv("HOME"), RC_FILE);
447   gtk_rc_parse(rc_file);
448
449   /* initialize printer options. temporary! we should only initialize
450    * if the options are not set in some ethereal initialization file */
451   printer_opts.output_format = 0;
452   printer_opts.output_dest = 0;
453   printer_opts.file = g_strdup("ethereal.out");
454   printer_opts.cmd = g_strdup("lpr");
455
456   if ((m_r_font = gdk_font_load(medium_font)) == NULL) {
457     fprintf(stderr, "Error font %s not found (use -m option)\n", medium_font);
458     exit(1);
459   }
460
461   if ((m_b_font = gdk_font_load(bold_font)) == NULL) {
462     fprintf(stderr, "Error font %s not found (use -b option)\n", bold_font);
463     exit(1);
464   }
465
466   /* Main window */  
467   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
468   gtk_widget_set_name(window, "main window");
469   gtk_signal_connect(GTK_OBJECT(window), "delete_event",
470     GTK_SIGNAL_FUNC(file_quit_cmd_cb), "WM destroy");
471   gtk_signal_connect(GTK_OBJECT(window), "destroy", 
472     GTK_SIGNAL_FUNC(file_quit_cmd_cb), "WM destroy");
473   gtk_signal_connect(GTK_OBJECT (window), "realize",
474     GTK_SIGNAL_FUNC(main_realize_cb), cf_name);
475   gtk_window_set_title(GTK_WINDOW(window), "The Ethereal Network Analyzer");
476   gtk_widget_set_usize(GTK_WIDGET(window), DEF_WIDTH, -1);
477
478   /* Container for menu bar, paned windows and progress/info box */
479   main_vbox = gtk_vbox_new(FALSE, 1);
480   gtk_container_border_width(GTK_CONTAINER(main_vbox), 1);
481   gtk_container_add(GTK_CONTAINER(window), main_vbox);
482   gtk_widget_show(main_vbox);
483
484   /* Menu bar */
485   get_main_menu(&menubar, &accel);
486   gtk_window_add_accelerator_table(GTK_WINDOW(window), accel);
487   gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0);
488   gtk_widget_show(menubar);
489
490   /* Panes for the packet list, tree, and byte view */
491   u_pane = gtk_vpaned_new();
492   gtk_paned_gutter_size(GTK_PANED(u_pane), (GTK_PANED(u_pane))->handle_size);
493   l_pane = gtk_vpaned_new();
494   gtk_paned_gutter_size(GTK_PANED(l_pane), (GTK_PANED(l_pane))->handle_size);
495   gtk_container_add(GTK_CONTAINER(main_vbox), u_pane);
496   gtk_widget_show(u_pane);
497   gtk_paned_add2 (GTK_PANED(u_pane), l_pane);
498   gtk_widget_show(l_pane);
499
500   /* Packet list */
501   packet_list = gtk_clist_new_with_titles(NUM_COLS, cl_title);
502   pl_style = gtk_style_new();
503   gdk_font_unref(pl_style->font);
504   pl_style->font = m_r_font;
505   gtk_widget_set_style(packet_list, pl_style);
506   gtk_widget_set_name(packet_list, "packet list");
507   gtk_signal_connect(GTK_OBJECT(packet_list), "select_row",
508     GTK_SIGNAL_FUNC(packet_list_select_cb), NULL);
509   gtk_signal_connect(GTK_OBJECT(packet_list), "unselect_row",
510     GTK_SIGNAL_FUNC(packet_list_unselect_cb), NULL);
511   gtk_clist_set_column_justification(GTK_CLIST(packet_list), 0, 
512     GTK_JUSTIFY_RIGHT);
513   col_width = (gdk_string_width(pl_style->font, "0") * 7) + 2;
514   gtk_clist_set_column_width(GTK_CLIST(packet_list), COL_NUM, col_width);
515   if (timestamp_type == ABSOLUTE)
516     col_width = gdk_string_width(pl_style->font, "00:00:00.000000");
517   else
518     col_width = gdk_string_width(pl_style->font, "0000.000000");
519   gtk_clist_set_column_width(GTK_CLIST(packet_list), COL_TIME, col_width);
520   col_width = gdk_string_width(pl_style->font, "00:00:00:00:00:00") + 2;
521   gtk_clist_set_column_width(GTK_CLIST(packet_list), COL_SOURCE, col_width);
522   gtk_clist_set_column_width(GTK_CLIST(packet_list), COL_DESTINATION, col_width);
523   col_width = gdk_string_width(pl_style->font, "AppleTalk") + 2;
524   gtk_clist_set_column_width(GTK_CLIST(packet_list), COL_PROTOCOL, col_width);
525   gtk_widget_set_usize(packet_list, -1, pl_size);
526   gtk_paned_add1(GTK_PANED(u_pane), packet_list);
527   gtk_widget_show(packet_list);
528   
529   /* Tree view */
530   tv_scrollw = gtk_scrolled_window_new(NULL, NULL);
531   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(tv_scrollw),
532     GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
533   gtk_paned_add1(GTK_PANED(l_pane), tv_scrollw);
534   gtk_widget_set_usize(tv_scrollw, -1, tv_size);
535   gtk_widget_show(tv_scrollw);
536   
537   tree_view = gtk_tree_new();
538   gtk_container_add(GTK_CONTAINER(tv_scrollw), tree_view);
539   gtk_tree_set_selection_mode(GTK_TREE(tree_view), GTK_SELECTION_SINGLE);
540   gtk_tree_set_view_lines(GTK_TREE(tree_view), FALSE);
541   gtk_tree_set_view_mode(GTK_TREE(tree_view), TRUE);
542   gtk_signal_connect(GTK_OBJECT(tree_view), "selection_changed",
543     GTK_SIGNAL_FUNC(tree_view_cb), NULL);
544   gtk_widget_show(tree_view);
545
546   /* Byte view */
547   bv_table = gtk_table_new (2, 2, FALSE);
548   gtk_paned_add2(GTK_PANED(l_pane), bv_table);
549   gtk_widget_set_usize(bv_table, -1, bv_size);
550   gtk_widget_show(bv_table);
551
552   byte_view = gtk_text_new(NULL, NULL);
553   gtk_text_set_editable(GTK_TEXT(byte_view), FALSE);
554   gtk_text_set_word_wrap(GTK_TEXT(byte_view), FALSE);
555   gtk_table_attach (GTK_TABLE (bv_table), byte_view, 0, 1, 0, 1,
556     GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0);
557   gtk_widget_show(byte_view);
558
559   bv_hscroll = gtk_hscrollbar_new(GTK_TEXT(byte_view)->hadj);
560   gtk_table_attach(GTK_TABLE(bv_table), bv_hscroll, 0, 1, 1, 2,
561     GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
562   gtk_widget_show (bv_hscroll);
563
564   bv_vscroll = gtk_vscrollbar_new(GTK_TEXT(byte_view)->vadj);
565   gtk_table_attach(GTK_TABLE(bv_table), bv_vscroll, 1, 2, 0, 1,
566     GTK_FILL, GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0);
567   gtk_widget_show(bv_vscroll);
568   
569   /* Progress/filter/info box */
570   stat_hbox = gtk_hbox_new(FALSE, 1);
571   gtk_container_border_width(GTK_CONTAINER(stat_hbox), 0);
572   gtk_box_pack_start(GTK_BOX(main_vbox), stat_hbox, FALSE, TRUE, 0);
573   gtk_widget_show(stat_hbox);
574
575   prog_bar = gtk_progress_bar_new();  
576   gtk_box_pack_start(GTK_BOX(stat_hbox), prog_bar, FALSE, TRUE, 3);
577   gtk_widget_show(prog_bar);
578
579   filter_bt = gtk_button_new_with_label("Filter:");
580   gtk_signal_connect(GTK_OBJECT(filter_bt), "clicked",
581     GTK_SIGNAL_FUNC(prefs_cb), (gpointer) E_PR_PG_FILTER);
582   gtk_box_pack_start(GTK_BOX(stat_hbox), filter_bt, FALSE, TRUE, 0);
583   gtk_widget_show(filter_bt);
584   
585   filter_te = gtk_entry_new();
586   gtk_object_set_data(GTK_OBJECT(filter_bt), E_FILT_TE_PTR_KEY, filter_te);
587   gtk_box_pack_start(GTK_BOX(stat_hbox), filter_te, TRUE, TRUE, 3);
588   gtk_widget_show(filter_te);
589   set_menu_object_data("<Main>/File/Open", E_DFILTER_TE_KEY, filter_te);
590   set_menu_object_data("<Main>/File/Reload", E_DFILTER_TE_KEY, filter_te);
591   set_menu_object_data("<Main>/Tools/Follow TCP Stream", E_DFILTER_TE_KEY,
592     filter_te);
593
594   info_bar = gtk_statusbar_new();
595   main_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "main");
596   file_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(info_bar), "file");
597   gtk_statusbar_push(GTK_STATUSBAR(info_bar), main_ctx, DEF_READY_MESSAGE);
598   gtk_box_pack_start(GTK_BOX(stat_hbox), info_bar, TRUE, TRUE, 0);
599   gtk_widget_show(info_bar);
600
601   gtk_widget_show(window);
602   gtk_main();
603
604   exit(0);
605 }