Make sure that the Capture/Start menue item will always use the
[obnox/wireshark/wip.git] / gtk / main.c
1 /* main.c
2  *
3  * $Id$
4  *
5  * Wireshark - Network traffic analyzer
6  * By Gerald Combs <gerald@wireshark.org>
7  * Copyright 1998 Gerald Combs
8  *
9  * Richard Sharpe, 13-Feb-1999, added support for initializing structures
10  *                              needed by dissect routines
11  * Jeff Foster,    2001/03/12,  added support tabbed hex display windowss
12  *
13  *
14  * This program is free software; you can redistribute it and/or
15  * modify it under the terms of the GNU General Public License
16  * as published by the Free Software Foundation; either version 2
17  * of the License, or (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
27  */
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <gtk/gtk.h>
34 #include <gdk/gdkkeysyms.h>
35 #if GTK_CHECK_VERSION(3,0,0)
36 # include <gdk/gdkkeysyms-compat.h>
37 #endif
38
39 #include <stdio.h>
40 #include <string.h>
41 #include <ctype.h>
42 #include <locale.h>
43
44 #ifdef HAVE_UNISTD_H
45 #include <unistd.h>
46 #endif
47
48 #ifdef HAVE_GETOPT_H
49 #include <getopt.h>
50 #else
51 #include "wsutil/wsgetopt.h"
52 #endif
53
54 #ifdef _WIN32 /* Needed for console I/O */
55 #include <fcntl.h>
56 #include <conio.h>
57 #endif
58
59 #ifdef HAVE_LIBPORTAUDIO
60 #include <portaudio.h>
61 #endif /* HAVE_LIBPORTAUDIO */
62
63 #include <epan/epan.h>
64 #include <epan/filesystem.h>
65 #include <wsutil/privileges.h>
66 #include <epan/epan_dissect.h>
67 #include <epan/timestamp.h>
68 #include <epan/packet.h>
69 #include <epan/plugins.h>
70 #include <epan/dfilter/dfilter.h>
71 #include <epan/strutil.h>
72 #include <epan/addr_resolv.h>
73 #include <epan/emem.h>
74 #include <epan/ex-opt.h>
75 #include <epan/funnel.h>
76 #include <epan/expert.h>
77 #include <epan/frequency-utils.h>
78 #include <epan/prefs.h>
79 #include <epan/prefs-int.h>
80 #include <epan/tap.h>
81 #include <epan/stat_cmd_args.h>
82 #include <epan/uat.h>
83 #include <epan/column.h>
84
85 /* general (not GTK specific) */
86 #include "../file.h"
87 #include "../summary.h"
88 #include "../filters.h"
89 #include "../disabled_protos.h"
90 #include "../color.h"
91 #include "../color_filters.h"
92 #include "../print.h"
93 #include "../simple_dialog.h"
94 #include "../main_statusbar.h"
95 #include "../register.h"
96 #include "../ringbuffer.h"
97 #include "../ui_util.h"
98 #include "../util.h"
99 #include "../clopts_common.h"
100 #include "../console_io.h"
101 #include "../cmdarg_err.h"
102 #include "../version_info.h"
103 #include "../merge.h"
104 #include "../alert_box.h"
105 #include "../log.h"
106 #include "../u3.h"
107 #include <wsutil/file_util.h>
108
109 #ifdef HAVE_LIBPCAP
110 #include "../capture_ui_utils.h"
111 #include "../capture-pcap-util.h"
112 #include "../capture_ifinfo.h"
113 #include "../capture.h"
114 #include "../capture_sync.h"
115 #endif
116
117 #ifdef _WIN32
118 #include "../capture-wpcap.h"
119 #include "../capture_wpcap_packet.h"
120 #include <tchar.h> /* Needed for Unicode */
121 #include <wsutil/unicode-utils.h>
122 #include <commctrl.h>
123 #include <shellapi.h>
124 #endif /* _WIN32 */
125
126 /* GTK related */
127 #include "gtk/file_dlg.h"
128 #include "gtk/gtkglobals.h"
129 #include "gtk/color_utils.h"
130 #include "gtk/gui_utils.h"
131 #include "gtk/color_dlg.h"
132 #include "gtk/filter_dlg.h"
133 #include "gtk/uat_gui.h"
134 #include "gtk/main.h"
135 #include "gtk/main_airpcap_toolbar.h"
136 #include "gtk/main_filter_toolbar.h"
137 #include "gtk/menus.h"
138 #include "gtk/macros_dlg.h"
139 #include "gtk/main_statusbar_private.h"
140 #include "gtk/main_toolbar.h"
141 #include "gtk/main_welcome.h"
142 #include "gtk/drag_and_drop.h"
143 #include "gtk/capture_file_dlg.h"
144 #include "gtk/main_proto_draw.h"
145 #include "gtk/keys.h"
146 #include "gtk/packet_win.h"
147 #include "gtk/stock_icons.h"
148 #include "gtk/find_dlg.h"
149 #include "gtk/recent.h"
150 #include "gtk/follow_tcp.h"
151 #include "gtk/font_utils.h"
152 #include "gtk/about_dlg.h"
153 #include "gtk/help_dlg.h"
154 #include "gtk/decode_as_dlg.h"
155 #include "gtk/webbrowser.h"
156 #include "gtk/capture_dlg.h"
157 #include "gtk/capture_if_dlg.h"
158 #include "gtk/tap_param_dlg.h"
159 #include "gtk/prefs_column.h"
160 #include "gtk/prefs_dlg.h"
161 #include "gtk/proto_help.h"
162 #include "gtk/new_packet_list.h"
163
164 #ifdef HAVE_LIBPCAP
165 #include "../image/wsicon16.xpm"
166 #include "../image/wsicon32.xpm"
167 #include "../image/wsicon48.xpm"
168 #include "../image/wsicon64.xpm"
169 #include "../image/wsiconcap16.xpm"
170 #include "../image/wsiconcap32.xpm"
171 #include "../image/wsiconcap48.xpm"
172 #endif
173
174 #ifdef HAVE_AIRPCAP
175 #include <airpcap.h>
176 #include "airpcap_loader.h"
177 #include "airpcap_dlg.h"
178 #include "airpcap_gui_utils.h"
179 #endif
180
181 #include <epan/crypt/airpdcap_ws.h>
182
183
184 #ifdef HAVE_GTKOSXAPPLICATION
185 #include <igemacintegration/gtkosxapplication.h>
186 #endif
187
188 /*
189  * Files under personal and global preferences directories in which
190  * GTK settings for Wireshark are stored.
191  */
192 #define RC_FILE "gtkrc"
193
194 capture_file cfile;
195
196 /* "exported" main widgets */
197 GtkWidget   *top_level = NULL, *pkt_scrollw, *tree_view_gbl, *byte_nb_ptr_gbl;
198
199 /* placement widgets (can be a bit confusing, because of the many layout possibilities */
200 static GtkWidget   *main_vbox, *main_pane_v1, *main_pane_v2, *main_pane_h1, *main_pane_h2;
201 static GtkWidget   *main_first_pane, *main_second_pane;
202
203 /* internally used widgets */
204 static GtkWidget   *menubar, *main_tb, *filter_tb, *tv_scrollw, *statusbar, *welcome_pane;
205
206 #ifdef HAVE_AIRPCAP
207 GtkWidget *airpcap_tb;
208 int    airpcap_dll_ret_val = -1;
209 #endif
210
211 GString *comp_info_str, *runtime_info_str;
212
213 static gboolean have_capture_file = FALSE; /* XXX - is there an equivalent in cfile? */
214
215 static guint  tap_update_timer_id;
216
217 #ifdef _WIN32
218 static gboolean has_console;    /* TRUE if app has console */
219 static gboolean console_wait;   /* "Press any key..." */
220 static void destroy_console(void);
221 static gboolean stdin_capture = FALSE; /* Don't grab stdin & stdout if TRUE */
222 #endif
223 static void console_log_handler(const char *log_domain,
224     GLogLevelFlags log_level, const char *message, gpointer user_data);
225
226 #ifdef HAVE_LIBPCAP
227 capture_options global_capture_opts;
228 #endif
229
230
231 static void create_main_window(gint, gint, gint, e_prefs*);
232 static void show_main_window(gboolean);
233 static void file_quit_answered_cb(gpointer dialog, gint btn, gpointer data);
234 static void main_save_window_geometry(GtkWidget *widget);
235
236
237 /* Match selected byte pattern */
238 static void
239 match_selected_cb_do(gpointer data, int action, gchar *text)
240 {
241     GtkWidget  *filter_te;
242     char       *cur_filter, *new_filter;
243
244     if ((!text) || (0 == strlen(text))) {
245         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Could not acquire information to build a filter!\nTry expanding or choosing another item.");
246         return;
247     }
248
249     g_assert(data);
250     filter_te = g_object_get_data(G_OBJECT(data), E_DFILTER_TE_KEY);
251     g_assert(filter_te);
252
253     cur_filter = gtk_editable_get_chars(GTK_EDITABLE(filter_te), 0, -1);
254
255     switch (action&MATCH_SELECTED_MASK) {
256
257     case MATCH_SELECTED_REPLACE:
258         new_filter = g_strdup(text);
259         break;
260
261     case MATCH_SELECTED_AND:
262         if ((!cur_filter) || (0 == strlen(cur_filter)))
263             new_filter = g_strdup(text);
264         else
265             new_filter = g_strconcat("(", cur_filter, ") && (", text, ")", NULL);
266         break;
267
268     case MATCH_SELECTED_OR:
269         if ((!cur_filter) || (0 == strlen(cur_filter)))
270             new_filter = g_strdup(text);
271         else
272             new_filter = g_strconcat("(", cur_filter, ") || (", text, ")", NULL);
273         break;
274
275     case MATCH_SELECTED_NOT:
276         new_filter = g_strconcat("!(", text, ")", NULL);
277         break;
278
279     case MATCH_SELECTED_AND_NOT:
280         if ((!cur_filter) || (0 == strlen(cur_filter)))
281             new_filter = g_strconcat("!(", text, ")", NULL);
282         else
283             new_filter = g_strconcat("(", cur_filter, ") && !(", text, ")", NULL);
284         break;
285
286     case MATCH_SELECTED_OR_NOT:
287         if ((!cur_filter) || (0 == strlen(cur_filter)))
288             new_filter = g_strconcat("!(", text, ")", NULL);
289         else
290             new_filter = g_strconcat("(", cur_filter, ") || !(", text, ")", NULL);
291         break;
292
293     default:
294         g_assert_not_reached();
295         new_filter = NULL;
296         break;
297     }
298
299     /* Free up the copy we got of the old filter text. */
300     g_free(cur_filter);
301
302     /* Don't change the current display filter if we only want to copy the filter */
303     if (action&MATCH_SELECTED_COPY_ONLY) {
304         GString *gtk_text_str = g_string_new("");
305         g_string_append(gtk_text_str, new_filter);
306         copy_to_clipboard(gtk_text_str);
307         g_string_free(gtk_text_str, TRUE);
308     } else {
309         /* create a new one and set the display filter entry accordingly */
310         gtk_entry_set_text(GTK_ENTRY(filter_te), new_filter);
311
312         /* Run the display filter so it goes in effect. */
313         if (action&MATCH_SELECTED_APPLY_NOW)
314             main_filter_packets(&cfile, new_filter, FALSE);
315     }
316
317     /* Free up the new filter text. */
318     g_free(new_filter);
319 }
320
321 void
322 match_selected_ptree_cb(GtkWidget *w, gpointer data, MATCH_SELECTED_E action)
323 {
324     char *filter = NULL;
325
326     if (cfile.finfo_selected) {
327         filter = proto_construct_match_selected_string(cfile.finfo_selected,
328                                                        cfile.edt);
329         match_selected_cb_do((data ? data : w), action, filter);
330     }
331 }
332
333 void
334 colorize_selected_ptree_cb(GtkWidget *w _U_, gpointer data _U_, guint8 filt_nr)
335 {
336     char *filter = NULL;
337
338     if (cfile.finfo_selected) {
339         filter = proto_construct_match_selected_string(cfile.finfo_selected,
340                                                        cfile.edt);
341         if ((!filter) || (0 == strlen(filter))) {
342             simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
343                 "Could not acquire information to build a filter!\n"
344                 "Try expanding or choosing another item.");
345             return;
346         }
347
348         if (filt_nr==0) {
349             color_display_with_filter(filter);
350         } else {
351             if (filt_nr==255) {
352                 color_filters_reset_tmp();
353             } else {
354                 color_filters_set_tmp(filt_nr,filter, FALSE);
355             }
356             new_packet_list_colorize_packets();
357         }
358     }
359 }
360
361
362 static void selected_ptree_info_answered_cb(gpointer dialog _U_, gint btn, gpointer data)
363 {
364     gchar *selected_proto_url;
365     gchar *proto_abbrev = data;
366
367
368     switch(btn) {
369     case(ESD_BTN_OK):
370         if (cfile.finfo_selected) {
371             /* open wiki page using the protocol abbreviation */
372             selected_proto_url = g_strdup_printf("http://wiki.wireshark.org/Protocols/%s", proto_abbrev);
373             browser_open_url(selected_proto_url);
374             g_free(selected_proto_url);
375         }
376         break;
377     case(ESD_BTN_CANCEL):
378         break;
379     default:
380         g_assert_not_reached();
381     }
382 }
383
384
385 void
386 selected_ptree_info_cb(GtkWidget *widget _U_, gpointer data _U_)
387 {
388     int field_id;
389     const gchar *proto_abbrev;
390     gpointer  dialog;
391
392
393     if (cfile.finfo_selected) {
394         /* convert selected field to protocol abbreviation */
395         /* XXX - could this conversion be simplified? */
396         field_id = cfile.finfo_selected->hfinfo->id;
397         /* if the selected field isn't a protocol, get it's parent */
398         if(!proto_registrar_is_protocol(field_id)) {
399             field_id = proto_registrar_get_parent(cfile.finfo_selected->hfinfo->id);
400         }
401
402         proto_abbrev = proto_registrar_get_abbrev(field_id);
403
404         if (!proto_is_private(field_id)) {
405             /* ask the user if the wiki page really should be opened */
406             dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_OK_CANCEL,
407                     "%sOpen Wireshark Wiki page of protocol \"%s\"?%s\n"
408                     "\n"
409                     "This will open the \"%s\" related Wireshark Wiki page in your Web browser.\n"
410                     "\n"
411                     "The Wireshark Wiki is a collaborative approach to provide information "
412                     "about Wireshark in several ways (not limited to protocol specifics).\n"
413                     "\n"
414                     "This Wiki is new, so the page of the selected protocol "
415                     "may not exist and/or may not contain valuable information.\n"
416                     "\n"
417                     "As everyone can edit the Wiki and add new content (or extend existing), "
418                     "you are encouraged to add information if you can.\n"
419                     "\n"
420                     "Hint 1: If you are new to wiki editing, try out editing the Sandbox first!\n"
421                     "\n"
422                     "Hint 2: If you want to add a new protocol page, you should use the ProtocolTemplate, "
423                     "which will save you a lot of editing and will give a consistent look over the pages.",
424                     simple_dialog_primary_start(), proto_abbrev, simple_dialog_primary_end(), proto_abbrev);
425             simple_dialog_set_cb(dialog, selected_ptree_info_answered_cb, (gpointer)proto_abbrev);
426         } else {
427             /* appologize to the user that the wiki page cannot be opened */
428             simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
429                     "%sCan't open Wireshark Wiki page of protocol \"%s\"%s\n"
430                     "\n"
431                     "This would open the \"%s\" related Wireshark Wiki page in your Web browser.\n"
432                     "\n"
433                     "Since this is a private protocol, such information is not available in "
434                     "a public wiki. Therefore this wiki entry is blocked.\n"
435                     "\n"
436                     "Sorry for the inconvenience.\n",
437                     simple_dialog_primary_start(), proto_abbrev, simple_dialog_primary_end(), proto_abbrev);
438         }
439     }
440 }
441
442 static void selected_ptree_ref_answered_cb(gpointer dialog _U_, gint btn, gpointer data)
443 {
444     gchar *selected_proto_url;
445     gchar *proto_abbrev = data;
446
447     switch(btn) {
448     case(ESD_BTN_OK):
449         if (cfile.finfo_selected) {
450             /* open reference page using the protocol abbreviation */
451             selected_proto_url = g_strdup_printf("http://www.wireshark.org/docs/dfref/%c/%s", proto_abbrev[0], proto_abbrev);
452             browser_open_url(selected_proto_url);
453             g_free(selected_proto_url);
454         }
455         break;
456     case(ESD_BTN_CANCEL):
457         break;
458     default:
459         g_assert_not_reached();
460     }
461 }
462
463 void
464 selected_ptree_ref_cb(GtkWidget *widget _U_, gpointer data _U_)
465 {
466     int field_id;
467     const gchar *proto_abbrev;
468     gpointer  dialog;
469
470
471     if (cfile.finfo_selected) {
472         /* convert selected field to protocol abbreviation */
473         /* XXX - could this conversion be simplified? */
474         field_id = cfile.finfo_selected->hfinfo->id;
475         /* if the selected field isn't a protocol, get it's parent */
476         if(!proto_registrar_is_protocol(field_id)) {
477             field_id = proto_registrar_get_parent(cfile.finfo_selected->hfinfo->id);
478         }
479
480         proto_abbrev = proto_registrar_get_abbrev(field_id);
481
482         if (!proto_is_private(field_id)) {
483             /* ask the user if the wiki page really should be opened */
484             dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_OK_CANCEL,
485                     "%sOpen Wireshark filter reference page of protocol \"%s\"?%s\n"
486                     "\n"
487                     "This will open the \"%s\" related Wireshark filter reference page in your Web browser.\n"
488                     "\n",
489                     simple_dialog_primary_start(), proto_abbrev, simple_dialog_primary_end(), proto_abbrev);
490             simple_dialog_set_cb(dialog, selected_ptree_ref_answered_cb, (gpointer)proto_abbrev);
491         } else {
492             /* appologize to the user that the wiki page cannot be opened */
493             simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
494                     "%sCan't open Wireshark filter reference page of protocol \"%s\"%s\n"
495                     "\n"
496                     "This would open the \"%s\" related Wireshark filter reference page in your Web browser.\n"
497                     "\n"
498                     "Since this is a private protocol, such information is not available on "
499                     "a public website. Therefore this filter entry is blocked.\n"
500                     "\n"
501                     "Sorry for the inconvenience.\n",
502                     simple_dialog_primary_start(), proto_abbrev, simple_dialog_primary_end(), proto_abbrev);
503         }
504     }
505 }
506
507 static gboolean
508 is_address_column (gint column)
509 {
510   if (((cfile.cinfo.col_fmt[column] == COL_DEF_SRC) ||
511        (cfile.cinfo.col_fmt[column] == COL_RES_SRC) ||
512        (cfile.cinfo.col_fmt[column] == COL_DEF_DST) ||
513        (cfile.cinfo.col_fmt[column] == COL_RES_DST)) &&
514       strlen(cfile.cinfo.col_expr.col_expr_val[column]))
515   {
516     return TRUE;
517   }
518
519   return FALSE;
520 }
521
522 GList *
523 get_ip_address_list_from_packet_list_row(gpointer data)
524 {
525     gint    row = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(data), E_MPACKET_LIST_ROW_KEY));
526     gint    column = new_packet_list_get_column_id (GPOINTER_TO_INT(g_object_get_data(G_OBJECT(data), E_MPACKET_LIST_COL_KEY)));
527     gint    col;
528     frame_data *fdata;
529     GList      *addr_list = NULL;
530
531     fdata = (frame_data *) new_packet_list_get_row_data(row);
532
533     if (fdata != NULL) {
534         epan_dissect_t edt;
535
536         if (!cf_read_frame (&cfile, fdata))
537             return NULL; /* error reading the frame */
538
539         epan_dissect_init(&edt, FALSE, FALSE);
540         col_custom_prime_edt(&edt, &cfile.cinfo);
541
542         epan_dissect_run(&edt, &cfile.pseudo_header, cfile.pd, fdata, &cfile.cinfo);
543         epan_dissect_fill_in_columns(&edt, TRUE, TRUE);
544
545         /* First check selected column */
546         if (is_address_column (column)) {
547           addr_list = g_list_append (addr_list, se_strdup_printf("%s", cfile.cinfo.col_expr.col_expr_val[column]));
548         }
549
550         for (col = 0; col < cfile.cinfo.num_cols; col++) {
551           /* Then check all columns except the selected */
552           if ((col != column) && (is_address_column (col))) {
553             addr_list = g_list_append (addr_list, se_strdup_printf("%s", cfile.cinfo.col_expr.col_expr_val[col]));
554           }
555         }
556
557         epan_dissect_cleanup(&edt);
558     }
559
560     return addr_list;
561 }
562
563 static gchar *
564 get_filter_from_packet_list_row_and_column(gpointer data)
565 {
566     gint    row = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(data), E_MPACKET_LIST_ROW_KEY));
567     gint    column = new_packet_list_get_column_id (GPOINTER_TO_INT(g_object_get_data(G_OBJECT(data), E_MPACKET_LIST_COL_KEY)));
568     frame_data *fdata;
569     gchar      *buf=NULL;
570
571     fdata = (frame_data *) new_packet_list_get_row_data(row);
572
573     if (fdata != NULL) {
574         epan_dissect_t edt;
575
576         if (!cf_read_frame(&cfile, fdata))
577             return NULL; /* error reading the frame */
578         /* proto tree, visible. We need a proto tree if there's custom columns */
579         epan_dissect_init(&edt, have_custom_cols(&cfile.cinfo), FALSE);
580         col_custom_prime_edt(&edt, &cfile.cinfo);
581
582         epan_dissect_run(&edt, &cfile.pseudo_header, cfile.pd, fdata,
583                  &cfile.cinfo);
584         epan_dissect_fill_in_columns(&edt, TRUE, TRUE);
585
586         if ((cfile.cinfo.col_custom_occurrence[column]) ||
587             (strchr (cfile.cinfo.col_expr.col_expr_val[column], ',') == NULL))
588         {
589             /* Only construct the filter when a single occurrence is displayed
590              * otherwise we might end up with a filter like "ip.proto==1,6".
591              *
592              * Or do we want to be able to filter on multiple occurrences so that
593              * the filter might be calculated as "ip.proto==1 && ip.proto==6"
594              * instead?
595              */
596             if (strlen(cfile.cinfo.col_expr.col_expr[column]) != 0 &&
597                 strlen(cfile.cinfo.col_expr.col_expr_val[column]) != 0) {
598                 /* leak a little but safer than ep_ here */
599                 if (cfile.cinfo.col_fmt[column] == COL_CUSTOM) {
600                     header_field_info *hfi = proto_registrar_get_byname(cfile.cinfo.col_custom_field[column]);
601                     if (hfi->parent == -1) {
602                         /* Protocol only */
603                         buf = se_strdup(cfile.cinfo.col_expr.col_expr[column]);
604                     } else if (hfi->type == FT_STRING) {
605                         /* Custom string, add quotes */
606                         buf = se_strdup_printf("%s == \"%s\"", cfile.cinfo.col_expr.col_expr[column],
607                                                cfile.cinfo.col_expr.col_expr_val[column]);
608                     }
609                 }
610                 if (buf == NULL) {
611                     buf = se_strdup_printf("%s == %s", cfile.cinfo.col_expr.col_expr[column],
612                                            cfile.cinfo.col_expr.col_expr_val[column]);
613                 }
614             }
615         }
616
617         epan_dissect_cleanup(&edt);
618     }
619
620     return buf;
621 }
622
623 void
624 match_selected_plist_cb(GtkWidget *w _U_, gpointer data, MATCH_SELECTED_E action)
625 {
626     match_selected_cb_do(data,
627         action,
628         get_filter_from_packet_list_row_and_column(data));
629 }
630
631 /* This function allows users to right click in the details window and copy the text
632  * information to the operating systems clipboard.
633  *
634  * We first check to see if a string representation is setup in the tree and then
635  * read the string. If not available then we try to grab the value. If all else
636  * fails we display a message to the user to indicate the copy could not be completed.
637  */
638 void
639 copy_selected_plist_cb(GtkWidget *w _U_, gpointer data _U_, COPY_SELECTED_E action)
640 {
641     GString *gtk_text_str = g_string_new("");
642     char labelstring[256];
643     char *stringpointer = labelstring;
644
645     switch(action)
646     {
647     case COPY_SELECTED_DESCRIPTION:
648         if (cfile.finfo_selected->rep &&
649             strlen (cfile.finfo_selected->rep->representation) > 0) {
650             g_string_append(gtk_text_str, cfile.finfo_selected->rep->representation);
651         }
652         break;
653     case COPY_SELECTED_FIELDNAME:
654         if (cfile.finfo_selected->hfinfo->abbrev != 0) {
655             g_string_append(gtk_text_str, cfile.finfo_selected->hfinfo->abbrev);
656         }
657         break;
658     case COPY_SELECTED_VALUE:
659         if (cfile.edt !=0 ) {
660             g_string_append(gtk_text_str,
661                     get_node_field_value(cfile.finfo_selected, cfile.edt));
662         }
663         break;
664     default:
665         break;
666     }
667
668     if (gtk_text_str->len == 0) {
669         /* If no representation then... Try to read the value */
670         proto_item_fill_label(cfile.finfo_selected, stringpointer);
671         g_string_append(gtk_text_str, stringpointer);
672     }
673
674     if (gtk_text_str->len == 0) {
675         /* Could not get item so display error msg */
676         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Could not acquire information to copy, try expanding or choosing another item");
677     } else {
678         /* Copy string to clipboard */
679         copy_to_clipboard(gtk_text_str);
680     }
681     g_string_free(gtk_text_str, TRUE);                       /* Free the memory */
682 }
683
684
685 /* mark as reference time frame */
686 void
687 set_frame_reftime(gboolean set, frame_data *frame, gint row) {
688   if (row == -1)
689     return;
690   if (set) {
691     frame->flags.ref_time=1;
692         cfile.ref_time_count++;
693   } else {
694     frame->flags.ref_time=0;
695     cfile.ref_time_count--;
696   }
697   cf_reftime_packets(&cfile);
698   if (!frame->flags.ref_time && !frame->flags.passed_dfilter) {
699     new_packet_list_freeze();
700     cfile.displayed_count--;
701     new_packet_list_recreate_visible_rows();
702     new_packet_list_thaw();
703   }
704   new_packet_list_queue_draw();
705 }
706
707
708 static void reftime_answered_cb(gpointer dialog _U_, gint btn, gpointer data _U_)
709 {
710     switch(btn) {
711     case(ESD_BTN_YES):
712         timestamp_set_type(TS_RELATIVE);
713         recent.gui_time_format  = TS_RELATIVE;
714                 cf_timestamp_auto_precision(&cfile);
715                 new_packet_list_queue_draw();
716         break;
717     case(ESD_BTN_NO):
718         break;
719     default:
720         g_assert_not_reached();
721     }
722
723     if (cfile.current_frame) {
724       set_frame_reftime(!cfile.current_frame->flags.ref_time,
725                         cfile.current_frame, cfile.current_row);
726     }
727 }
728
729
730 void
731 reftime_frame_cb(GtkWidget *w _U_, gpointer data _U_, REFTIME_ACTION_E action)
732 {
733   static GtkWidget *reftime_dialog = NULL;
734
735   switch(action){
736   case REFTIME_TOGGLE:
737     if (cfile.current_frame) {
738         if(recent.gui_time_format != TS_RELATIVE && cfile.current_frame->flags.ref_time==0) {
739             reftime_dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_YES_NO,
740                 "%sSwitch to the appropriate Time Display Format?%s\n\n"
741                 "Time References don't work well with the currently selected Time Display Format.\n\n"
742                 "Do you want to switch to \"Seconds Since Beginning of Capture\" now?",
743                 simple_dialog_primary_start(), simple_dialog_primary_end());
744             simple_dialog_set_cb(reftime_dialog, reftime_answered_cb, NULL);
745         } else {
746             set_frame_reftime(!cfile.current_frame->flags.ref_time,
747                               cfile.current_frame, cfile.current_row);
748         }
749     }
750     break;
751   case REFTIME_FIND_NEXT:
752     cf_find_packet_time_reference(&cfile, SD_FORWARD);
753     break;
754   case REFTIME_FIND_PREV:
755     cf_find_packet_time_reference(&cfile, SD_BACKWARD);
756     break;
757   }
758 }
759
760 void
761 find_next_mark_cb(GtkWidget *w _U_, gpointer data _U_, int action _U_)
762 {
763     cf_find_packet_marked(&cfile, SD_FORWARD);
764 }
765
766 void
767 find_prev_mark_cb(GtkWidget *w _U_, gpointer data _U_, int action _U_)
768 {
769     cf_find_packet_marked(&cfile, SD_BACKWARD);
770 }
771
772 static void
773 tree_view_selection_changed_cb(GtkTreeSelection *sel, gpointer user_data _U_)
774 {
775     field_info   *finfo;
776     gchar         len_str[2+10+1+5+1]; /* ", {N} bytes\0",
777                                           N < 4294967296 */
778     gboolean      has_blurb = FALSE;
779     guint         length = 0, byte_len;
780     GtkWidget    *byte_view;
781     const guint8 *byte_data;
782     gint          finfo_length;
783     GtkTreeModel *model;
784     GtkTreeIter   iter;
785
786     /* if nothing is selected */
787     if (!gtk_tree_selection_get_selected(sel, &model, &iter))
788     {
789         /*
790          * Which byte view is displaying the current protocol tree
791          * row's data?
792          */
793         byte_view = get_notebook_bv_ptr(byte_nb_ptr_gbl);
794         if (byte_view == NULL)
795             return;     /* none */
796
797         byte_data = get_byte_view_data_and_length(byte_view, &byte_len);
798         if (byte_data == NULL)
799             return;     /* none */
800
801         cf_unselect_field(&cfile);
802         packet_hex_print(byte_view, byte_data,
803                          cfile.current_frame, NULL, byte_len);
804         proto_help_menu_modify(sel, &cfile);
805         return;
806     }
807     gtk_tree_model_get(model, &iter, 1, &finfo, -1);
808     if (!finfo) return;
809
810     set_notebook_page(byte_nb_ptr_gbl, finfo->ds_tvb);
811
812     byte_view = get_notebook_bv_ptr(byte_nb_ptr_gbl);
813     byte_data = get_byte_view_data_and_length(byte_view, &byte_len);
814     g_assert(byte_data != NULL);
815
816     cfile.finfo_selected = finfo;
817     set_menus_for_selected_tree_row(&cfile);
818
819     if (finfo->hfinfo) {
820         if (finfo->hfinfo->blurb != NULL &&
821             finfo->hfinfo->blurb[0] != '\0') {
822             has_blurb = TRUE;
823             length = (guint) strlen(finfo->hfinfo->blurb);
824         } else {
825             length = (guint) strlen(finfo->hfinfo->name);
826         }
827         finfo_length = finfo->length + finfo->appendix_length;
828
829         if (finfo_length == 0) {
830             len_str[0] = '\0';
831         } else if (finfo_length == 1) {
832             g_strlcpy (len_str, ", 1 byte", sizeof len_str);
833         } else {
834             g_snprintf (len_str, sizeof len_str, ", %d bytes", finfo_length);
835         }
836         statusbar_pop_field_msg();      /* get rid of current help msg */
837         if (length) {
838             statusbar_push_field_msg(" %s (%s)%s",
839                     (has_blurb) ? finfo->hfinfo->blurb : finfo->hfinfo->name,
840                     finfo->hfinfo->abbrev, len_str);
841         } else {
842             /*
843              * Don't show anything if the field name is zero-length;
844              * the pseudo-field for "proto_tree_add_text()" is such
845              * a field, and we don't want "Text (text)" showing up
846              * on the status line if you've selected such a field.
847              *
848              * XXX - there are zero-length fields for which we *do*
849              * want to show the field name.
850              *
851              * XXX - perhaps the name and abbrev field should be null
852              * pointers rather than null strings for that pseudo-field,
853              * but we'd have to add checks for null pointers in some
854              * places if we did that.
855              *
856              * Or perhaps protocol tree items added with
857              * "proto_tree_add_text()" should have -1 as the field index,
858              * with no pseudo-field being used, but that might also
859              * require special checks for -1 to be added.
860              */
861             statusbar_push_field_msg("%s", "");
862         }
863     }
864     packet_hex_print(byte_view, byte_data, cfile.current_frame, finfo,
865                      byte_len);
866     proto_help_menu_modify(sel, &cfile);
867 }
868
869 void collapse_all_cb(GtkWidget *widget _U_, gpointer data _U_) {
870   if (cfile.edt->tree)
871     collapse_all_tree(cfile.edt->tree, tree_view_gbl);
872 }
873
874 void expand_all_cb(GtkWidget *widget _U_, gpointer data _U_) {
875   if (cfile.edt->tree)
876     expand_all_tree(cfile.edt->tree, tree_view_gbl);
877 }
878
879 void apply_as_custom_column_cb (GtkWidget *widget _U_, gpointer data _U_)
880 {
881   if (cfile.finfo_selected) {
882     column_prefs_add_custom(COL_CUSTOM, cfile.finfo_selected->hfinfo->name,
883                             cfile.finfo_selected->hfinfo->abbrev,0);
884     /* Recreate the packet list according to new preferences */
885     new_packet_list_recreate ();
886     if (!prefs.gui_use_pref_save) {
887       prefs_main_write();
888     }
889     cfile.cinfo.columns_changed = FALSE; /* Reset value */
890   }
891 }
892
893 void expand_tree_cb(GtkWidget *widget _U_, gpointer data _U_) {
894   GtkTreePath  *path;
895
896   path = tree_find_by_field_info(GTK_TREE_VIEW(tree_view_gbl), cfile.finfo_selected);
897   if(path) {
898     /* the mouse position is at an entry, expand that one */
899     gtk_tree_view_expand_row(GTK_TREE_VIEW(tree_view_gbl), path, TRUE);
900     gtk_tree_path_free(path);
901   }
902 }
903
904 void resolve_name_cb(GtkWidget *widget _U_, gpointer data _U_) {
905   if (cfile.edt->tree) {
906     guint32 tmp = gbl_resolv_flags;
907     gbl_resolv_flags = RESOLV_ALL;
908     proto_tree_draw(cfile.edt->tree, tree_view_gbl);
909     gbl_resolv_flags = tmp;
910   }
911 }
912
913 static void
914 main_set_for_capture_file(gboolean have_capture_file_in)
915 {
916     have_capture_file = have_capture_file_in;
917
918     main_widgets_show_or_hide();
919 }
920
921 gboolean
922 main_do_quit(void)
923 {
924         /* get the current geometry, before writing it to disk */
925         main_save_window_geometry(top_level);
926
927         /* write user's recent file to disk
928          * It is no problem to write this file, even if we do not quit */
929         write_profile_recent();
930         write_recent();
931
932         /* XXX - should we check whether the capture file is an
933            unsaved temporary file for a live capture and, if so,
934            pop up a "do you want to exit without saving the capture
935            file?" dialog, and then just return, leaving said dialog
936            box to forcibly quit if the user clicks "OK"?
937
938            If so, note that this should be done in a subroutine that
939            returns TRUE if we do so, and FALSE otherwise, and if it
940            returns TRUE we should return TRUE without nuking anything.
941
942            Note that, if we do that, we might also want to check if
943            an "Update list of packets in real time" capture is in
944            progress and, if so, ask whether they want to terminate
945            the capture and discard it, and return TRUE, before nuking
946            any child capture, if they say they don't want to do so. */
947
948 #ifdef HAVE_LIBPCAP
949         /* Nuke any child capture in progress. */
950         capture_kill_child(&global_capture_opts);
951 #endif
952
953         /* Are we in the middle of reading a capture? */
954         if (cfile.state == FILE_READ_IN_PROGRESS) {
955                 /* Yes, so we can't just close the file and quit, as
956                    that may yank the rug out from under the read in
957                    progress; instead, just set the state to
958                    "FILE_READ_ABORTED" and return - the code doing the read
959                    will check for that and, if it sees that, will clean
960                    up and quit. */
961                 cfile.state = FILE_READ_ABORTED;
962
963                 /* Say that the window should *not* be deleted;
964                    that'll be done by the code that cleans up. */
965                 return TRUE;
966         } else {
967                 /* Close any capture file we have open; on some OSes, you
968                    can't unlink a temporary capture file if you have it
969                    open.
970                    "cf_close()" will unlink it after closing it if
971                    it's a temporary file.
972
973                    We do this here, rather than after the main loop returns,
974                    as, after the main loop returns, the main window may have
975                    been destroyed (if this is called due to a "destroy"
976                    even on the main window rather than due to the user
977                    selecting a menu item), and there may be a crash
978                    or other problem when "cf_close()" tries to
979                    clean up stuff in the main window.
980
981                    XXX - is there a better place to put this?
982                    Or should we have a routine that *just* closes the
983                    capture file, and doesn't do anything with the UI,
984                    which we'd call here, and another routine that
985                    calls that routine and also cleans up the UI, which
986                    we'd call elsewhere? */
987                 cf_close(&cfile);
988
989                 /* Exit by leaving the main loop, so that any quit functions
990                    we registered get called. */
991                 gtk_main_quit();
992
993                 /* Say that the window should be deleted. */
994                 return FALSE;
995         }
996 }
997
998 static gboolean
999 main_window_delete_event_cb(GtkWidget *widget _U_, GdkEvent *event _U_, gpointer data _U_)
1000 {
1001   gpointer dialog;
1002
1003   if((cfile.state != FILE_CLOSED) && !cfile.user_saved && prefs.gui_ask_unsaved) {
1004     gtk_window_present(GTK_WINDOW(top_level));
1005     /* user didn't saved his current file, ask him */
1006     dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_SAVE_QUIT_DONTSAVE_CANCEL,
1007                 "%sSave capture file before program quit?%s\n\n"
1008                 "If you quit the program without saving, your capture data will be discarded.",
1009                 simple_dialog_primary_start(), simple_dialog_primary_end());
1010     simple_dialog_set_cb(dialog, file_quit_answered_cb, NULL);
1011     return TRUE;
1012   } else {
1013     /* unchanged file, just exit */
1014     /* "main_do_quit()" indicates whether the main window should be deleted. */
1015     return main_do_quit();
1016   }
1017 }
1018
1019
1020 static void
1021 main_pane_load_window_geometry(void)
1022 {
1023     if (recent.has_gui_geometry_main_upper_pane && recent.gui_geometry_main_upper_pane)
1024         gtk_paned_set_position(GTK_PANED(main_first_pane), recent.gui_geometry_main_upper_pane);
1025     if (recent.has_gui_geometry_main_lower_pane && recent.gui_geometry_main_lower_pane) {
1026         gtk_paned_set_position(GTK_PANED(main_second_pane), recent.gui_geometry_main_lower_pane);
1027     }
1028 }
1029
1030
1031 static void
1032 main_load_window_geometry(GtkWidget *widget)
1033 {
1034     window_geometry_t geom;
1035
1036     geom.set_pos        = prefs.gui_geometry_save_position;
1037     geom.x              = recent.gui_geometry_main_x;
1038     geom.y              = recent.gui_geometry_main_y;
1039     geom.set_size       = prefs.gui_geometry_save_size;
1040     if (recent.gui_geometry_main_width > 0 &&
1041         recent.gui_geometry_main_height > 0) {
1042         geom.width          = recent.gui_geometry_main_width;
1043         geom.height         = recent.gui_geometry_main_height;
1044         geom.set_maximized  = prefs.gui_geometry_save_maximized;
1045     } else {
1046         /* We assume this means the width and height weren't set in
1047            the "recent" file (or that there is no "recent" file),
1048            and weren't set to a default value, so we don't set the
1049            size.  (The "recent" file code rejects non-positive width
1050            and height values.) */
1051        geom.set_size = FALSE;
1052     }
1053     geom.maximized      = recent.gui_geometry_main_maximized;
1054
1055     window_set_geometry(widget, &geom);
1056
1057     main_pane_load_window_geometry();
1058     statusbar_load_window_geometry();
1059 }
1060
1061
1062 static void
1063 main_save_window_geometry(GtkWidget *widget)
1064 {
1065     window_geometry_t geom;
1066
1067     window_get_geometry(widget, &geom);
1068
1069     if (prefs.gui_geometry_save_position) {
1070         recent.gui_geometry_main_x = geom.x;
1071         recent.gui_geometry_main_y = geom.y;
1072     }
1073
1074     if (prefs.gui_geometry_save_size) {
1075         recent.gui_geometry_main_width  = geom.width;
1076         recent.gui_geometry_main_height = geom.height;
1077     }
1078
1079     if(prefs.gui_geometry_save_maximized) {
1080         recent.gui_geometry_main_maximized = geom.maximized;
1081     }
1082
1083     recent.gui_geometry_main_upper_pane     = gtk_paned_get_position(GTK_PANED(main_first_pane));
1084     recent.gui_geometry_main_lower_pane     = gtk_paned_get_position(GTK_PANED(main_second_pane));
1085     statusbar_save_window_geometry();
1086 }
1087
1088 static void file_quit_answered_cb(gpointer dialog _U_, gint btn, gpointer data _U_)
1089 {
1090     switch(btn) {
1091     case(ESD_BTN_SAVE):
1092         /* save file first */
1093         file_save_as_cmd(after_save_exit, NULL);
1094         break;
1095     case(ESD_BTN_QUIT_DONT_SAVE):
1096         main_do_quit();
1097         break;
1098     case(ESD_BTN_CANCEL):
1099         break;
1100     default:
1101         g_assert_not_reached();
1102     }
1103 }
1104
1105 void
1106 file_quit_cmd_cb(GtkWidget *widget _U_, gpointer data _U_)
1107 {
1108   gpointer dialog;
1109
1110   if((cfile.state != FILE_CLOSED) && !cfile.user_saved && prefs.gui_ask_unsaved) {
1111     /* user didn't saved his current file, ask him */
1112     dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_SAVE_QUIT_DONTSAVE_CANCEL,
1113                 "%sSave capture file before program quit?%s\n\n"
1114                 "If you quit the program without saving, your capture data will be discarded.",
1115                 simple_dialog_primary_start(), simple_dialog_primary_end());
1116     simple_dialog_set_cb(dialog, file_quit_answered_cb, NULL);
1117   } else {
1118     /* unchanged file, just exit */
1119     main_do_quit();
1120   }
1121 }
1122
1123 static void
1124 print_usage(gboolean print_ver) {
1125
1126   FILE *output;
1127
1128 #ifdef _WIN32
1129   create_console();
1130 #endif
1131
1132   if (print_ver) {
1133     output = stdout;
1134     fprintf(output, "Wireshark " VERSION "%s\n"
1135         "Interactively dump and analyze network traffic.\n"
1136         "See http://www.wireshark.org for more information.\n"
1137         "\n"
1138         "%s",
1139         wireshark_svnversion, get_copyright_info());
1140   } else {
1141     output = stderr;
1142   }
1143   fprintf(output, "\n");
1144   fprintf(output, "Usage: wireshark [options] ... [ <infile> ]\n");
1145   fprintf(output, "\n");
1146
1147 #ifdef HAVE_LIBPCAP
1148   fprintf(output, "Capture interface:\n");
1149   fprintf(output, "  -i <interface>           name or idx of interface (def: first non-loopback)\n");
1150   fprintf(output, "  -f <capture filter>      packet filter in libpcap filter syntax\n");
1151   fprintf(output, "  -s <snaplen>             packet snapshot length (def: 65535)\n");
1152   fprintf(output, "  -p                       don't capture in promiscuous mode\n");
1153   fprintf(output, "  -k                       start capturing immediately (def: do nothing)\n");
1154   fprintf(output, "  -Q                       quit Wireshark after capturing\n");
1155   fprintf(output, "  -S                       update packet display when new packets are captured\n");
1156   fprintf(output, "  -l                       turn on automatic scrolling while -S is in use\n");
1157 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
1158   fprintf(output, "  -B <buffer size>         size of kernel buffer (def: 1MB)\n");
1159 #endif
1160   fprintf(output, "  -y <link type>           link layer type (def: first appropriate)\n");
1161   fprintf(output, "  -D                       print list of interfaces and exit\n");
1162   fprintf(output, "  -L                       print list of link-layer types of iface and exit\n");
1163   fprintf(output, "\n");
1164   fprintf(output, "Capture stop conditions:\n");
1165   fprintf(output, "  -c <packet count>        stop after n packets (def: infinite)\n");
1166   fprintf(output, "  -a <autostop cond.> ...  duration:NUM - stop after NUM seconds\n");
1167   fprintf(output, "                           filesize:NUM - stop this file after NUM KB\n");
1168   fprintf(output, "                              files:NUM - stop after NUM files\n");
1169   /*fprintf(output, "\n");*/
1170   fprintf(output, "Capture output:\n");
1171   fprintf(output, "  -b <ringbuffer opt.> ... duration:NUM - switch to next file after NUM secs\n");
1172   fprintf(output, "                           filesize:NUM - switch to next file after NUM KB\n");
1173   fprintf(output, "                              files:NUM - ringbuffer: replace after NUM files\n");
1174 #endif  /* HAVE_LIBPCAP */
1175
1176   /*fprintf(output, "\n");*/
1177   fprintf(output, "Input file:\n");
1178   fprintf(output, "  -r <infile>              set the filename to read from (no pipes or stdin!)\n");
1179
1180   fprintf(output, "\n");
1181   fprintf(output, "Processing:\n");
1182   fprintf(output, "  -R <read filter>         packet filter in Wireshark display filter syntax\n");
1183   fprintf(output, "  -n                       disable all name resolutions (def: all enabled)\n");
1184   fprintf(output, "  -N <name resolve flags>  enable specific name resolution(s): \"mntC\"\n");
1185
1186   fprintf(output, "\n");
1187   fprintf(output, "User interface:\n");
1188   fprintf(output, "  -C <config profile>      start with specified configuration profile\n");
1189   fprintf(output, "  -g <packet number>       go to specified packet number after \"-r\"\n");
1190   fprintf(output, "  -J <jump filter>         jump to the first packet matching the (display)\n");
1191   fprintf(output, "                           filter\n");
1192   fprintf(output, "  -j                       search backwards for a matching packet after \"-J\"\n");
1193   fprintf(output, "  -m <font>                set the font name used for most text\n");
1194   fprintf(output, "  -t ad|a|r|d|dd|e         output format of time stamps (def: r: rel. to first)\n");
1195   fprintf(output, "  -u s|hms                 output format of seconds (def: s: seconds)\n");
1196   fprintf(output, "  -X <key>:<value>         eXtension options, see man page for details\n");
1197   fprintf(output, "  -z <statistics>          show various statistics, see man page for details\n");
1198
1199   fprintf(output, "\n");
1200   fprintf(output, "Output:\n");
1201   fprintf(output, "  -w <outfile|->           set the output filename (or '-' for stdout)\n");
1202
1203   fprintf(output, "\n");
1204   fprintf(output, "Miscellaneous:\n");
1205   fprintf(output, "  -h                       display this help and exit\n");
1206   fprintf(output, "  -v                       display version info and exit\n");
1207   fprintf(output, "  -P <key>:<path>          persconf:path - personal configuration files\n");
1208   fprintf(output, "                           persdata:path - personal data files\n");
1209   fprintf(output, "  -o <name>:<value> ...    override preference or recent setting\n");
1210   fprintf(output, "  -K <keytab>              keytab file to use for kerberos decryption\n");
1211 #ifndef _WIN32
1212   fprintf(output, "  --display=DISPLAY        X display to use\n");
1213 #endif
1214
1215 #ifdef _WIN32
1216   destroy_console();
1217 #endif
1218 }
1219
1220 static void
1221 show_version(void)
1222 {
1223 #ifdef _WIN32
1224   create_console();
1225 #endif
1226
1227   printf(PACKAGE " " VERSION "%s\n"
1228          "\n"
1229          "%s"
1230          "\n"
1231          "%s"
1232          "\n"
1233          "%s",
1234       wireshark_svnversion, get_copyright_info(), comp_info_str->str,
1235       runtime_info_str->str);
1236
1237 #ifdef _WIN32
1238   destroy_console();
1239 #endif
1240 }
1241
1242 /*
1243  * Print to the standard error.  On Windows, create a console for the
1244  * standard error to show up on, if necessary.
1245  * XXX - pop this up in a window of some sort on UNIX+X11 if the controlling
1246  * terminal isn't the standard error?
1247  */
1248 void
1249 vfprintf_stderr(const char *fmt, va_list ap)
1250 {
1251 #ifdef _WIN32
1252   create_console();
1253 #endif
1254   vfprintf(stderr, fmt, ap);
1255 }
1256
1257 void
1258 fprintf_stderr(const char *fmt, ...)
1259 {
1260   va_list ap;
1261
1262   va_start(ap, fmt);
1263   vfprintf_stderr(fmt, ap);
1264   va_end(ap);
1265 }
1266
1267 /*
1268  * Report an error in command-line arguments.
1269  * Creates a console on Windows.
1270  */
1271 void
1272 cmdarg_err(const char *fmt, ...)
1273 {
1274   va_list ap;
1275
1276   fprintf_stderr("wireshark: ");
1277   va_start(ap, fmt);
1278   vfprintf_stderr(fmt, ap);
1279   va_end(ap);
1280   fprintf_stderr("\n");
1281 }
1282
1283 /*
1284  * Report additional information for an error in command-line arguments.
1285  * Creates a console on Windows.
1286  * XXX - pop this up in a window of some sort on UNIX+X11 if the controlling
1287  * terminal isn't the standard error?
1288  */
1289 void
1290 cmdarg_err_cont(const char *fmt, ...)
1291 {
1292   va_list ap;
1293
1294   va_start(ap, fmt);
1295   vfprintf_stderr(fmt, ap);
1296   fprintf_stderr("\n");
1297   va_end(ap);
1298 }
1299
1300 /*
1301    Once every 3 seconds we get a callback here which we use to update
1302    the tap extensions.
1303  */
1304 static gboolean
1305 tap_update_cb(gpointer data _U_)
1306 {
1307         draw_tap_listeners(FALSE);
1308         return TRUE;
1309 }
1310
1311 /* Restart the tap update display timer with new configured interval */
1312 void reset_tap_update_timer(void)
1313 {
1314     g_source_remove(tap_update_timer_id);
1315     tap_update_timer_id = g_timeout_add(prefs.tap_update_interval, tap_update_cb, NULL);
1316 }
1317
1318 void
1319 protect_thread_critical_region(void)
1320 {
1321         /* Threading support for TAP:s removed
1322          * http://www.wireshark.org/lists/wireshark-dev/200611/msg00199.html
1323          * See the commit for removed code:
1324          * http://anonsvn.wireshark.org/viewvc/viewvc.cgi?view=rev&revision=35027
1325          */
1326 }
1327 void
1328 unprotect_thread_critical_region(void)
1329 {
1330         /* Threading support for TAP:s removed
1331          * http://www.wireshark.org/lists/wireshark-dev/200611/msg00199.html
1332          */
1333
1334 }
1335
1336 /*
1337  * Periodically process outstanding hostname lookups. If we have new items,
1338  * redraw the packet list and tree view.
1339  */
1340
1341 static gboolean
1342 resolv_update_cb(gpointer data _U_)
1343 {
1344   /* Anything new show up? */
1345   if (host_name_lookup_process(NULL)) {
1346 #if GTK_CHECK_VERSION(2,14,0)
1347     if (gtk_widget_get_window(pkt_scrollw))
1348         gdk_window_invalidate_rect(gtk_widget_get_window(pkt_scrollw), NULL, TRUE);
1349     if (gtk_widget_get_window(tv_scrollw))
1350         gdk_window_invalidate_rect(gtk_widget_get_window(tv_scrollw), NULL, TRUE);
1351 #else
1352     if (pkt_scrollw->window)
1353         gdk_window_invalidate_rect(pkt_scrollw->window, NULL, TRUE);
1354     if (tv_scrollw->window)
1355         gdk_window_invalidate_rect(tv_scrollw->window, NULL, TRUE);
1356 #endif
1357   }
1358
1359   /* Always check. Even if we don't do async lookups we could still get
1360      passive updates, e.g. from DNS packets. */
1361   return TRUE;
1362 }
1363
1364
1365 /* Set main_window_name and it's icon title to the capture filename */
1366 static void
1367 set_display_filename(capture_file *cf)
1368 {
1369   gchar *window_name;
1370
1371   if (cf->filename) {
1372     window_name = g_strdup_printf("%s", cf_get_display_name(cf));
1373     set_main_window_name(window_name);
1374     g_free(window_name);
1375   } else {
1376     set_main_window_name("The Wireshark Network Analyzer");
1377   }
1378 }
1379
1380 static GtkWidget           *close_dlg = NULL;
1381
1382 static void
1383 priv_warning_dialog_cb(gpointer dialog, gint btn _U_, gpointer data _U_)
1384 {
1385     recent.privs_warn_if_elevated = !simple_dialog_check_get(dialog);
1386 }
1387
1388 #ifdef _WIN32
1389 static void
1390 npf_warning_dialog_cb(gpointer dialog, gint btn _U_, gpointer data _U_)
1391 {
1392     recent.privs_warn_if_no_npf = !simple_dialog_check_get(dialog);
1393 }
1394 #endif
1395
1396 static void
1397 main_cf_cb_file_closing(capture_file *cf)
1398 {
1399
1400     /* if we have more than 10000 packets, show a splash screen while closing */
1401     /* XXX - don't know a better way to decide whether to show or not,
1402      * as most of the time is spend in a single eth_clist_clear function,
1403      * so we can't use a progress bar here! */
1404     if(cf->count > 10000) {
1405         close_dlg = simple_dialog(ESD_TYPE_STOP, ESD_BTN_NONE,
1406                                   "%sClosing file!%s\n\nPlease wait ...",
1407                                   simple_dialog_primary_start(),
1408                                   simple_dialog_primary_end());
1409         gtk_window_set_position(GTK_WINDOW(close_dlg), GTK_WIN_POS_CENTER_ON_PARENT);
1410     }
1411
1412     /* Destroy all windows, which refer to the
1413        capture file we're closing. */
1414     destroy_packet_wins();
1415     file_save_as_destroy();
1416
1417     /* Restore the standard title bar message. */
1418     set_main_window_name("The Wireshark Network Analyzer");
1419
1420     /* Disable all menu items that make sense only if you have a capture. */
1421     set_menus_for_capture_file(NULL);
1422     set_menus_for_captured_packets(FALSE);
1423     set_menus_for_selected_packet(cf);
1424     set_menus_for_capture_in_progress(FALSE);
1425     set_capture_if_dialog_for_capture_in_progress(FALSE);
1426     set_menus_for_selected_tree_row(cf);
1427
1428     /* Set up main window for no capture file. */
1429     main_set_for_capture_file(FALSE);
1430
1431     main_window_update();
1432 }
1433
1434 static void
1435 main_cf_cb_file_closed(capture_file *cf _U_)
1436 {
1437   if(close_dlg != NULL) {
1438     splash_destroy(close_dlg);
1439     close_dlg = NULL;
1440   }
1441 }
1442
1443
1444 static void
1445 main_cf_cb_file_read_started(capture_file *cf _U_)
1446 {
1447   tap_param_dlg_update();
1448
1449   /* Set up main window for a capture file. */
1450   main_set_for_capture_file(TRUE);
1451 }
1452
1453 static void
1454 main_cf_cb_file_read_finished(capture_file *cf)
1455 {
1456     gchar *dir_path;
1457
1458     if (!cf->is_tempfile && cf->filename) {
1459         /* Add this filename to the list of recent files in the "Recent Files" submenu */
1460         add_menu_recent_capture_file(cf->filename);
1461
1462         /* Remember folder for next Open dialog and save it in recent */
1463         dir_path = get_dirname(g_strdup(cf->filename));
1464         set_last_open_dir(dir_path);
1465         g_free(dir_path);
1466     }
1467     set_display_filename(cf);
1468
1469     /* Enable menu items that make sense if you have a capture file you've
1470        finished reading. */
1471     set_menus_for_capture_file(cf);
1472
1473     /* Enable menu items that make sense if you have some captured packets. */
1474     set_menus_for_captured_packets(TRUE);
1475 }
1476
1477 #ifdef HAVE_LIBPCAP
1478 static GList *icon_list_create(
1479     const char **icon16_xpm,
1480     const char **icon32_xpm,
1481     const char **icon48_xpm,
1482     const char **icon64_xpm)
1483 {
1484   GList *icon_list = NULL;
1485   GdkPixbuf * pixbuf16;
1486   GdkPixbuf * pixbuf32;
1487   GdkPixbuf * pixbuf48;
1488   GdkPixbuf * pixbuf64;
1489
1490
1491   if(icon16_xpm != NULL) {
1492       pixbuf16 = gdk_pixbuf_new_from_xpm_data(icon16_xpm);
1493       g_assert(pixbuf16);
1494       icon_list = g_list_append(icon_list, pixbuf16);
1495   }
1496
1497   if(icon32_xpm != NULL) {
1498       pixbuf32 = gdk_pixbuf_new_from_xpm_data(icon32_xpm);
1499       g_assert(pixbuf32);
1500       icon_list = g_list_append(icon_list, pixbuf32);
1501   }
1502
1503   if(icon48_xpm != NULL) {
1504       pixbuf48 = gdk_pixbuf_new_from_xpm_data(icon48_xpm);
1505       g_assert(pixbuf48);
1506       icon_list = g_list_append(icon_list, pixbuf48);
1507   }
1508
1509   if(icon64_xpm != NULL) {
1510       pixbuf64 = gdk_pixbuf_new_from_xpm_data(icon64_xpm);
1511       g_assert(pixbuf64);
1512       icon_list = g_list_append(icon_list, pixbuf64);
1513   }
1514
1515   return icon_list;
1516 }
1517
1518 static void
1519 main_capture_set_main_window_title(capture_options *capture_opts)
1520 {
1521     GString *title = g_string_new("");
1522
1523     g_string_append(title, "Capturing ");
1524     g_string_append_printf(title, "from %s ", cf_get_tempfile_source(capture_opts->cf));
1525     set_main_window_name(title->str);
1526     g_string_free(title, TRUE);
1527 }
1528
1529 static void
1530 main_capture_cb_capture_prepared(capture_options *capture_opts)
1531 {
1532     static GList *icon_list = NULL;
1533
1534     main_capture_set_main_window_title(capture_opts);
1535
1536     if(icon_list == NULL) {
1537         icon_list = icon_list_create(wsiconcap16_xpm, wsiconcap32_xpm, wsiconcap48_xpm, NULL);
1538     }
1539     gtk_window_set_icon_list(GTK_WINDOW(top_level), icon_list);
1540
1541     /* Disable menu items that make no sense if you're currently running
1542        a capture. */
1543     set_menus_for_capture_in_progress(TRUE);
1544     set_capture_if_dialog_for_capture_in_progress(TRUE);
1545
1546     /* Don't set up main window for a capture file. */
1547     main_set_for_capture_file(FALSE);
1548 }
1549
1550 static void
1551 main_capture_cb_capture_update_started(capture_options *capture_opts)
1552 {
1553     /* We've done this in "prepared" above, but it will be cleared while
1554        switching to the next multiple file. */
1555     main_capture_set_main_window_title(capture_opts);
1556
1557     set_menus_for_capture_in_progress(TRUE);
1558     set_capture_if_dialog_for_capture_in_progress(TRUE);
1559
1560     /* Enable menu items that make sense if you have some captured
1561        packets (yes, I know, we don't have any *yet*). */
1562     set_menus_for_captured_packets(TRUE);
1563
1564     /* Set up main window for a capture file. */
1565     main_set_for_capture_file(TRUE);
1566 }
1567
1568 static void
1569 main_capture_cb_capture_update_finished(capture_options *capture_opts)
1570 {
1571     capture_file *cf = capture_opts->cf;
1572     static GList *icon_list = NULL;
1573
1574     if (!cf->is_tempfile && cf->filename) {
1575         /* Add this filename to the list of recent files in the "Recent Files" submenu */
1576         add_menu_recent_capture_file(cf->filename);
1577     }
1578     set_display_filename(cf);
1579
1580     /* Enable menu items that make sense if you're not currently running
1581      a capture. */
1582     set_menus_for_capture_in_progress(FALSE);
1583     set_capture_if_dialog_for_capture_in_progress(FALSE);
1584
1585     /* Enable menu items that make sense if you have a capture file
1586        you've finished reading. */
1587     set_menus_for_capture_file(cf);
1588
1589     /* Set up main window for a capture file. */
1590     main_set_for_capture_file(TRUE);
1591
1592     if(icon_list == NULL) {
1593         icon_list = icon_list_create(wsicon16_xpm, wsicon32_xpm, wsicon48_xpm, wsicon64_xpm);
1594     }
1595     gtk_window_set_icon_list(GTK_WINDOW(top_level), icon_list);
1596
1597     if(global_capture_opts.quit_after_cap) {
1598         /* command line asked us to quit after the capture */
1599         /* don't pop up a dialog to ask for unsaved files etc. */
1600         main_do_quit();
1601     }
1602 }
1603
1604 static void
1605 main_capture_cb_capture_fixed_started(capture_options *capture_opts _U_)
1606 {
1607     /* Don't set up main window for a capture file. */
1608     main_set_for_capture_file(FALSE);
1609 }
1610
1611 static void
1612 main_capture_cb_capture_fixed_finished(capture_options *capture_opts _U_)
1613 {
1614 #if 0
1615     capture_file *cf = capture_opts->cf;
1616 #endif
1617     static GList *icon_list = NULL;
1618
1619     /*set_display_filename(cf);*/
1620
1621     /* Enable menu items that make sense if you're not currently running
1622      a capture. */
1623     set_menus_for_capture_in_progress(FALSE);
1624     set_capture_if_dialog_for_capture_in_progress(FALSE);
1625
1626     /* Restore the standard title bar message */
1627     /* (just in case we have trouble opening the capture file). */
1628     set_main_window_name("The Wireshark Network Analyzer");
1629
1630     if(icon_list == NULL) {
1631         icon_list = icon_list_create(wsicon16_xpm, wsicon32_xpm, wsicon48_xpm, wsicon64_xpm);
1632     }
1633     gtk_window_set_icon_list(GTK_WINDOW(top_level), icon_list);
1634
1635     /* We don't have loaded the capture file, this will be done later.
1636      * For now we still have simply a blank screen. */
1637
1638     if(global_capture_opts.quit_after_cap) {
1639         /* command line asked us to quit after the capture */
1640         /* don't pop up a dialog to ask for unsaved files etc. */
1641         main_do_quit();
1642     }
1643 }
1644
1645 #endif  /* HAVE_LIBPCAP */
1646
1647 static void
1648 main_cf_cb_packet_selected(gpointer data)
1649 {
1650     capture_file *cf = data;
1651
1652     /* Display the GUI protocol tree and packet bytes.
1653       XXX - why do we dump core if we call "proto_tree_draw()"
1654       before calling "add_byte_views()"? */
1655     add_main_byte_views(cf->edt);
1656     main_proto_tree_draw(cf->edt->tree);
1657
1658     /* Note: Both string and hex value searches in the packet data produce a non-zero
1659        search_pos if successful */
1660     if(cf->search_in_progress &&
1661       (cf->search_pos != 0 || (cf->string && cf->decode_data))) {
1662         highlight_field(cf->edt->tvb, cf->search_pos,
1663                         (GtkTreeView *)tree_view_gbl, cf->edt->tree);
1664     }
1665
1666     /* A packet is selected. */
1667     set_menus_for_selected_packet(cf);
1668 }
1669
1670 static void
1671 main_cf_cb_packet_unselected(capture_file *cf)
1672 {
1673     /* Clear out the display of that packet. */
1674     clear_tree_and_hex_views();
1675
1676     /* No packet is selected. */
1677     set_menus_for_selected_packet(cf);
1678 }
1679
1680 static void
1681 main_cf_cb_field_unselected(capture_file *cf)
1682 {
1683     set_menus_for_selected_tree_row(cf);
1684 }
1685
1686 static void
1687 main_cf_cb_file_save_reload_finished(gpointer data _U_)
1688 {
1689     set_display_filename(&cfile);
1690     set_menus_for_capture_file(&cfile);
1691 }
1692
1693 static void
1694 main_cf_callback(gint event, gpointer data, gpointer user_data _U_)
1695 {
1696     switch(event) {
1697     case(cf_cb_file_closing):
1698         g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: Closing");
1699         main_cf_cb_file_closing(data);
1700         break;
1701     case(cf_cb_file_closed):
1702         g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: Closed");
1703         main_cf_cb_file_closed(data);
1704         break;
1705     case(cf_cb_file_read_started):
1706         g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: Read started");
1707         main_cf_cb_file_read_started(data);
1708         break;
1709     case(cf_cb_file_read_finished):
1710         g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: Read finished");
1711         main_cf_cb_file_read_finished(data);
1712         break;
1713     case(cf_cb_packet_selected):
1714         main_cf_cb_packet_selected(data);
1715         break;
1716     case(cf_cb_packet_unselected):
1717         main_cf_cb_packet_unselected(data);
1718         break;
1719     case(cf_cb_field_unselected):
1720         main_cf_cb_field_unselected(data);
1721         break;
1722     case(cf_cb_file_save_started):
1723         g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: Save started");
1724         break;
1725     case(cf_cb_file_save_finished):
1726         g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: Save finished");
1727         break;
1728     case(cf_cb_file_save_reload_finished):
1729         g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: Reload finished");
1730         main_cf_cb_file_save_reload_finished(data);
1731         break;
1732     case(cf_cb_file_save_failed):
1733         g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: Save failed");
1734         break;
1735     default:
1736         g_warning("main_cf_callback: event %u unknown", event);
1737         g_assert_not_reached();
1738     }
1739 }
1740
1741 #ifdef HAVE_LIBPCAP
1742 static void
1743 main_capture_callback(gint event, capture_options *capture_opts, gpointer user_data _U_)
1744 {
1745 #ifdef HAVE_GTKOSXAPPLICATION
1746     GtkOSXApplication *theApp;
1747 #endif
1748     switch(event) {
1749     case(capture_cb_capture_prepared):
1750         g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture prepared");
1751         main_capture_cb_capture_prepared(capture_opts);
1752         break;
1753     case(capture_cb_capture_update_started):
1754         g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture update started");
1755         main_capture_cb_capture_update_started(capture_opts);
1756 #ifdef HAVE_GTKOSXAPPLICATION
1757         theApp = g_object_new(GTK_TYPE_OSX_APPLICATION, NULL);
1758         gtk_osxapplication_set_dock_icon_pixbuf(theApp,gdk_pixbuf_new_from_xpm_data(wsiconcap48_xpm));
1759 #endif
1760         break;
1761     case(capture_cb_capture_update_continue):
1762         /*g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture update continue");*/
1763         break;
1764     case(capture_cb_capture_update_finished):
1765         g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture update finished");
1766         main_capture_cb_capture_update_finished(capture_opts);
1767         break;
1768     case(capture_cb_capture_fixed_started):
1769         g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture fixed started");
1770         main_capture_cb_capture_fixed_started(capture_opts);
1771         break;
1772     case(capture_cb_capture_fixed_continue):
1773         g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture fixed continue");
1774         break;
1775     case(capture_cb_capture_fixed_finished):
1776         g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture fixed finished");
1777         main_capture_cb_capture_fixed_finished(capture_opts);
1778         break;
1779     case(capture_cb_capture_stopping):
1780         g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture stopping");
1781         /* Beware: this state won't be called, if the capture child
1782          * closes the capturing on it's own! */
1783 #ifdef HAVE_GTKOSXAPPLICATION
1784         theApp = g_object_new(GTK_TYPE_OSX_APPLICATION, NULL);
1785         gtk_osxapplication_set_dock_icon_pixbuf(theApp,gdk_pixbuf_new_from_xpm_data(wsicon64_xpm));
1786 #endif
1787         break;
1788     default:
1789         g_warning("main_capture_callback: event %u unknown", event);
1790         g_assert_not_reached();
1791     }
1792 }
1793 #endif
1794
1795 static void
1796 get_gtk_compiled_info(GString *str)
1797 {
1798   g_string_append(str, "with ");
1799   g_string_append_printf(str,
1800 #ifdef GTK_MAJOR_VERSION
1801                     "GTK+ %d.%d.%d", GTK_MAJOR_VERSION, GTK_MINOR_VERSION,
1802                     GTK_MICRO_VERSION);
1803 #else
1804                     "GTK+ (version unknown)");
1805 #endif
1806   g_string_append(str, ", ");
1807 }
1808
1809 static void
1810 get_gui_compiled_info(GString *str)
1811 {
1812   epan_get_compiled_version_info(str);
1813
1814   g_string_append(str, ", ");
1815 #ifdef HAVE_LIBPORTAUDIO
1816 #ifdef PORTAUDIO_API_1
1817   g_string_append(str, "with PortAudio <= V18");
1818 #else /* PORTAUDIO_API_1 */
1819   g_string_append(str, "with ");
1820   g_string_append(str, Pa_GetVersionText());
1821 #endif /* PORTAUDIO_API_1 */
1822 #else /* HAVE_LIBPORTAUDIO */
1823   g_string_append(str, "without PortAudio");
1824 #endif /* HAVE_LIBPORTAUDIO */
1825
1826   g_string_append(str, ", ");
1827 #ifdef HAVE_AIRPCAP
1828   get_compiled_airpcap_version(str);
1829 #else
1830   g_string_append(str, "without AirPcap");
1831 #endif
1832 }
1833
1834 static void
1835 get_gui_runtime_info(GString *str)
1836 {
1837   epan_get_runtime_version_info(str);
1838
1839 #ifdef HAVE_AIRPCAP
1840   g_string_append(str, ", ");
1841   get_runtime_airpcap_version(str);
1842 #endif
1843
1844   if(u3_active()) {
1845     g_string_append(str, ", ");
1846     u3_runtime_info(str);
1847   }
1848 }
1849
1850 static e_prefs *
1851 read_configuration_files(char **gdp_path, char **dp_path)
1852 {
1853   int                  gpf_open_errno, gpf_read_errno;
1854   int                  cf_open_errno, df_open_errno;
1855   int                  gdp_open_errno, gdp_read_errno;
1856   int                  dp_open_errno, dp_read_errno;
1857   char                *gpf_path, *pf_path;
1858   char                *cf_path, *df_path;
1859   int                  pf_open_errno, pf_read_errno;
1860   e_prefs             *prefs_p;
1861
1862   /* Read the preference files. */
1863   prefs_p = read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
1864                      &pf_open_errno, &pf_read_errno, &pf_path);
1865
1866   if (gpf_path != NULL) {
1867     if (gpf_open_errno != 0) {
1868       simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
1869         "Could not open global preferences file\n\"%s\": %s.", gpf_path,
1870         g_strerror(gpf_open_errno));
1871     }
1872     if (gpf_read_errno != 0) {
1873       simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
1874         "I/O error reading global preferences file\n\"%s\": %s.", gpf_path,
1875         g_strerror(gpf_read_errno));
1876     }
1877   }
1878   if (pf_path != NULL) {
1879     if (pf_open_errno != 0) {
1880       simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
1881         "Could not open your preferences file\n\"%s\": %s.", pf_path,
1882         g_strerror(pf_open_errno));
1883     }
1884     if (pf_read_errno != 0) {
1885       simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
1886         "I/O error reading your preferences file\n\"%s\": %s.", pf_path,
1887         g_strerror(pf_read_errno));
1888     }
1889     g_free(pf_path);
1890     pf_path = NULL;
1891   }
1892
1893 #ifdef _WIN32
1894   /* if the user wants a console to be always there, well, we should open one for him */
1895   if (prefs_p->gui_console_open == console_open_always) {
1896     create_console();
1897   }
1898 #endif
1899
1900   /* Read the capture filter file. */
1901   read_filter_list(CFILTER_LIST, &cf_path, &cf_open_errno);
1902   if (cf_path != NULL) {
1903       simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
1904         "Could not open your capture filter file\n\"%s\": %s.", cf_path,
1905         g_strerror(cf_open_errno));
1906       g_free(cf_path);
1907   }
1908
1909   /* Read the display filter file. */
1910   read_filter_list(DFILTER_LIST, &df_path, &df_open_errno);
1911   if (df_path != NULL) {
1912       simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
1913         "Could not open your display filter file\n\"%s\": %s.", df_path,
1914         g_strerror(df_open_errno));
1915       g_free(df_path);
1916   }
1917
1918   /* Read the disabled protocols file. */
1919   read_disabled_protos_list(gdp_path, &gdp_open_errno, &gdp_read_errno,
1920                             dp_path, &dp_open_errno, &dp_read_errno);
1921   if (*gdp_path != NULL) {
1922     if (gdp_open_errno != 0) {
1923       simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
1924         "Could not open global disabled protocols file\n\"%s\": %s.",
1925         *gdp_path, g_strerror(gdp_open_errno));
1926     }
1927     if (gdp_read_errno != 0) {
1928       simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
1929         "I/O error reading global disabled protocols file\n\"%s\": %s.",
1930         *gdp_path, g_strerror(gdp_read_errno));
1931     }
1932     g_free(*gdp_path);
1933     *gdp_path = NULL;
1934   }
1935   if (*dp_path != NULL) {
1936     if (dp_open_errno != 0) {
1937       simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
1938         "Could not open your disabled protocols file\n\"%s\": %s.", *dp_path,
1939         g_strerror(dp_open_errno));
1940     }
1941     if (dp_read_errno != 0) {
1942       simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
1943         "I/O error reading your disabled protocols file\n\"%s\": %s.", *dp_path,
1944         g_strerror(dp_read_errno));
1945     }
1946     g_free(*dp_path);
1947     *dp_path = NULL;
1948   }
1949
1950   return prefs_p;
1951 }
1952
1953 /*  Check if there's something important to tell the user during startup.
1954  *  We want to do this *after* showing the main window so that any windows
1955  *  we pop up will be above the main window.
1956  */
1957 static void
1958 #ifdef _WIN32
1959 check_and_warn_user_startup(gchar *cf_name)
1960 #else
1961 check_and_warn_user_startup(gchar *cf_name _U_)
1962 #endif
1963 {
1964   gchar               *cur_user, *cur_group;
1965   gpointer             priv_warning_dialog;
1966
1967   /* Tell the user not to run as root. */
1968   if (running_with_special_privs() && recent.privs_warn_if_elevated) {
1969     cur_user = get_cur_username();
1970     cur_group = get_cur_groupname();
1971     priv_warning_dialog = simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
1972       "Running as user \"%s\" and group \"%s\".\n"
1973       "This could be dangerous.\n\n"
1974       "If you're running Wireshark this way in order to perform live capture, "
1975       "you may want to be aware that there is a better way documented at\n"
1976       "http://wiki.wireshark.org/CaptureSetup/CapturePrivileges", cur_user, cur_group);
1977     g_free(cur_user);
1978     g_free(cur_group);
1979     simple_dialog_check_set(priv_warning_dialog, "Don't show this message again.");
1980     simple_dialog_set_cb(priv_warning_dialog, priv_warning_dialog_cb, NULL);
1981   }
1982
1983 #ifdef _WIN32
1984   /* Warn the user if npf.sys isn't loaded. */
1985   if (!stdin_capture && !cf_name && !npf_sys_is_running() && recent.privs_warn_if_no_npf && get_os_major_version() >= 6) {
1986     priv_warning_dialog = simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
1987       "The NPF driver isn't running.  You may have trouble\n"
1988       "capturing or listing interfaces.");
1989     simple_dialog_check_set(priv_warning_dialog, "Don't show this message again.");
1990     simple_dialog_set_cb(priv_warning_dialog, npf_warning_dialog_cb, NULL);
1991   }
1992 #endif
1993
1994 }
1995
1996
1997 /* And now our feature presentation... [ fade to music ] */
1998 int
1999 main(int argc, char *argv[])
2000 {
2001   char                *init_progfile_dir_error;
2002   char                *s;
2003   int                  opt;
2004   gboolean             arg_error = FALSE;
2005
2006   extern int           info_update_freq;  /* Found in about_dlg.c. */
2007   const gchar         *filter;
2008
2009 #ifdef _WIN32
2010   WSADATA              wsaData;
2011 #endif  /* _WIN32 */
2012
2013   char                *rf_path;
2014   int                  rf_open_errno;
2015   char                *gdp_path, *dp_path;
2016   int                  err;
2017 #ifdef HAVE_LIBPCAP
2018   gboolean             start_capture = FALSE;
2019   gboolean             list_link_layer_types = FALSE;
2020   GList               *if_list;
2021   gchar               *err_str;
2022 #else
2023   gboolean             capture_option_specified = FALSE;
2024 #ifdef _WIN32
2025 #ifdef HAVE_AIRPCAP
2026   gchar               *err_str;
2027 #endif
2028 #endif
2029 #endif
2030   gint                 pl_size = 280, tv_size = 95, bv_size = 75;
2031   gchar               *rc_file, *cf_name = NULL, *rfilter = NULL, *jfilter = NULL;
2032   dfilter_t           *rfcode = NULL;
2033   gboolean             rfilter_parse_failed = FALSE;
2034   e_prefs             *prefs_p;
2035   char                 badopt;
2036   GtkWidget           *splash_win = NULL;
2037   GLogLevelFlags       log_flags;
2038   guint                go_to_packet = 0;
2039   gboolean             jump_backwards = FALSE;
2040   dfilter_t           *jump_to_filter = NULL;
2041   int                  optind_initial;
2042   int                  status;
2043 #ifdef HAVE_GTKOSXAPPLICATION
2044   GtkOSXApplication   *theApp;
2045 #endif
2046
2047 #ifdef HAVE_LIBPCAP
2048 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
2049 #define OPTSTRING_B "B:"
2050 #else
2051 #define OPTSTRING_B ""
2052 #endif  /* _WIN32 or HAVE_PCAP_CREATE */
2053 #else /* HAVE_LIBPCAP */
2054 #define OPTSTRING_B ""
2055 #endif  /* HAVE_LIBPCAP */
2056
2057 #ifdef HAVE_PCAP_CREATE
2058 #define OPTSTRING_I "I"
2059 #else
2060 #define OPTSTRING_I ""
2061 #endif
2062
2063 #define OPTSTRING "a:b:" OPTSTRING_B "c:C:Df:g:Hhi:" OPTSTRING_I "jJ:kK:lLm:nN:o:P:pQr:R:Ss:t:u:vw:X:y:z:"
2064
2065   static const char optstring[] = OPTSTRING;
2066
2067   /* Set the C-language locale to the native environment. */
2068   setlocale(LC_ALL, "");
2069 #ifdef _WIN32
2070   arg_list_utf_16to8(argc, argv);
2071 #endif /* _WIN32 */
2072
2073   /*
2074    * Get credential information for later use, and drop privileges
2075    * before doing anything else.
2076    * Let the user know if anything happened.
2077    */
2078   init_process_policies();
2079   relinquish_special_privs_perm();
2080
2081   /*
2082    * Attempt to get the pathname of the executable file.
2083    */
2084   init_progfile_dir_error = init_progfile_dir(argv[0], main);
2085
2086   /* initialize the funnel mini-api */
2087   initialize_funnel_ops();
2088
2089   AirPDcapInitContext(&airpdcap_ctx);
2090
2091 #ifdef _WIN32
2092   /* Load wpcap if possible. Do this before collecting the run-time version information */
2093   load_wpcap();
2094
2095   /* ... and also load the packet.dll from wpcap */
2096   wpcap_packet_load();
2097
2098 #ifdef HAVE_AIRPCAP
2099   /* Load the airpcap.dll.  This must also be done before collecting
2100    * run-time version information. */
2101   airpcap_dll_ret_val = load_airpcap();
2102
2103   switch (airpcap_dll_ret_val) {
2104   case AIRPCAP_DLL_OK:
2105     /* load the airpcap interfaces */
2106     airpcap_if_list = get_airpcap_interface_list(&err, &err_str);
2107
2108     if (airpcap_if_list == NULL || g_list_length(airpcap_if_list) == 0){
2109       if (err == CANT_GET_AIRPCAP_INTERFACE_LIST && err_str != NULL) {
2110         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", "Failed to open Airpcap Adapters!");
2111         g_free(err_str);
2112       }
2113       airpcap_if_active = NULL;
2114
2115     } else {
2116
2117       /* select the first ad default (THIS SHOULD BE CHANGED) */
2118       airpcap_if_active = airpcap_get_default_if(airpcap_if_list);
2119           }
2120     break;
2121 #if 0
2122     /*
2123      * XXX - Maybe we need to warn the user if one of the following happens???
2124      */
2125     case AIRPCAP_DLL_OLD:
2126       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s","AIRPCAP_DLL_OLD\n");
2127       break;
2128
2129     case AIRPCAP_DLL_ERROR:
2130       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s","AIRPCAP_DLL_ERROR\n");
2131       break;
2132
2133     case AIRPCAP_DLL_NOT_FOUND:
2134       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s","AIRPCAP_DDL_NOT_FOUND\n");
2135       break;
2136 #endif
2137   }
2138 #endif /* HAVE_AIRPCAP */
2139
2140   /* Start windows sockets */
2141   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
2142 #endif  /* _WIN32 */
2143
2144   profile_store_persconffiles (TRUE);
2145
2146   /* Assemble the compile-time version information string */
2147   comp_info_str = g_string_new("Compiled ");
2148
2149   get_compiled_version_info(comp_info_str, get_gtk_compiled_info, get_gui_compiled_info);
2150
2151   /* Assemble the run-time version information string */
2152   runtime_info_str = g_string_new("Running ");
2153   get_runtime_version_info(runtime_info_str, get_gui_runtime_info);
2154
2155   /* Read the profile independent recent file.  We have to do this here so we can */
2156   /* set the profile before it can be set from the command line parameterts */
2157   recent_read_static(&rf_path, &rf_open_errno);
2158   if (rf_path != NULL && rf_open_errno != 0) {
2159     simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
2160                   "Could not open common recent file\n\"%s\": %s.",
2161                   rf_path, g_strerror(rf_open_errno));
2162   }
2163
2164   /* "pre-scan" the command line parameters, if we have "console only"
2165      parameters.  We do this so we don't start GTK+ if we're only showing
2166      command-line help or version information.
2167
2168      XXX - this pre-scan is done before we start GTK+, so we haven't
2169      run gtk_init() on the arguments.  That means that GTK+ arguments
2170      have not been removed from the argument list; those arguments
2171      begin with "--", and will be treated as an error by getopt().
2172
2173      We thus ignore errors - *and* set "opterr" to 0 to suppress the
2174      error messages. */
2175   opterr = 0;
2176   optind_initial = optind;
2177   while ((opt = getopt(argc, argv, optstring)) != -1) {
2178     switch (opt) {
2179       case 'C':        /* Configuration Profile */
2180         if (profile_exists (optarg, FALSE)) {
2181           set_profile_name (optarg);
2182         } else {
2183           cmdarg_err("Configuration Profile \"%s\" does not exist", optarg);
2184           exit(1);
2185         }
2186         break;
2187       case 'D':        /* Print a list of capture devices and exit */
2188 #ifdef HAVE_LIBPCAP
2189         if_list = capture_interface_list(&err, &err_str);
2190         if (if_list == NULL) {
2191           switch (err) {
2192           case CANT_GET_INTERFACE_LIST:
2193             cmdarg_err("%s", err_str);
2194             g_free(err_str);
2195             break;
2196
2197           case NO_INTERFACES_FOUND:
2198             cmdarg_err("There are no interfaces on which a capture can be done");
2199             break;
2200           }
2201           exit(2);
2202         }
2203         capture_opts_print_interfaces(if_list);
2204         free_interface_list(if_list);
2205         exit(0);
2206 #else
2207         capture_option_specified = TRUE;
2208         arg_error = TRUE;
2209 #endif
2210         break;
2211       case 'h':        /* Print help and exit */
2212         print_usage(TRUE);
2213         exit(0);
2214         break;
2215 #ifdef _WIN32
2216       case 'i':
2217         if (strcmp(optarg, "-") == 0)
2218           stdin_capture = TRUE;
2219         break;
2220 #endif
2221       case 'P':        /* Path settings - change these before the Preferences and alike are processed */
2222         status = filesystem_opt(opt, optarg);
2223         if(status != 0) {
2224             cmdarg_err("-P flag \"%s\" failed (hint: is it quoted and existing?)", optarg);
2225             exit(status);
2226         }
2227         break;
2228       case 'v':        /* Show version and exit */
2229         show_version();
2230         exit(0);
2231         break;
2232       case 'X':
2233         /*
2234          *  Extension command line options have to be processed before
2235          *  we call epan_init() as they are supposed to be used by dissectors
2236          *  or taps very early in the registration process.
2237          */
2238         ex_opt_add(optarg);
2239         break;
2240       case '?':        /* Ignore errors - the "real" scan will catch them. */
2241         break;
2242     }
2243   }
2244
2245   /* Init the "Open file" dialog directory */
2246   /* (do this after the path settings are processed) */
2247
2248   /* Read the profile dependent (static part) of the recent file. */
2249   /* Only the static part of it will be read, as we don't have the gui now to fill the */
2250   /* recent lists which is done in the dynamic part. */
2251   /* We have to do this already here, so command line parameters can overwrite these values. */
2252   recent_read_profile_static(&rf_path, &rf_open_errno);
2253   if (rf_path != NULL && rf_open_errno != 0) {
2254     simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
2255                   "Could not open recent file\n\"%s\": %s.",
2256                   rf_path, g_strerror(rf_open_errno));
2257   }
2258
2259   if (recent.gui_fileopen_remembered_dir &&
2260       test_for_directory(recent.gui_fileopen_remembered_dir) == EISDIR) {
2261     set_last_open_dir(recent.gui_fileopen_remembered_dir);
2262   } else {
2263     set_last_open_dir(get_persdatafile_dir());
2264   }
2265
2266   /* Set getopt index back to initial value, so it will start with the
2267      first command line parameter again.  Also reset opterr to 1, so that
2268      error messages are printed by getopt().
2269
2270      XXX - this seems to work on most platforms, but time will tell.
2271      The Single UNIX Specification says "The getopt() function need
2272      not be reentrant", so this isn't guaranteed to work.  The Mac
2273      OS X 10.4[.x] getopt() man page says
2274
2275        In order to use getopt() to evaluate multiple sets of arguments, or to
2276        evaluate a single set of arguments multiple times, the variable optreset
2277        must be set to 1 before the second and each additional set of calls to
2278        getopt(), and the variable optind must be reinitialized.
2279
2280            ...
2281
2282        The optreset variable was added to make it possible to call the getopt()
2283        function multiple times.  This is an extension to the IEEE Std 1003.2
2284        (``POSIX.2'') specification.
2285
2286      which I think comes from one of the other BSDs.
2287
2288      XXX - if we want to control all the command-line option errors, so
2289      that we can display them where we choose (e.g., in a window), we'd
2290      want to leave opterr as 0, and produce our own messages using optopt.
2291      We'd have to check the value of optopt to see if it's a valid option
2292      letter, in which case *presumably* the error is "this option requires
2293      an argument but none was specified", or not a valid option letter,
2294      in which case *presumably* the error is "this option isn't valid".
2295      Some versions of getopt() let you supply a option string beginning
2296      with ':', which means that getopt() will return ':' rather than '?'
2297      for "this option requires an argument but none was specified", but
2298      not all do. */
2299   optind = optind_initial;
2300   opterr = 1;
2301
2302 #ifdef USE_THREADS
2303   g_thread_init(NULL);
2304 #endif
2305
2306   /* Set the current locale according to the program environment.
2307    * We haven't localized anything, but some GTK widgets are localized
2308    * (the file selection dialogue, for example).
2309    * This also sets the C-language locale to the native environment. */
2310   gtk_set_locale();
2311
2312   /* Let GTK get its args (will need an X server, so do this after command line only commands handled) */
2313   gtk_init (&argc, &argv);
2314
2315   cf_callback_add(main_cf_callback, NULL);
2316 #ifdef HAVE_LIBPCAP
2317   capture_callback_add(main_capture_callback, NULL);
2318 #endif
2319   cf_callback_add(statusbar_cf_callback, NULL);
2320 #ifdef HAVE_LIBPCAP
2321   capture_callback_add(statusbar_capture_callback, NULL);
2322 #endif
2323
2324   /* Arrange that if we have no console window, and a GLib message logging
2325      routine is called to log a message, we pop up a console window.
2326
2327      We do that by inserting our own handler for all messages logged
2328      to the default domain; that handler pops up a console if necessary,
2329      and then calls the default handler. */
2330
2331   /* We might want to have component specific log levels later ... */
2332
2333   log_flags =
2334                     G_LOG_LEVEL_ERROR|
2335                     G_LOG_LEVEL_CRITICAL|
2336                     G_LOG_LEVEL_WARNING|
2337                     G_LOG_LEVEL_MESSAGE|
2338                     G_LOG_LEVEL_INFO|
2339                     G_LOG_LEVEL_DEBUG|
2340                     G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION;
2341
2342   g_log_set_handler(NULL,
2343                     log_flags,
2344                     console_log_handler, NULL /* user_data */);
2345   g_log_set_handler(LOG_DOMAIN_MAIN,
2346                     log_flags,
2347                     console_log_handler, NULL /* user_data */);
2348
2349 #ifdef HAVE_LIBPCAP
2350   g_log_set_handler(LOG_DOMAIN_CAPTURE,
2351                     log_flags,
2352                     console_log_handler, NULL /* user_data */);
2353   g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
2354                     log_flags,
2355                     console_log_handler, NULL /* user_data */);
2356
2357   /* Set the initial values in the capture options. This might be overwritten
2358      by preference settings and then again by the command line parameters. */
2359   capture_opts_init(&global_capture_opts, &cfile);
2360 #endif
2361
2362   /* Initialize whatever we need to allocate colors for GTK+ */
2363   colors_init();
2364
2365   /* Non-blank filter means we're remote. Throttle splash screen and resolution updates. */
2366   filter = get_conn_cfilter();
2367   if ( *filter != '\0' ) {
2368     info_update_freq = 1000;  /* Milliseconds */
2369   }
2370
2371   /* We won't come till here, if we had a "console only" command line parameter. */
2372   splash_win = splash_new("Loading Wireshark ...");
2373   if (init_progfile_dir_error != NULL) {
2374     simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
2375         "Can't get pathname of Wireshark: %s.\n"
2376         "It won't be possible to capture traffic.\n"
2377         "Report this to the Wireshark developers.",
2378         init_progfile_dir_error);
2379     g_free(init_progfile_dir_error);
2380   }
2381
2382   splash_update(RA_DISSECTORS, NULL, (gpointer)splash_win);
2383
2384   /* Register all dissectors; we must do this before checking for the
2385      "-G" flag, as the "-G" flag dumps information registered by the
2386      dissectors, and we must do it before we read the preferences, in
2387      case any dissectors register preferences. */
2388   epan_init(register_all_protocols,register_all_protocol_handoffs,
2389             splash_update, (gpointer) splash_win,
2390             failure_alert_box,open_failure_alert_box,read_failure_alert_box,
2391             write_failure_alert_box);
2392
2393   splash_update(RA_LISTENERS, NULL, (gpointer)splash_win);
2394
2395   /* Register all tap listeners; we do this before we parse the arguments,
2396      as the "-z" argument can specify a registered tap. */
2397
2398   /* we register the plugin taps before the other taps because
2399           stats_tree taps plugins will be registered as tap listeners
2400           by stats_tree_stat.c and need to registered before that */
2401
2402 #ifdef HAVE_PLUGINS
2403   register_all_plugin_tap_listeners();
2404 #endif
2405
2406   register_all_tap_listeners();
2407
2408   splash_update(RA_PREFERENCES, NULL, (gpointer)splash_win);
2409
2410   /* Now register the preferences for any non-dissector modules.
2411      We must do that before we read the preferences as well. */
2412   prefs_register_modules();
2413
2414   prefs_p = read_configuration_files (&gdp_path, &dp_path);
2415   /* Removed thread code:
2416    * http://anonsvn.wireshark.org/viewvc/viewvc.cgi?view=rev&revision=35027
2417    */
2418
2419   /* this is to keep tap extensions updating once every 3 seconds */
2420   tap_update_timer_id = g_timeout_add(prefs_p->tap_update_interval, tap_update_cb, NULL);
2421
2422   splash_update(RA_CONFIGURATION, NULL, (gpointer)splash_win);
2423   proto_help_init();
2424   cap_file_init(&cfile);
2425
2426   /* Fill in capture options with values from the preferences */
2427   prefs_to_capture_opts();
2428
2429   /* Now get our args */
2430   while ((opt = getopt(argc, argv, optstring)) != -1) {
2431     switch (opt) {
2432       /*** capture option specific ***/
2433       case 'a':        /* autostop criteria */
2434       case 'b':        /* Ringbuffer option */
2435       case 'c':        /* Capture xxx packets */
2436       case 'f':        /* capture filter */
2437       case 'k':        /* Start capture immediately */
2438       case 'H':        /* Hide capture info dialog box */
2439       case 'i':        /* Use interface xxx */
2440       case 'p':        /* Don't capture in promiscuous mode */
2441 #ifdef HAVE_PCAP_CREATE
2442       case 'I':        /* Capture in monitor mode, if available */
2443 #endif
2444       case 'Q':        /* Quit after capture (just capture to file) */
2445       case 's':        /* Set the snapshot (capture) length */
2446       case 'S':        /* "Sync" mode: used for following file ala tail -f */
2447       case 'w':        /* Write to capture file xxx */
2448       case 'y':        /* Set the pcap data link type */
2449 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
2450       case 'B':        /* Buffer size */
2451 #endif /* _WIN32 or HAVE_PCAP_CREATE */
2452 #ifdef HAVE_LIBPCAP
2453         status = capture_opts_add_opt(&global_capture_opts, opt, optarg,
2454                                       &start_capture);
2455         if(status != 0) {
2456             exit(status);
2457         }
2458 #else
2459         capture_option_specified = TRUE;
2460         arg_error = TRUE;
2461 #endif
2462         break;
2463
2464 #if defined(HAVE_HEIMDAL_KERBEROS) || defined(HAVE_MIT_KERBEROS)
2465       case 'K':        /* Kerberos keytab file */
2466         read_keytab_file(optarg);
2467         break;
2468 #endif
2469
2470       /*** all non capture option specific ***/
2471       case 'C':
2472         /* Configuration profile settings were already processed just ignore them this time*/
2473         break;
2474       case 'j':        /* Search backwards for a matching packet from filter in option J */
2475         jump_backwards = TRUE;
2476         break;
2477       case 'g':        /* Go to packet with the given packet number */
2478         go_to_packet = get_positive_int(optarg, "go to packet");
2479         break;
2480       case 'J':        /* Jump to the first packet which matches the filter criteria */
2481         jfilter = optarg;
2482         break;
2483       case 'l':        /* Automatic scrolling in live capture mode */
2484 #ifdef HAVE_LIBPCAP
2485         auto_scroll_live = TRUE;
2486 #else
2487         capture_option_specified = TRUE;
2488         arg_error = TRUE;
2489 #endif
2490         break;
2491       case 'L':        /* Print list of link-layer types and exit */
2492 #ifdef HAVE_LIBPCAP
2493         list_link_layer_types = TRUE;
2494 #else
2495         capture_option_specified = TRUE;
2496         arg_error = TRUE;
2497 #endif
2498         break;
2499       case 'm':        /* Fixed-width font for the display */
2500         g_free(prefs_p->gui_font_name);
2501         prefs_p->gui_font_name = g_strdup(optarg);
2502         break;
2503       case 'n':        /* No name resolution */
2504         gbl_resolv_flags = RESOLV_NONE;
2505         break;
2506       case 'N':        /* Select what types of addresses/port #s to resolve */
2507         if (gbl_resolv_flags == RESOLV_ALL)
2508           gbl_resolv_flags = RESOLV_NONE;
2509         badopt = string_to_name_resolve(optarg, &gbl_resolv_flags);
2510         if (badopt != '\0') {
2511           cmdarg_err("-N specifies unknown resolving option '%c'; valid options are 'm', 'n', and 't'",
2512                         badopt);
2513           exit(1);
2514         }
2515         break;
2516       case 'o':        /* Override preference from command line */
2517         switch (prefs_set_pref(optarg)) {
2518         case PREFS_SET_OK:
2519           break;
2520         case PREFS_SET_SYNTAX_ERR:
2521           cmdarg_err("Invalid -o flag \"%s\"", optarg);
2522           exit(1);
2523           break;
2524         case PREFS_SET_NO_SUCH_PREF:
2525           /* not a preference, might be a recent setting */
2526           switch (recent_set_arg(optarg)) {
2527             case PREFS_SET_OK:
2528               break;
2529             case PREFS_SET_SYNTAX_ERR:
2530               /* shouldn't happen, checked already above */
2531               cmdarg_err("Invalid -o flag \"%s\"", optarg);
2532               exit(1);
2533               break;
2534             case PREFS_SET_NO_SUCH_PREF:
2535             case PREFS_SET_OBSOLETE:
2536               cmdarg_err("-o flag \"%s\" specifies unknown preference/recent value",
2537                     optarg);
2538               exit(1);
2539               break;
2540             default:
2541               g_assert_not_reached();
2542             }
2543           break;
2544         case PREFS_SET_OBSOLETE:
2545           cmdarg_err("-o flag \"%s\" specifies obsolete preference",
2546                         optarg);
2547           exit(1);
2548           break;
2549         default:
2550           g_assert_not_reached();
2551         }
2552         break;
2553       case 'P':
2554         /* Path settings were already processed just ignore them this time*/
2555         break;
2556       case 'r':        /* Read capture file xxx */
2557         /* We may set "last_open_dir" to "cf_name", and if we change
2558            "last_open_dir" later, we free the old value, so we have to
2559            set "cf_name" to something that's been allocated. */
2560         cf_name = g_strdup(optarg);
2561         break;
2562       case 'R':        /* Read file filter */
2563         rfilter = optarg;
2564         break;
2565       case 't':        /* Time stamp type */
2566         if (strcmp(optarg, "r") == 0)
2567           timestamp_set_type(TS_RELATIVE);
2568         else if (strcmp(optarg, "a") == 0)
2569           timestamp_set_type(TS_ABSOLUTE);
2570         else if (strcmp(optarg, "ad") == 0)
2571           timestamp_set_type(TS_ABSOLUTE_WITH_DATE);
2572         else if (strcmp(optarg, "d") == 0)
2573           timestamp_set_type(TS_DELTA);
2574         else if (strcmp(optarg, "dd") == 0)
2575           timestamp_set_type(TS_DELTA_DIS);
2576         else if (strcmp(optarg, "e") == 0)
2577           timestamp_set_type(TS_EPOCH);
2578         else if (strcmp(optarg, "u") == 0)
2579           timestamp_set_type(TS_UTC);
2580         else if (strcmp(optarg, "ud") == 0)
2581           timestamp_set_type(TS_UTC_WITH_DATE);
2582         else {
2583           cmdarg_err("Invalid time stamp type \"%s\"", optarg);
2584           cmdarg_err_cont("It must be \"r\" for relative, \"a\" for absolute,");
2585           cmdarg_err_cont("\"ad\" for absolute with date, or \"d\" for delta.");
2586           exit(1);
2587         }
2588         break;
2589       case 'u':        /* Seconds type */
2590         if (strcmp(optarg, "s") == 0)
2591           timestamp_set_seconds_type(TS_SECONDS_DEFAULT);
2592         else if (strcmp(optarg, "hms") == 0)
2593           timestamp_set_seconds_type(TS_SECONDS_HOUR_MIN_SEC);
2594         else {
2595           cmdarg_err("Invalid seconds type \"%s\"", optarg);
2596           cmdarg_err_cont("It must be \"s\" for seconds or \"hms\" for hours, minutes and seconds.");
2597           exit(1);
2598         }
2599         break;
2600       case 'X':
2601           /* ext ops were already processed just ignore them this time*/
2602           break;
2603       case 'z':
2604         /* We won't call the init function for the stat this soon
2605            as it would disallow MATE's fields (which are registered
2606            by the preferences set callback) from being used as
2607            part of a tap filter.  Instead, we just add the argument
2608            to a list of stat arguments. */
2609         if (!process_stat_cmd_arg(optarg)) {
2610           cmdarg_err("Invalid -z argument.");
2611           cmdarg_err_cont("  -z argument must be one of :");
2612           list_stat_cmd_args();
2613           exit(1);
2614         }
2615         break;
2616       default:
2617       case '?':        /* Bad flag - print usage message */
2618         arg_error = TRUE;
2619         break;
2620     }
2621   }
2622   if (!arg_error) {
2623     argc -= optind;
2624     argv += optind;
2625     if (argc >= 1) {
2626       if (cf_name != NULL) {
2627         /*
2628          * Input file name specified with "-r" *and* specified as a regular
2629          * command-line argument.
2630          */
2631         cmdarg_err("File name specified both with -r and regular argument");
2632         arg_error = TRUE;
2633       } else {
2634         /*
2635          * Input file name not specified with "-r", and a command-line argument
2636          * was specified; treat it as the input file name.
2637          *
2638          * Yes, this is different from tshark, where non-flag command-line
2639          * arguments are a filter, but this works better on GUI desktops
2640          * where a command can be specified to be run to open a particular
2641          * file - yes, you could have "-r" as the last part of the command,
2642          * but that's a bit ugly.
2643          */
2644         cf_name = g_strdup(argv[0]);
2645       }
2646       argc--;
2647       argv++;
2648     }
2649
2650     if (argc != 0) {
2651       /*
2652        * Extra command line arguments were specified; complain.
2653        */
2654       cmdarg_err("Invalid argument: %s", argv[0]);
2655       arg_error = TRUE;
2656     }
2657   }
2658   if (arg_error) {
2659 #ifndef HAVE_LIBPCAP
2660     if (capture_option_specified) {
2661       cmdarg_err("This version of Wireshark was not built with support for capturing packets.");
2662     }
2663 #endif
2664     print_usage(FALSE);
2665     exit(1);
2666   }
2667
2668 #ifdef HAVE_LIBPCAP
2669   if (start_capture && list_link_layer_types) {
2670     /* Specifying *both* is bogus. */
2671     cmdarg_err("You can't specify both -L and a live capture.");
2672     exit(1);
2673   }
2674
2675   if (list_link_layer_types) {
2676     /* We're supposed to list the link-layer types for an interface;
2677        did the user also specify a capture file to be read? */
2678     if (cf_name) {
2679       /* Yes - that's bogus. */
2680       cmdarg_err("You can't specify -L and a capture file to be read.");
2681       exit(1);
2682     }
2683     /* No - did they specify a ring buffer option? */
2684     if (global_capture_opts.multi_files_on) {
2685       cmdarg_err("Ring buffer requested, but a capture isn't being done.");
2686       exit(1);
2687     }
2688   } else {
2689     /* We're supposed to do a live capture; did the user also specify
2690        a capture file to be read? */
2691     if (start_capture && cf_name) {
2692       /* Yes - that's bogus. */
2693       cmdarg_err("You can't specify both a live capture and a capture file to be read.");
2694       exit(1);
2695     }
2696
2697     /* No - was the ring buffer option specified and, if so, does it make
2698        sense? */
2699     if (global_capture_opts.multi_files_on) {
2700       /* Ring buffer works only under certain conditions:
2701          a) ring buffer does not work with temporary files;
2702          b) real_time_mode and multi_files_on are mutually exclusive -
2703             real_time_mode takes precedence;
2704          c) it makes no sense to enable the ring buffer if the maximum
2705             file size is set to "infinite". */
2706       if (global_capture_opts.save_file == NULL) {
2707         cmdarg_err("Ring buffer requested, but capture isn't being saved to a permanent file.");
2708         global_capture_opts.multi_files_on = FALSE;
2709       }
2710 /*      if (global_capture_opts.real_time_mode) {
2711         cmdarg_err("Ring buffer requested, but an \"Update list of packets in real time\" capture is being done.");
2712         global_capture_opts.multi_files_on = FALSE;
2713       }*/
2714       if (!global_capture_opts.has_autostop_filesize && !global_capture_opts.has_file_duration) {
2715         cmdarg_err("Ring buffer requested, but no maximum capture file size or duration were specified.");
2716 /* XXX - this must be redesigned as the conditions changed */
2717 /*      global_capture_opts.multi_files_on = FALSE;*/
2718       }
2719     }
2720   }
2721
2722   if (start_capture || list_link_layer_types) {
2723     /* Did the user specify an interface to use? */
2724     if (!capture_opts_trim_iface(&global_capture_opts,
2725         (prefs_p->capture_device) ? get_if_name(prefs_p->capture_device) : NULL)) {
2726         exit(2);
2727     }
2728   }
2729
2730   if (list_link_layer_types) {
2731     /* Get the list of link-layer types for the capture devices. */
2732     if_capabilities_t *caps;
2733     guint i;
2734     interface_options interface_opts;
2735
2736     for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2737
2738       interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2739       caps = capture_get_if_capabilities(interface_opts.name, interface_opts.monitor_mode, &err_str);
2740       if (caps == NULL) {
2741         cmdarg_err("%s", err_str);
2742         g_free(err_str);
2743         exit(2);
2744       }
2745       if (caps->data_link_types == NULL) {
2746         cmdarg_err("The capture device \"%s\" has no data link types.", interface_opts.name);
2747         exit(2);
2748       }
2749       capture_opts_print_if_capabilities(caps, interface_opts.name, interface_opts.monitor_mode);
2750       free_if_capabilities(caps);
2751     }
2752     exit(0);
2753   }
2754
2755   capture_opts_trim_snaplen(&global_capture_opts, MIN_PACKET_SIZE);
2756   capture_opts_trim_ring_num_files(&global_capture_opts);
2757 #endif /* HAVE_LIBPCAP */
2758
2759   /* Notify all registered modules that have had any of their preferences
2760      changed either from one of the preferences file or from the command
2761      line that their preferences have changed. */
2762   prefs_apply_all();
2763
2764 #ifdef HAVE_LIBPCAP
2765 #ifndef USE_THREADS
2766   if ((global_capture_opts.ifaces->len > 1) && start_capture) {
2767     cmdarg_err("You specified multiple interfaces for capturing which this version of Wireshark doesn't support.");
2768     exit(2);
2769   }
2770 #endif
2771   if ((global_capture_opts.ifaces->len == 0) &&
2772       (prefs.capture_device != NULL)) {
2773     interface_options interface_opts;
2774
2775     interface_opts.name = g_strdup(get_if_name(prefs.capture_device));
2776     interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
2777     interface_opts.monitor_mode = prefs_capture_device_monitor_mode(interface_opts.name);
2778     interface_opts.linktype = capture_dev_user_linktype_find(interface_opts.name);
2779     interface_opts.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
2780     interface_opts.snaplen = global_capture_opts.default_options.snaplen;
2781     interface_opts.has_snaplen = global_capture_opts.default_options.has_snaplen;
2782     interface_opts.promisc_mode = global_capture_opts.default_options.promisc_mode;
2783 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
2784     interface_opts.buffer_size =  global_capture_opts.default_options.buffer_size;
2785 #endif
2786 #ifdef HAVE_PCAP_REMOTE
2787     interface_opts.src_type = global_capture_opts.default_options.src_type;
2788     interface_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
2789     interface_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
2790     interface_opts.auth_type = global_capture_opts.default_options.auth_type;
2791     interface_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
2792     interface_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
2793     interface_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
2794     interface_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
2795     interface_opts.nocap_local = global_capture_opts.default_options.nocap_local;
2796  #endif
2797  #ifdef HAVE_PCAP_SETSAMPLING
2798     interface_opts.sampling_method = global_capture_opts.default_options.sampling_method;
2799     interface_opts.sampling_param  = global_capture_opts.default_options.sampling_param;
2800  #endif
2801     g_array_insert_val(global_capture_opts.ifaces, 0, interface_opts);
2802   }
2803 #endif
2804
2805   /* disabled protocols as per configuration file */
2806   if (gdp_path == NULL && dp_path == NULL) {
2807     set_disabled_protos_list();
2808   }
2809
2810   build_column_format_array(&cfile.cinfo, prefs_p->num_cols, TRUE);
2811
2812   /* read in rc file from global and personal configuration paths. */
2813   rc_file = get_datafile_path(RC_FILE);
2814   gtk_rc_parse(rc_file);
2815   g_free(rc_file);
2816   rc_file = get_persconffile_path(RC_FILE, FALSE, FALSE);
2817   gtk_rc_parse(rc_file);
2818   g_free(rc_file);
2819
2820   font_init();
2821
2822   macros_init();
2823
2824   stock_icons_init();
2825
2826   /* close the splash screen, as we are going to open the main window now */
2827   splash_destroy(splash_win);
2828
2829   /************************************************************************/
2830   /* Everything is prepared now, preferences and command line was read in */
2831
2832   /* Pop up the main window. */
2833   create_main_window(pl_size, tv_size, bv_size, prefs_p);
2834
2835   /* Read the dynamic part of the recent file, as we have the gui now ready for it. */
2836   recent_read_dynamic(&rf_path, &rf_open_errno);
2837   if (rf_path != NULL && rf_open_errno != 0) {
2838     simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
2839                   "Could not open recent file\n\"%s\": %s.",
2840                   rf_path, g_strerror(rf_open_errno));
2841   }
2842
2843   color_filters_enable(recent.packet_list_colorize);
2844
2845   /* rearrange all the widgets as we now have all recent settings ready for this */
2846   main_widgets_rearrange();
2847
2848   /* Fill in column titles.  This must be done after the top level window
2849      is displayed.
2850
2851      XXX - is that still true, with fixed-width columns? */
2852
2853   menu_recent_read_finished();
2854 #ifdef HAVE_LIBPCAP
2855   menu_auto_scroll_live_changed(auto_scroll_live);
2856 #endif
2857
2858   switch (user_font_apply()) {
2859   case FA_SUCCESS:
2860       break;
2861   case FA_FONT_NOT_RESIZEABLE:
2862       /* "user_font_apply()" popped up an alert box. */
2863       /* turn off zooming - font can't be resized */
2864   case FA_FONT_NOT_AVAILABLE:
2865       /* XXX - did we successfully load the un-zoomed version earlier?
2866       If so, this *probably* means the font is available, but not at
2867       this particular zoom level, but perhaps some other failure
2868       occurred; I'm not sure you can determine which is the case,
2869       however. */
2870       /* turn off zooming - zoom level is unavailable */
2871   default:
2872       /* in any other case than FA_SUCCESS, turn off zooming */
2873       recent.gui_zoom_level = 0;
2874       /* XXX: would it be a good idea to disable zooming (insensitive GUI)? */
2875   }
2876
2877   dnd_init(top_level);
2878
2879   color_filters_init();
2880   decode_as_init();
2881
2882   /* the window can be sized only, if it's not already shown, so do it now! */
2883   main_load_window_geometry(top_level);
2884
2885   g_timeout_add(info_update_freq, resolv_update_cb, NULL);
2886
2887
2888   /* If we were given the name of a capture file, read it in now;
2889      we defer it until now, so that, if we can't open it, and pop
2890      up an alert box, the alert box is more likely to come up on
2891      top of the main window - but before the preference-file-error
2892      alert box, so, if we get one of those, it's more likely to come
2893      up on top of us. */
2894   if (cf_name) {
2895     show_main_window(TRUE);
2896     check_and_warn_user_startup(cf_name);
2897     if (rfilter != NULL) {
2898       if (!dfilter_compile(rfilter, &rfcode)) {
2899         bad_dfilter_alert_box(rfilter);
2900         rfilter_parse_failed = TRUE;
2901       }
2902     }
2903     if (!rfilter_parse_failed) {
2904       if (cf_open(&cfile, cf_name, FALSE, &err) == CF_OK) {
2905         /* "cf_open()" succeeded, so it closed the previous
2906            capture file, and thus destroyed any previous read filter
2907            attached to "cf". */
2908
2909         cfile.rfcode = rfcode;
2910         /* Open stat windows; we do so after creating the main window,
2911            to avoid GTK warnings, and after successfully opening the
2912            capture file, so we know we have something to compute stats
2913            on, and after registering all dissectors, so that MATE will
2914            have registered its field array and we can have a tap filter
2915            with one of MATE's late-registered fields as part of the
2916            filter. */
2917         start_requested_stats();
2918
2919         /* Read the capture file. */
2920         switch (cf_read(&cfile, FALSE)) {
2921
2922         case CF_READ_OK:
2923         case CF_READ_ERROR:
2924           /* Just because we got an error, that doesn't mean we were unable
2925              to read any of the file; we handle what we could get from the
2926              file. */
2927           /* if the user told us to jump to a specific packet, do it now */
2928           if(go_to_packet != 0) {
2929             /* Jump to the specified frame number, kept for backward
2930                compatibility. */
2931             cf_goto_frame(&cfile, go_to_packet);
2932           } else if (jfilter != NULL) {
2933             /* try to compile given filter */
2934             if (!dfilter_compile(jfilter, &jump_to_filter)) {
2935               bad_dfilter_alert_box(jfilter);
2936             } else {
2937               /* Filter ok, jump to the first packet matching the filter
2938                  conditions. Default search direction is forward, but if
2939                  option d was given, search backwards */
2940               cf_find_packet_dfilter(&cfile, jump_to_filter, jump_backwards);
2941             }
2942           }
2943           break;
2944
2945         case CF_READ_ABORTED:
2946           /* Exit now. */
2947           exit(0);
2948           break;
2949         }
2950
2951         /* If the filename is not the absolute path, prepend the current dir. This happens
2952            when wireshark is invoked from a cmd shell (e.g.,'wireshark -r file.pcap'). */
2953         if (!g_path_is_absolute(cf_name)) {
2954           char *old_cf_name = cf_name;
2955           char *pwd = g_get_current_dir();
2956           cf_name = g_strdup_printf("%s%s%s", pwd, G_DIR_SEPARATOR_S, cf_name);
2957           g_free(old_cf_name);
2958           g_free(pwd);
2959         }
2960
2961         /* Save the name of the containing directory specified in the
2962            path name, if any; we can write over cf_name, which is a
2963            good thing, given that "get_dirname()" does write over its
2964            argument. */
2965         s = get_dirname(cf_name);
2966         set_last_open_dir(s);
2967         g_free(cf_name);
2968         cf_name = NULL;
2969       } else {
2970         if (rfcode != NULL)
2971           dfilter_free(rfcode);
2972         cfile.rfcode = NULL;
2973         show_main_window(FALSE);
2974         /* Don't call check_and_warn_user_startup(): we did it above */
2975         set_menus_for_capture_in_progress(FALSE);
2976         set_capture_if_dialog_for_capture_in_progress(FALSE);
2977       }
2978     }
2979   } else {
2980 #ifdef HAVE_LIBPCAP
2981     if (start_capture) {
2982       if (global_capture_opts.save_file != NULL) {
2983         /* Save the directory name for future file dialogs. */
2984         /* (get_dirname overwrites filename) */
2985         s = get_dirname(g_strdup(global_capture_opts.save_file));
2986         set_last_open_dir(s);
2987         g_free(s);
2988       }
2989       /* "-k" was specified; start a capture. */
2990       show_main_window(TRUE);
2991       check_and_warn_user_startup(cf_name);
2992       if (capture_start(&global_capture_opts)) {
2993         /* The capture started.  Open stat windows; we do so after creating
2994            the main window, to avoid GTK warnings, and after successfully
2995            opening the capture file, so we know we have something to compute
2996            stats on, and after registering all dissectors, so that MATE will
2997            have registered its field array and we can have a tap filter with
2998            one of MATE's late-registered fields as part of the filter. */
2999         start_requested_stats();
3000       }
3001     } else {
3002       show_main_window(FALSE);
3003       check_and_warn_user_startup(cf_name);
3004       set_menus_for_capture_in_progress(FALSE);
3005       set_capture_if_dialog_for_capture_in_progress(FALSE);
3006     }
3007
3008     /* if the user didn't supply a capture filter, use the one to filter out remote connections like SSH */
3009     if (!start_capture && !global_capture_opts.default_options.cfilter) {
3010       global_capture_opts.default_options.cfilter = g_strdup(get_conn_cfilter());
3011     }
3012 #else /* HAVE_LIBPCAP */
3013     show_main_window(FALSE);
3014     check_and_warn_user_startup(cf_name);
3015     set_menus_for_capture_in_progress(FALSE);
3016     set_capture_if_dialog_for_capture_in_progress(FALSE);
3017 #endif /* HAVE_LIBPCAP */
3018   }
3019
3020   /* register our pid if we are being run from a U3 device */
3021   u3_register_pid();
3022
3023   profile_store_persconffiles (FALSE);
3024
3025 #ifdef HAVE_GTKOSXAPPLICATION
3026   theApp = g_object_new(GTK_TYPE_OSX_APPLICATION, NULL);
3027   gtk_osxapplication_set_dock_icon_pixbuf(theApp,gdk_pixbuf_new_from_xpm_data(wsicon64_xpm));
3028   gtk_osxapplication_ready(theApp);
3029 #endif
3030
3031   g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_INFO, "Wireshark is up and ready to go");
3032
3033   /* we'll enter the GTK loop now and hand the control over to GTK ... */
3034   gtk_main();
3035   /* ... back from GTK, we're going down now! */
3036
3037   /* deregister our pid */
3038   u3_deregister_pid();
3039
3040   epan_cleanup();
3041
3042   AirPDcapDestroyContext(&airpdcap_ctx);
3043
3044 #ifdef _WIN32
3045   /* hide the (unresponsive) main window, while asking the user to close the console window */
3046   gtk_widget_hide(top_level);
3047
3048 #ifdef HAVE_GTKOSXAPPLICATION
3049   g_object_unref(theApp);
3050 #endif
3051
3052   /* Shutdown windows sockets */
3053   WSACleanup();
3054
3055   /* For some unknown reason, the "atexit()" call in "create_console()"
3056      doesn't arrange that "destroy_console()" be called when we exit,
3057      so we call it here if a console was created. */
3058   destroy_console();
3059 #endif
3060
3061   exit(0);
3062 }
3063
3064 #ifdef _WIN32
3065
3066 /* We build this as a GUI subsystem application on Win32, so
3067    "WinMain()", not "main()", gets called.
3068
3069    Hack shamelessly stolen from the Win32 port of the GIMP. */
3070 #ifdef __GNUC__
3071 #define _stdcall  __attribute__((stdcall))
3072 #endif
3073
3074 int _stdcall
3075 WinMain (struct HINSTANCE__ *hInstance,
3076          struct HINSTANCE__ *hPrevInstance,
3077          char               *lpszCmdLine,
3078          int                 nCmdShow)
3079 {
3080   INITCOMMONCONTROLSEX comm_ctrl;
3081
3082   /*
3083    * Initialize our DLL search path. MUST be called before LoadLibrary
3084    * or g_module_open.
3085    */
3086   ws_init_dll_search_path();
3087
3088   /* Initialize our controls. Required for native Windows file dialogs. */
3089   memset (&comm_ctrl, 0, sizeof(comm_ctrl));
3090   comm_ctrl.dwSize = sizeof(comm_ctrl);
3091   /* Includes the animate, header, hot key, list view, progress bar,
3092    * status bar, tab, tooltip, toolbar, trackbar, tree view, and
3093    * up-down controls
3094    */
3095   comm_ctrl.dwICC = ICC_WIN95_CLASSES;
3096   InitCommonControlsEx(&comm_ctrl);
3097
3098   /* RichEd20.DLL is needed for filter entries. */
3099   ws_load_library("riched20.dll");
3100
3101   has_console = FALSE;
3102   console_wait = FALSE;
3103   return main (__argc, __argv);
3104 }
3105
3106 /* The code to create and desstroy console windows should not be necessary,
3107    at least as I read the GLib source code, as it looks as if GLib is, on
3108    Win32, *supposed* to create a console window into which to display its
3109    output.
3110
3111    That doesn't happen, however.  I suspect there's something completely
3112    broken about that code in GLib-for-Win32, and that it may be related
3113    to the breakage that forces us to just call "printf()" on the message
3114    rather than passing the message on to "g_log_default_handler()"
3115    (which is the routine that does the aforementioned non-functional
3116    console window creation).  */
3117
3118 /*
3119  * If this application has no console window to which its standard output
3120  * would go, create one.
3121  */
3122 void
3123 create_console(void)
3124 {
3125   if (stdin_capture) {
3126     /* We've been handed "-i -". Don't mess with stdio. */
3127     return;
3128   }
3129
3130   if (!has_console) {
3131     /* We have no console to which to print the version string, so
3132        create one and make it the standard input, output, and error. */
3133
3134     /*
3135      * See if we have an existing console (i.e. we were run from a
3136      * command prompt)
3137      */
3138     if (!AttachConsole(ATTACH_PARENT_PROCESS)) {
3139       if (AllocConsole()) {
3140         console_wait = TRUE;
3141         SetConsoleTitle(_T("Wireshark Debug Console"));
3142       } else {
3143         return;   /* couldn't create console */
3144       }
3145     }
3146
3147     ws_freopen("CONIN$", "r", stdin);
3148     ws_freopen("CONOUT$", "w", stdout);
3149     ws_freopen("CONOUT$", "w", stderr);
3150     fprintf(stdout, "\n");
3151     fprintf(stderr, "\n");
3152
3153     /* Now register "destroy_console()" as a routine to be called just
3154        before the application exits, so that we can destroy the console
3155        after the user has typed a key (so that the console doesn't just
3156        disappear out from under them, giving the user no chance to see
3157        the message(s) we put in there). */
3158     atexit(destroy_console);
3159
3160     /* Well, we have a console now. */
3161     has_console = TRUE;
3162   }
3163 }
3164
3165 static void
3166 destroy_console(void)
3167 {
3168   if (console_wait) {
3169     printf("\n\nPress any key to exit\n");
3170     _getch();
3171   }
3172   FreeConsole();
3173 }
3174 #endif /* _WIN32 */
3175
3176
3177 static void
3178 console_log_handler(const char *log_domain, GLogLevelFlags log_level,
3179                     const char *message, gpointer user_data _U_)
3180 {
3181   time_t curr;
3182   struct tm *today;
3183   const char *level;
3184
3185
3186   /* ignore log message, if log_level isn't interesting based
3187      upon the console log preferences.
3188      If the preferences haven't been loaded loaded yet, display the
3189      message anyway.
3190
3191      The default console_log_level preference value is such that only
3192        ERROR, CRITICAL and WARNING level messages are processed;
3193        MESSAGE, INFO and DEBUG level messages are ignored.  */
3194   if((log_level & G_LOG_LEVEL_MASK & prefs.console_log_level) == 0 &&
3195      prefs.console_log_level != 0) {
3196     return;
3197   }
3198
3199 #ifdef _WIN32
3200   if (prefs.gui_console_open != console_open_never || log_level & G_LOG_LEVEL_ERROR) {
3201     /* the user wants a console or the application will terminate immediately */
3202     create_console();
3203   }
3204   if (has_console) {
3205     /* For some unknown reason, the above doesn't appear to actually cause
3206        anything to be sent to the standard output, so we'll just splat the
3207        message out directly, just to make sure it gets out. */
3208 #endif
3209     switch(log_level & G_LOG_LEVEL_MASK) {
3210     case G_LOG_LEVEL_ERROR:
3211         level = "Err ";
3212         break;
3213     case G_LOG_LEVEL_CRITICAL:
3214         level = "Crit";
3215         break;
3216     case G_LOG_LEVEL_WARNING:
3217         level = "Warn";
3218         break;
3219     case G_LOG_LEVEL_MESSAGE:
3220         level = "Msg ";
3221         break;
3222     case G_LOG_LEVEL_INFO:
3223         level = "Info";
3224         break;
3225     case G_LOG_LEVEL_DEBUG:
3226         level = "Dbg ";
3227         break;
3228     default:
3229         fprintf(stderr, "unknown log_level %u\n", log_level);
3230         level = NULL;
3231         g_assert_not_reached();
3232     }
3233
3234     /* create a "timestamp" */
3235     time(&curr);
3236     today = localtime(&curr);
3237
3238     fprintf(stderr, "%02u:%02u:%02u %8s %s %s\n",
3239             today->tm_hour, today->tm_min, today->tm_sec,
3240             log_domain != NULL ? log_domain : "",
3241             level, message);
3242 #ifdef _WIN32
3243     if(log_level & G_LOG_LEVEL_ERROR) {
3244         /* wait for a key press before the following error handler will terminate the program
3245            this way the user at least can read the error message */
3246         printf("\n\nPress any key to exit\n");
3247         _getch();
3248     }
3249   } else {
3250     /* XXX - on UN*X, should we just use g_log_default_handler()?
3251        We want the error messages to go to the standard output;
3252        on Mac OS X, that will cause them to show up in various
3253        per-user logs accessible through Console (details depend
3254        on whether you're running 10.0 through 10.4 or running
3255        10.5 and later), and, on other UN*X desktop environments,
3256        if they don't show up in some form of console log, that's
3257        a deficiency in that desktop environment.  (Too bad
3258        Windows doesn't set the standard output and error for
3259        GUI apps to something that shows up in such a log.) */
3260     g_log_default_handler(log_domain, log_level, message, user_data);
3261   }
3262 #endif
3263 }
3264
3265
3266 /*
3267  * Helper for main_widgets_rearrange()
3268  */
3269 static void foreach_remove_a_child(GtkWidget *widget, gpointer data) {
3270     gtk_container_remove(GTK_CONTAINER(data), widget);
3271 }
3272
3273 static GtkWidget *main_widget_layout(gint layout_content)
3274 {
3275     switch(layout_content) {
3276     case(layout_pane_content_none):
3277         return NULL;
3278     case(layout_pane_content_plist):
3279         return pkt_scrollw;
3280     case(layout_pane_content_pdetails):
3281         return tv_scrollw;
3282     case(layout_pane_content_pbytes):
3283         return byte_nb_ptr_gbl;
3284     default:
3285         g_assert_not_reached();
3286         return NULL;
3287     }
3288 }
3289
3290
3291 /*
3292  * Rearrange the main window widgets
3293  */
3294 void main_widgets_rearrange(void) {
3295     GtkWidget *first_pane_widget1, *first_pane_widget2;
3296     GtkWidget *second_pane_widget1, *second_pane_widget2;
3297     gboolean split_top_left;
3298
3299     /* be a bit faster */
3300     gtk_widget_hide(main_vbox);
3301
3302     /* be sure we don't lose a widget while rearranging */
3303     g_object_ref(G_OBJECT(menubar));
3304     g_object_ref(G_OBJECT(main_tb));
3305     g_object_ref(G_OBJECT(filter_tb));
3306 #ifdef HAVE_AIRPCAP
3307     g_object_ref(G_OBJECT(airpcap_tb));
3308 #endif
3309     g_object_ref(G_OBJECT(pkt_scrollw));
3310     g_object_ref(G_OBJECT(tv_scrollw));
3311     g_object_ref(G_OBJECT(byte_nb_ptr_gbl));
3312     g_object_ref(G_OBJECT(statusbar));
3313     g_object_ref(G_OBJECT(main_pane_v1));
3314     g_object_ref(G_OBJECT(main_pane_v2));
3315     g_object_ref(G_OBJECT(main_pane_h1));
3316     g_object_ref(G_OBJECT(main_pane_h2));
3317     g_object_ref(G_OBJECT(welcome_pane));
3318
3319     /* empty all containers participating */
3320     gtk_container_foreach(GTK_CONTAINER(main_vbox),     foreach_remove_a_child, main_vbox);
3321     gtk_container_foreach(GTK_CONTAINER(main_pane_v1),  foreach_remove_a_child, main_pane_v1);
3322     gtk_container_foreach(GTK_CONTAINER(main_pane_v2),  foreach_remove_a_child, main_pane_v2);
3323     gtk_container_foreach(GTK_CONTAINER(main_pane_h1),  foreach_remove_a_child, main_pane_h1);
3324     gtk_container_foreach(GTK_CONTAINER(main_pane_h2),  foreach_remove_a_child, main_pane_h2);
3325
3326     statusbar_widgets_emptying(statusbar);
3327
3328     /* add the menubar always at the top */
3329     gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0);
3330
3331     /* main toolbar */
3332     gtk_box_pack_start(GTK_BOX(main_vbox), main_tb, FALSE, TRUE, 0);
3333
3334     /* filter toolbar in toolbar area */
3335     if (!prefs.filter_toolbar_show_in_statusbar) {
3336         gtk_box_pack_start(GTK_BOX(main_vbox), filter_tb, FALSE, TRUE, 1);
3337     }
3338
3339 #ifdef HAVE_AIRPCAP
3340     /* airpcap toolbar */
3341     gtk_box_pack_start(GTK_BOX(main_vbox), airpcap_tb, FALSE, TRUE, 1);
3342 #endif
3343
3344     /* fill the main layout panes */
3345     switch(prefs.gui_layout_type) {
3346     case(layout_type_5):
3347         main_first_pane  = main_pane_v1;
3348         main_second_pane = main_pane_v2;
3349         split_top_left = FALSE;
3350         break;
3351     case(layout_type_2):
3352         main_first_pane  = main_pane_v1;
3353         main_second_pane = main_pane_h1;
3354         split_top_left = FALSE;
3355         break;
3356     case(layout_type_1):
3357         main_first_pane  = main_pane_v1;
3358         main_second_pane = main_pane_h1;
3359         split_top_left = TRUE;
3360         break;
3361     case(layout_type_4):
3362         main_first_pane  = main_pane_h1;
3363         main_second_pane = main_pane_v1;
3364         split_top_left = FALSE;
3365         break;
3366     case(layout_type_3):
3367         main_first_pane  = main_pane_h1;
3368         main_second_pane = main_pane_v1;
3369         split_top_left = TRUE;
3370         break;
3371     case(layout_type_6):
3372         main_first_pane  = main_pane_h1;
3373         main_second_pane = main_pane_h2;
3374         split_top_left = FALSE;
3375         break;
3376     default:
3377         main_first_pane = NULL;
3378         main_second_pane = NULL;
3379         split_top_left = FALSE;
3380         g_assert_not_reached();
3381     }
3382     if (split_top_left) {
3383         first_pane_widget1 = main_second_pane;
3384         second_pane_widget1 = main_widget_layout(prefs.gui_layout_content_1);
3385         second_pane_widget2 = main_widget_layout(prefs.gui_layout_content_2);
3386         first_pane_widget2 = main_widget_layout(prefs.gui_layout_content_3);
3387     } else {
3388         first_pane_widget1 = main_widget_layout(prefs.gui_layout_content_1);
3389         first_pane_widget2 = main_second_pane;
3390         second_pane_widget1 = main_widget_layout(prefs.gui_layout_content_2);
3391         second_pane_widget2 = main_widget_layout(prefs.gui_layout_content_3);
3392     }
3393     if (first_pane_widget1 != NULL)
3394         gtk_paned_add1(GTK_PANED(main_first_pane), first_pane_widget1);
3395     if (first_pane_widget2 != NULL)
3396         gtk_paned_add2(GTK_PANED(main_first_pane), first_pane_widget2);
3397     if (second_pane_widget1 != NULL)
3398         gtk_paned_pack1(GTK_PANED(main_second_pane), second_pane_widget1, TRUE, TRUE);
3399     if (second_pane_widget2 != NULL)
3400         gtk_paned_pack2(GTK_PANED(main_second_pane), second_pane_widget2, FALSE, FALSE);
3401
3402     gtk_container_add(GTK_CONTAINER(main_vbox), main_first_pane);
3403
3404     /* welcome pane */
3405     gtk_box_pack_start(GTK_BOX(main_vbox), welcome_pane, TRUE, TRUE, 0);
3406
3407     /* statusbar */
3408     gtk_box_pack_start(GTK_BOX(main_vbox), statusbar, FALSE, TRUE, 0);
3409
3410     /* filter toolbar in statusbar hbox */
3411     if (prefs.filter_toolbar_show_in_statusbar) {
3412         gtk_box_pack_start(GTK_BOX(statusbar), filter_tb, FALSE, TRUE, 1);
3413     }
3414
3415     /* statusbar widgets */
3416     statusbar_widgets_pack(statusbar);
3417
3418     /* hide widgets on users recent settings */
3419     main_widgets_show_or_hide();
3420
3421     gtk_widget_show(main_vbox);
3422 }
3423
3424 static void
3425 is_widget_visible(GtkWidget *widget, gpointer data)
3426 {
3427     gboolean *is_visible = data;
3428
3429     if (!*is_visible) {
3430 #if GTK_CHECK_VERSION(2,18,0)
3431         if (gtk_widget_get_visible(widget))
3432 #else
3433         if (GTK_WIDGET_VISIBLE(widget))
3434 #endif
3435             *is_visible = TRUE;
3436     }
3437 }
3438
3439
3440 void
3441 main_widgets_show_or_hide(void)
3442 {
3443     gboolean main_second_pane_show;
3444
3445     if (recent.main_toolbar_show) {
3446         gtk_widget_show(main_tb);
3447     } else {
3448         gtk_widget_hide(main_tb);
3449     }
3450
3451     statusbar_widgets_show_or_hide(statusbar);
3452
3453     if (recent.filter_toolbar_show) {
3454         gtk_widget_show(filter_tb);
3455     } else {
3456         gtk_widget_hide(filter_tb);
3457     }
3458
3459 #ifdef HAVE_AIRPCAP
3460     if (recent.airpcap_toolbar_show) {
3461         gtk_widget_show(airpcap_tb);
3462     } else {
3463         gtk_widget_hide(airpcap_tb);
3464     }
3465 #endif
3466
3467     if (recent.packet_list_show && have_capture_file) {
3468         gtk_widget_show(pkt_scrollw);
3469     } else {
3470         gtk_widget_hide(pkt_scrollw);
3471     }
3472
3473     if (recent.tree_view_show && have_capture_file) {
3474         gtk_widget_show(tv_scrollw);
3475     } else {
3476         gtk_widget_hide(tv_scrollw);
3477     }
3478
3479     if (recent.byte_view_show && have_capture_file) {
3480         gtk_widget_show(byte_nb_ptr_gbl);
3481     } else {
3482         gtk_widget_hide(byte_nb_ptr_gbl);
3483     }
3484
3485     if (have_capture_file) {
3486         gtk_widget_show(main_first_pane);
3487     } else {
3488         gtk_widget_hide(main_first_pane);
3489     }
3490
3491     /*
3492      * Is anything in "main_second_pane" visible?
3493      * If so, show it, otherwise hide it.
3494      */
3495     main_second_pane_show = FALSE;
3496     gtk_container_foreach(GTK_CONTAINER(main_second_pane), is_widget_visible,
3497                           &main_second_pane_show);
3498     if (main_second_pane_show) {
3499         gtk_widget_show(main_second_pane);
3500     } else {
3501         gtk_widget_hide(main_second_pane);
3502     }
3503
3504     if (!have_capture_file) {
3505         if(welcome_pane) {
3506             gtk_widget_show(welcome_pane);
3507             select_ifaces();
3508         }
3509     } else {
3510         gtk_widget_hide(welcome_pane);
3511     }
3512 }
3513
3514
3515 /* called, when the window state changes (minimized, maximized, ...) */
3516 static gboolean
3517 window_state_event_cb (GtkWidget *widget _U_,
3518                        GdkEvent *event,
3519                        gpointer  data _U_)
3520 {
3521     GdkWindowState new_window_state = ((GdkEventWindowState*)event)->new_window_state;
3522
3523     if( (event->type) == (GDK_WINDOW_STATE)) {
3524         if(!(new_window_state & GDK_WINDOW_STATE_ICONIFIED)) {
3525             /* we might have dialogs popped up while we where iconified,
3526                show em now */
3527             display_queued_messages();
3528         }
3529     }
3530     return FALSE;
3531 }
3532
3533
3534
3535 #define NO_SHIFT_MOD_MASK (GDK_MODIFIER_MASK & ~(GDK_SHIFT_MASK|GDK_MOD2_MASK|GDK_LOCK_MASK))
3536 static gboolean
3537 top_level_key_pressed_cb(GtkWidget *w _U_, GdkEventKey *event, gpointer user_data _U_)
3538 {
3539     if (event->keyval == GDK_F8) {
3540         new_packet_list_next();
3541         return TRUE;
3542     } else if (event->keyval == GDK_F7) {
3543         new_packet_list_prev();
3544         return TRUE;
3545     } else if (event->state & NO_SHIFT_MOD_MASK) {
3546         return FALSE; /* Skip control, alt, and other modifiers */
3547     /*
3548      * A comment in gdkkeysyms.h says that it's autogenerated from
3549      * freedesktop.org/x.org's keysymdef.h.  Although the GDK docs
3550      * don't explicitly say so, isprint() should work as expected
3551      * for values < 127.
3552      */
3553     } else if (isascii(event->keyval) && isprint(event->keyval)) {
3554         /* Forward the keypress on to the display filter entry */
3555         if (main_display_filter_widget && !gtk_widget_is_focus(main_display_filter_widget)) {
3556             gtk_window_set_focus(GTK_WINDOW(top_level), main_display_filter_widget);
3557             gtk_editable_set_position(GTK_EDITABLE(main_display_filter_widget), -1);
3558         }
3559         return FALSE;
3560     }
3561     return FALSE;
3562 }
3563
3564 static void
3565 create_main_window (gint pl_size, gint tv_size, gint bv_size, e_prefs *prefs_p)
3566 {
3567     GtkAccelGroup *accel;
3568
3569     /* Main window */
3570     top_level = window_new(GTK_WINDOW_TOPLEVEL, "");
3571   &