gtk/capture_dlg.c

   1 /* capture_dlg.c
   2  * Routines for packet capture windows
   3  *
   4  * $Id$
   5  *
   6  * Ethereal - Network traffic analyzer
   7  * By Gerald Combs <gerald@ethereal.com>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 # include "config.h"
  27 #endif
  28
  29 #ifdef HAVE_LIBPCAP
  30
  31 #include <pcap.h>
  32 #include <string.h>
  33 #include <gtk/gtk.h>
  34
  35 #include <epan/packet.h>
  36 #include "capture.h"
  37 #include "globals.h"
  38 #include <epan/addr_resolv.h>
  39 #include "main.h"
  40 #include "ui_util.h"
  41 #include "capture.h"
  42 #include "capture_dlg.h"
  43 #include "filter_dlg.h"
  44 #include "simple_dialog.h"
  45 #include "dlg_utils.h"
  46 #include "pcap-util.h"
  47 #include "capture_ui_utils.h"
  48 #include <epan/prefs.h>
  49 #include "ringbuffer.h"
  50 #include <epan/filesystem.h>
  51 #include "compat_macros.h"
  52 #include "file_dlg.h"
  53 #include "help_dlg.h"
  54 #include "gtkglobals.h"
  55 #include "cfilter_combo_utils.h"
  56
  57 #ifdef _WIN32
  58 #include "capture-wpcap.h"
  59 #endif
  60
  61 /* Capture callback data keys */
  62 #define E_CAP_IFACE_KEY             "cap_iface"
  63 #define E_CAP_IFACE_IP_KEY          "cap_iface_ip"
  64 #define E_CAP_SNAP_CB_KEY           "cap_snap_cb"
  65 #define E_CAP_LT_OM_KEY             "cap_lt_om"
  66 #define E_CAP_LT_OM_LABEL_KEY       "cap_lt_om_label"
  67 #ifdef _WIN32
  68 #define E_CAP_BUFFER_SIZE_SB_KEY    "cap_buffer_size_sb"
  69 #endif
  70 #define E_CAP_SNAP_SB_KEY           "cap_snap_sb"
  71 #define E_CAP_PROMISC_KEY           "cap_promisc"
  72 #define E_CAP_FILT_KEY              "cap_filter_te"
  73 #define E_CAP_FILE_TE_KEY           "cap_file_te"
  74 #define E_CAP_MULTI_FILES_ON_CB_KEY "cap_multi_files_on_cb"
  75 #define E_CAP_RING_FILESIZE_CB_KEY  "cap_ring_filesize_cb"
  76 #define E_CAP_RING_FILESIZE_SB_KEY  "cap_ring_filesize_sb"
  77 #define E_CAP_RING_FILESIZE_OM_KEY  "cap_ring_filesize_om"
  78 #define E_CAP_FILE_DURATION_CB_KEY  "cap_file_duration_cb"
  79 #define E_CAP_FILE_DURATION_SB_KEY  "cap_file_duration_sb"
  80 #define E_CAP_FILE_DURATION_OM_KEY  "cap_file_duration_om"
  81 #define E_CAP_RING_NBF_CB_KEY       "cap_ring_nbf_cb"
  82 #define E_CAP_RING_NBF_SB_KEY       "cap_ring_nbf_sb"
  83 #define E_CAP_RING_NBF_LB_KEY       "cap_ring_nbf_lb"
  84 #define E_CAP_STOP_FILES_CB_KEY     "cap_stop_files_cb"
  85 #define E_CAP_STOP_FILES_SB_KEY     "cap_stop_files_sb"
  86 #define E_CAP_STOP_FILES_LB_KEY     "cap_stop_files_lb"
  87 #define E_CAP_SYNC_KEY              "cap_sync"
  88 #define E_CAP_AUTO_SCROLL_KEY       "cap_auto_scroll"
  89 #define E_CAP_HIDE_INFO_KEY         "cap_hide_info"
  90 #define E_CAP_STOP_PACKETS_CB_KEY   "cap_stop_packets_cb"
  91 #define E_CAP_STOP_PACKETS_SB_KEY   "cap_stop_packets_sb"
  92 #define E_CAP_STOP_PACKETS_LB_KEY   "cap_stop_packets_lb"
  93 #define E_CAP_STOP_FILESIZE_CB_KEY  "cap_stop_filesize_cb"
  94 #define E_CAP_STOP_FILESIZE_SB_KEY  "cap_stop_filesize_sb"
  95 #define E_CAP_STOP_FILESIZE_OM_KEY  "cap_stop_filesize_om"
  96 #define E_CAP_STOP_DURATION_CB_KEY  "cap_stop_duration_cb"
  97 #define E_CAP_STOP_DURATION_SB_KEY  "cap_stop_duration_sb"
  98 #define E_CAP_STOP_DURATION_OM_KEY  "cap_stop_duration_om"
  99 #define E_CAP_M_RESOLVE_KEY         "cap_m_resolve"
 100 #define E_CAP_N_RESOLVE_KEY         "cap_n_resolve"
 101 #define E_CAP_T_RESOLVE_KEY         "cap_t_resolve"
 102
 103 #define E_CAP_OM_LT_VALUE_KEY       "cap_om_lt_value"
 104
 105 static void
 106 capture_prep_file_cb(GtkWidget *file_bt, GtkWidget *file_te);
 107
 108 static void
 109 select_link_type_cb(GtkWidget *w, gpointer data);
 110
 111 static void
 112 capture_prep_adjust_sensitivity(GtkWidget *tb, gpointer parent_w);
 113
 114 static void
 115 capture_prep_ok_cb(GtkWidget *ok_bt, gpointer parent_w);
 116
 117 static void
 118 capture_prep_destroy_cb(GtkWidget *win, gpointer user_data);
 119
 120 static void
 121 capture_prep_interface_changed_cb(GtkWidget *entry, gpointer parent_w);
 122
 123 void
 124 capture_stop_cb(GtkWidget *w _U_, gpointer d _U_)
 125 {
 126     capture_stop(capture_opts);
 127 }
 128
 129 /*
 130  * Keep a static pointer to the current "Capture Options" window, if
 131  * any, so that if somebody tries to do "Capture:Start" while there's
 132  * already a "Capture Options" window up, we just pop up the existing
 133  * one, rather than creating a new one.
 134  */
 135 static GtkWidget *cap_open_w;
 136
 137 static void
 138 set_link_type_list(GtkWidget *linktype_om, GtkWidget *entry)
 139 {
 140   gchar *entry_text;
 141   gchar *if_text;
 142   gchar *if_name;
 143   GList *if_list;
 144   GList *if_entry;
 145   if_info_t *if_info;
 146   GList *lt_list;
 147   int err;
 148   char err_buf[PCAP_ERRBUF_SIZE];
 149   GtkWidget *lt_menu, *lt_menu_item;
 150   GList *lt_entry;
 151   data_link_info_t *data_link_info;
 152   gchar *linktype_menu_label;
 153   guint num_supported_link_types;
 154   GtkWidget *linktype_lb = OBJECT_GET_DATA(linktype_om, E_CAP_LT_OM_LABEL_KEY);
 155   GtkWidget *if_ip_lb;
 156   GString *ip_str = g_string_new("IP address: ");
 157   int ips = 0;
 158   GSList *curr_ip;
 159   if_addr_t *ip_addr;
 160
 161   lt_menu = gtk_menu_new();
 162   entry_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));
 163   if_text = g_strstrip(entry_text);
 164   if_name = get_if_name(if_text);
 165
 166   /*
 167    * If the interface name is in the list of known interfaces, get
 168    * its list of link-layer types and set the option menu to display it.
 169    *
 170    * If it's not, don't bother - the user might be in the middle of
 171    * editing the list, or it might be a remote device in which case
 172    * getting the list could take an arbitrarily-long period of time.
 173    * The list currently won't contain any remote devices (as
 174    * "pcap_findalldevs()" doesn't know about remote devices, and neither
 175    * does the code we use if "pcap_findalldevs()" isn't available), but
 176    * should contain all the local devices on which you can capture.
 177    */
 178   lt_list = NULL;
 179   if (*if_name != '\0') {
 180     /*
 181      * Try to get the list of known interfaces.
 182      */
 183     if_list = get_interface_list(&err, err_buf);
 184     if (if_list != NULL) {
 185       /*
 186        * We have the list - check it.
 187        */
 188       for (if_entry = if_list; if_entry != NULL;
 189            if_entry = g_list_next(if_entry)) {
 190         if_info = if_entry->data;
 191         if (strcmp(if_info->name, if_name) == 0) {
 192           /*
 193            * It's in the list.
 194            * Get the list of link-layer types for it.
 195            */
 196           lt_list = get_pcap_linktype_list(if_name, err_buf);
 197
 198           /* create string of list of IP addresses of this interface */
 199           for (; (curr_ip = g_slist_nth(if_info->ip_addr, ips)) != NULL; ips++) {
 200             if (ips != 0)
 201               g_string_append(ip_str, ", ");
 202
 203             ip_addr = (if_addr_t *)curr_ip->data;
 204             switch (ip_addr->type) {
 205
 206             case AT_IPv4:
 207               g_string_append(ip_str,
 208                 ip_to_str((guint8 *)&ip_addr->ip_addr.ip4_addr));
 209               break;
 210
 211             case AT_IPv6:
 212               g_string_append(ip_str,
 213                   ip6_to_str((struct e_in6_addr *)&ip_addr->ip_addr.ip6_addr));
 214               break;
 215
 216             default:
 217               g_assert_not_reached();
 218             }
 219           }
 220
 221           if (if_info->loopback)
 222             g_string_append(ip_str, " (loopback)");
 223         }
 224       }
 225       free_interface_list(if_list);
 226     }
 227   }
 228   g_free(entry_text);
 229   num_supported_link_types = 0;
 230   for (lt_entry = lt_list; lt_entry != NULL; lt_entry = g_list_next(lt_entry)) {
 231     data_link_info = lt_entry->data;
 232     if (data_link_info->description != NULL) {
 233       lt_menu_item = gtk_menu_item_new_with_label(data_link_info->description);
 234       OBJECT_SET_DATA(lt_menu_item, E_CAP_LT_OM_KEY, linktype_om);
 235       SIGNAL_CONNECT(lt_menu_item, "activate", select_link_type_cb,
 236                      GINT_TO_POINTER(data_link_info->dlt));
 237       num_supported_link_types++;
 238     } else {
 239       /* Not supported - tell them about it but don't let them select it. */
 240       linktype_menu_label = g_strdup_printf("%s (not supported)",
 241                                             data_link_info->name);
 242       lt_menu_item = gtk_menu_item_new_with_label(linktype_menu_label);
 243       g_free(linktype_menu_label);
 244       gtk_widget_set_sensitive(lt_menu_item, FALSE);
 245     }
 246     gtk_menu_append(GTK_MENU(lt_menu), lt_menu_item);
 247   }
 248   if (lt_list != NULL)
 249     free_pcap_linktype_list(lt_list);
 250   gtk_option_menu_set_menu(GTK_OPTION_MENU(linktype_om), lt_menu);
 251   gtk_widget_set_sensitive(linktype_lb, num_supported_link_types >= 2);
 252   gtk_widget_set_sensitive(linktype_om, num_supported_link_types >= 2);
 253
 254   if_ip_lb = OBJECT_GET_DATA(linktype_om, E_CAP_IFACE_KEY);
 255   if(ips == 0) {
 256     g_string_append(ip_str, "unknown");
 257   }
 258   gtk_label_set_text(GTK_LABEL(if_ip_lb), ip_str->str);
 259   g_string_free(ip_str, TRUE);
 260 }
 261
 262
 263 #define TIME_UNIT_SECOND    0
 264 #define TIME_UNIT_MINUTE    1
 265 #define TIME_UNIT_HOUR      2
 266 #define TIME_UNIT_DAY       3
 267 #define MAX_TIME_UNITS 4
 268 static char *time_unit_name[MAX_TIME_UNITS] = {
 269         "second(s)",
 270         "minute(s)",
 271         "hour(s)",
 272         "day(s)",
 273 };
 274
 275 static GtkWidget *time_unit_option_menu_new(guint32 value) {
 276     GtkWidget *unit_om, *menu, *menu_item;
 277     int i;
 278
 279         unit_om=gtk_option_menu_new();
 280         menu=gtk_menu_new();
 281         for(i=0;i<MAX_TIME_UNITS;i++){
 282                 menu_item=gtk_menu_item_new_with_label(time_unit_name[i]);
 283                 OBJECT_SET_DATA(menu_item, "time_unit", GINT_TO_POINTER(i));
 284                 gtk_menu_append(GTK_MENU(menu), menu_item);
 285         }
 286
 287     /* the selected menu item can't be changed, once the option_menu
 288        is created, so set the matching menu item now */
 289     /* days */
 290     if(value >= 60 * 60 * 24) {
 291             gtk_menu_set_active(GTK_MENU(menu), TIME_UNIT_DAY);
 292     } else {
 293         /* hours */
 294         if(value >= 60 * 60) {
 295                 gtk_menu_set_active(GTK_MENU(menu), TIME_UNIT_HOUR);
 296         } else {
 297             /* minutes */
 298             if(value >= 60) {
 299                     gtk_menu_set_active(GTK_MENU(menu), TIME_UNIT_MINUTE);
 300             } else {
 301                 /* seconds */
 302                     gtk_menu_set_active(GTK_MENU(menu), TIME_UNIT_SECOND);
 303             }
 304         }
 305     }
 306
 307         gtk_option_menu_set_menu(GTK_OPTION_MENU(unit_om), menu);
 308
 309     return unit_om;
 310 }
 311
 312 static guint32 time_unit_option_menu_convert_value(
 313 guint32 value)
 314 {
 315     /* days */
 316     if(value >= 60 * 60 * 24) {
 317         return value / (60 * 60 * 24);
 318     }
 319
 320     /* hours */
 321     if(value >= 60 * 60) {
 322         return value / (60 * 60);
 323     }
 324
 325     /* minutes */
 326     if(value >= 60) {
 327         return value / 60;
 328     }
 329
 330     /* seconds */
 331     return value;
 332 }
 333
 334 static guint32 time_unit_option_menu_get_value(
 335 GtkWidget *unit_om,
 336 guint32 value)
 337 {
 338         GtkWidget *menu, *menu_item;
 339     int unit;
 340
 341     menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(unit_om));
 342     menu_item = gtk_menu_get_active(GTK_MENU(menu));
 343     unit = GPOINTER_TO_INT(OBJECT_GET_DATA(menu_item, "time_unit"));
 344
 345
 346     switch(unit) {
 347     case(TIME_UNIT_SECOND):
 348         return value;
 349         break;
 350     case(TIME_UNIT_MINUTE):
 351         return value * 60;
 352         break;
 353     case(TIME_UNIT_HOUR):
 354         return value * 60 * 60;
 355         break;
 356     case(TIME_UNIT_DAY):
 357         return value * 60 * 60 * 24;
 358         break;
 359     default:
 360         g_assert_not_reached();
 361         return 0;
 362     }
 363 }
 364
 365
 366 #define SIZE_UNIT_BYTES     0
 367 #define SIZE_UNIT_KILOBYTES 1
 368 #define SIZE_UNIT_MEGABYTES 2
 369 #define SIZE_UNIT_GIGABYTES 3
 370 #define MAX_SIZE_UNITS 4
 371 static char *size_unit_name[MAX_SIZE_UNITS] = {
 372         "byte(s)",
 373         "kilobyte(s)",
 374         "megabyte(s)",
 375         "gigabyte(s)",
 376 };
 377
 378 static GtkWidget *size_unit_option_menu_new(guint32 value) {
 379     GtkWidget *unit_om, *menu, *menu_item;
 380     int i;
 381
 382         unit_om=gtk_option_menu_new();
 383         menu=gtk_menu_new();
 384         for(i=0;i<MAX_SIZE_UNITS;i++){
 385                 menu_item=gtk_menu_item_new_with_label(size_unit_name[i]);
 386                 OBJECT_SET_DATA(menu_item, "size_unit", GINT_TO_POINTER(i));
 387                 gtk_menu_append(GTK_MENU(menu), menu_item);
 388         }
 389
 390     /* the selected menu item can't be changed, once the option_menu
 391        is created, so set the matching menu item now */
 392     /* gigabytes */
 393     if(value >= 1024 * 1024 * 1024) {
 394             gtk_menu_set_active(GTK_MENU(menu), SIZE_UNIT_GIGABYTES);
 395     } else {
 396         /* megabytes */
 397         if(value >= 1024 * 1024) {
 398                 gtk_menu_set_active(GTK_MENU(menu), SIZE_UNIT_MEGABYTES);
 399         } else {
 400             /* kilobytes */
 401             if(value >= 1024) {
 402                     gtk_menu_set_active(GTK_MENU(menu), SIZE_UNIT_KILOBYTES);
 403             } else {
 404                 /* bytes */
 405                     gtk_menu_set_active(GTK_MENU(menu), SIZE_UNIT_BYTES);
 406             }
 407         }
 408     }
 409
 410         gtk_option_menu_set_menu(GTK_OPTION_MENU(unit_om), menu);
 411
 412     return unit_om;
 413 }
 414
 415 static guint32 size_unit_option_menu_set_value(
 416 guint32 value)
 417 {
 418     /* gigabytes */
 419     if(value >= 1024 * 1024 * 1024) {
 420         return value / (1024 * 1024 * 1024);
 421     }
 422
 423     /* megabytes */
 424     if(value >= 1024 * 1024) {
 425         return value / (1024 * 1024);
 426     }
 427
 428     /* kilobytes */
 429     if(value >= 1024) {
 430         return value / 1024;
 431     }
 432
 433     /* bytes */
 434     return value;
 435 }
 436
 437 static guint32 size_unit_option_menu_convert_value(
 438 GtkWidget *unit_om,
 439 guint32 value)
 440 {
 441         GtkWidget *menu, *menu_item;
 442     int unit;
 443
 444     menu = gtk_option_menu_get_menu(GTK_OPTION_MENU(unit_om));
 445     menu_item = gtk_menu_get_active(GTK_MENU(menu));
 446     unit = GPOINTER_TO_INT(OBJECT_GET_DATA(menu_item, "size_unit"));
 447
 448
 449     switch(unit) {
 450     case(SIZE_UNIT_BYTES):
 451         return value;
 452         break;
 453     case(SIZE_UNIT_KILOBYTES):
 454         if(value > G_MAXINT / 1024) {
 455             return 0;
 456         } else {
 457             return value * 1024;
 458         }
 459         break;
 460     case(SIZE_UNIT_MEGABYTES):
 461         if(value > G_MAXINT / (1024 * 1024)) {
 462             return 0;
 463         } else {
 464             return value * 1024 * 1024;
 465         }
 466         break;
 467     case(SIZE_UNIT_GIGABYTES):
 468         if(value > G_MAXINT / (1024 * 1024 * 1024)) {
 469             return 0;
 470         } else {
 471             return value * 1024 * 1024 * 1024;
 472         }
 473         break;
 474     default:
 475         g_assert_not_reached();
 476         return 0;
 477     }
 478 }
 479
 480
 481 void
 482 capture_prep(void)
 483 {
 484   GtkWidget     *main_vb,
 485                 *main_hb, *left_vb, *right_vb,
 486
 487                 *capture_fr, *capture_vb,
 488                 *if_hb, *if_cb, *if_lb,
 489                 *if_ip_hb, *if_ip_lb,
 490                 *linktype_hb, *linktype_lb, *linktype_om,
 491                 *snap_hb, *snap_cb, *snap_sb, *snap_lb,
 492                 *promisc_cb,
 493                 *filter_hb, *filter_bt, *filter_te, *filter_cm,
 494
 495                 *file_fr, *file_vb,
 496                 *file_hb, *file_bt, *file_lb, *file_te,
 497                 *multi_tb, *multi_files_on_cb,
 498                 *ring_filesize_cb, *ring_filesize_sb, *ring_filesize_om,
 499                 *file_duration_cb, *file_duration_sb, *file_duration_om,
 500                 *ringbuffer_nbf_cb, *ringbuffer_nbf_sb, *ringbuffer_nbf_lb,
 501                 *stop_files_cb, *stop_files_sb, *stop_files_lb,
 502
 503                 *limit_fr, *limit_vb, *limit_tb,
 504                 *stop_packets_cb, *stop_packets_sb, *stop_packets_lb,
 505                 *stop_filesize_cb, *stop_filesize_sb, *stop_filesize_om,
 506                 *stop_duration_cb, *stop_duration_sb, *stop_duration_om,
 507
 508                 *display_fr, *display_vb,
 509                 *sync_cb, *auto_scroll_cb, *hide_info_cb,
 510
 511                 *resolv_fr, *resolv_vb,
 512                 *m_resolv_cb, *n_resolv_cb, *t_resolv_cb,
 513                 *bbox, *ok_bt, *cancel_bt,
 514                 *help_bt;
 515 #if GTK_MAJOR_VERSION < 2
 516   GtkAccelGroup *accel_group;
 517 #endif
 518   GtkTooltips   *tooltips;
 519   GtkAdjustment *snap_adj, *ringbuffer_nbf_adj,
 520                 *stop_packets_adj, *stop_filesize_adj, *stop_duration_adj, *stop_files_adj, *ring_filesize_adj, *file_duration_adj;
 521   GList         *if_list, *combo_list, *filter_list;
 522   int           err;
 523   int           row;
 524   char          err_str[PCAP_ERRBUF_SIZE];
 525   gchar         *cant_get_if_list_errstr;
 526 #ifdef _WIN32
 527   GtkAdjustment *buffer_size_adj;
 528   GtkWidget     *buffer_size_lb, *buffer_size_sb;
 529 #endif
 530   guint32       value;
 531   gchar         *cap_title;
 532
 533   if (cap_open_w != NULL) {
 534     /* There's already a "Capture Options" dialog box; reactivate it. */
 535     reactivate_window(cap_open_w);
 536     return;
 537   }
 538
 539 #ifdef _WIN32
 540   /* Is WPcap loaded? */
 541   if (!has_wpcap) {
 542           simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
 543                   "Unable to load WinPcap (wpcap.dll); Ethereal will not be able\n"
 544                   "to capture packets.\n\n"
 545                   "In order to capture packets, WinPcap must be installed; see\n"
 546                   "\n"
 547                   "        http://winpcap.polito.it/\n"
 548                   "\n"
 549                   "or the mirror at\n"
 550                   "\n"
 551                   "        http://winpcap.mirror.ethereal.com/\n"
 552                   "\n"
 553                   "or the mirror at\n"
 554                   "\n"
 555                   "        http://www.mirrors.wiretapped.net/security/packet-capture/winpcap/\n"
 556                   "\n"
 557                   "for a downloadable version of WinPcap and for instructions\n"
 558                   "on how to install WinPcap.");
 559           return;
 560   }
 561 #endif
 562
 563   if_list = get_interface_list(&err, err_str);
 564   if (if_list == NULL && err == CANT_GET_INTERFACE_LIST) {
 565     cant_get_if_list_errstr = cant_get_if_list_error_message(err_str);
 566     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s",
 567                   cant_get_if_list_errstr);
 568     g_free(cant_get_if_list_errstr);
 569   }
 570
 571   /* use user-defined title if preference is set */
 572   cap_title = create_user_window_title("Ethereal: Capture Options");
 573
 574   cap_open_w = dlg_window_new(cap_title);
 575   g_free(cap_title);
 576
 577   tooltips = gtk_tooltips_new();
 578
 579 #if GTK_MAJOR_VERSION < 2
 580   /* Accelerator group for the accelerators (or, as they're called in
 581      Windows and, I think, in Motif, "mnemonics"; Alt+<key> is a mnemonic,
 582      Ctrl+<key> is an accelerator). */
 583   accel_group = gtk_accel_group_new();
 584   gtk_window_add_accel_group(GTK_WINDOW(cap_open_w), accel_group);
 585 #endif
 586
 587   main_vb = gtk_vbox_new(FALSE, 0);
 588   gtk_container_border_width(GTK_CONTAINER(main_vb), 5);
 589   gtk_container_add(GTK_CONTAINER(cap_open_w), main_vb);
 590
 591   /* Capture-related options frame */
 592   capture_fr = gtk_frame_new("Capture");
 593   gtk_container_add(GTK_CONTAINER(main_vb), capture_fr);
 594
 595   capture_vb = gtk_vbox_new(FALSE, 3);
 596   gtk_container_border_width(GTK_CONTAINER(capture_vb), 5);
 597   gtk_container_add(GTK_CONTAINER(capture_fr), capture_vb);
 598
 599   /* Interface row */
 600   if_hb = gtk_hbox_new(FALSE, 3);
 601   gtk_container_add(GTK_CONTAINER(capture_vb), if_hb);
 602
 603   if_lb = gtk_label_new("Interface:");
 604   gtk_box_pack_start(GTK_BOX(if_hb), if_lb, FALSE, FALSE, 6);
 605
 606   if_cb = gtk_combo_new();
 607   combo_list = build_capture_combo_list(if_list, TRUE);
 608   if (combo_list != NULL)
 609     gtk_combo_set_popdown_strings(GTK_COMBO(if_cb), combo_list);
 610   if (capture_opts->iface == NULL && prefs.capture_device != NULL) {
 611     /* No interface was specified on the command line or in a previous
 612        capture, but there is one specified in the preferences file;
 613        make the one from the preferences file the default */
 614     capture_opts->iface = g_strdup(prefs.capture_device);
 615   }
 616   if (capture_opts->iface != NULL)
 617     gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(if_cb)->entry), capture_opts->iface);
 618   else if (combo_list != NULL) {
 619     gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(if_cb)->entry),
 620                        (char *)combo_list->data);
 621   }
 622   free_capture_combo_list(combo_list);
 623   free_interface_list(if_list);
 624   gtk_tooltips_set_tip(tooltips, GTK_COMBO(if_cb)->entry,
 625     "Choose which interface (network card) will be used to capture packets from. "
 626     "Be sure to select the correct one, as it's a common mistake to select the wrong interface.", NULL);
 627   gtk_box_pack_start(GTK_BOX(if_hb), if_cb, TRUE, TRUE, 6);
 628
 629   if_ip_hb = gtk_hbox_new(FALSE, 3);
 630   gtk_box_pack_start(GTK_BOX(capture_vb), if_ip_hb, FALSE, FALSE, 0);
 631
 632   if_ip_lb = gtk_label_new("");
 633   gtk_box_pack_start(GTK_BOX(if_ip_hb), if_ip_lb, FALSE, FALSE, 6);
 634
 635   /* Linktype row */
 636   linktype_hb = gtk_hbox_new(FALSE, 3);
 637   gtk_box_pack_start(GTK_BOX(capture_vb), linktype_hb, FALSE, FALSE, 0);
 638
 639   linktype_lb = gtk_label_new("Link-layer header type:");
 640   gtk_box_pack_start(GTK_BOX(linktype_hb), linktype_lb, FALSE, FALSE, 6);
 641
 642   linktype_om = gtk_option_menu_new();
 643   OBJECT_SET_DATA(linktype_om, E_CAP_LT_OM_LABEL_KEY, linktype_lb);
 644   /* Default to "use the default" */
 645   OBJECT_SET_DATA(linktype_om, E_CAP_OM_LT_VALUE_KEY, GINT_TO_POINTER(-1));
 646   OBJECT_SET_DATA(linktype_om, E_CAP_IFACE_KEY, if_ip_lb);
 647   set_link_type_list(linktype_om, GTK_COMBO(if_cb)->entry);
 648   /*
 649    * XXX - in some cases, this is "multiple link-layer header types", e.g.
 650    * some 802.11 interfaces on FreeBSD 5.2 and later, where you can request
 651    * fake Ethernet, 802.11, or 802.11-plus-radio-information headers.
 652    *
 653    * In other cases, it's "multiple link-layer types", e.g., with recent
 654    * versions of libpcap, a DAG card on an "HDLC" WAN, where you can
 655    * request Cisco HDLC or PPP depending on what type of traffic is going
 656    * over the WAN, or an Ethernet interface, where you can request Ethernet
 657    * or DOCSIS, the latter being for some Cisco cable modem equipment that
 658    * can be configured to send raw DOCSIS frames over an Ethernet inside
 659    * Ethernet low-level framing, for traffic capture purposes.
 660    *
 661    * We leave it as "multiple link-layer types" for now.
 662    */
 663   gtk_tooltips_set_tip(tooltips, linktype_om,
 664     "The selected interface supports multiple link-layer types; select the desired one.", NULL);
 665   gtk_box_pack_start (GTK_BOX(linktype_hb), linktype_om, FALSE, FALSE, 0);
 666   SIGNAL_CONNECT(GTK_ENTRY(GTK_COMBO(if_cb)->entry), "changed",
 667                  capture_prep_interface_changed_cb, linktype_om);
 668
 669 #ifdef _WIN32
 670   buffer_size_lb = gtk_label_new("Buffer size:");
 671   gtk_box_pack_start (GTK_BOX(linktype_hb), buffer_size_lb, FALSE, FALSE, 0);
 672
 673   buffer_size_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) capture_opts->buffer_size,
 674     1, 65535, 1.0, 10.0, 0.0);
 675   buffer_size_sb = gtk_spin_button_new (buffer_size_adj, 0, 0);
 676   gtk_spin_button_set_value(GTK_SPIN_BUTTON (buffer_size_sb), (gfloat) capture_opts->buffer_size);
 677   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (buffer_size_sb), TRUE);
 678   WIDGET_SET_SIZE(buffer_size_sb, 80, -1);
 679   gtk_tooltips_set_tip(tooltips, buffer_size_sb,
 680     "The memory buffer size used while capturing. If you notice packet drops, you can try to increase this size.", NULL);
 681   gtk_box_pack_start (GTK_BOX(linktype_hb), buffer_size_sb, FALSE, FALSE, 0);
 682
 683   buffer_size_lb = gtk_label_new("megabyte(s)");
 684   gtk_box_pack_start (GTK_BOX(linktype_hb), buffer_size_lb, FALSE, FALSE, 0);
 685 #endif
 686
 687   /* Promiscuous mode row */
 688   promisc_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
 689       "Capture packets in _promiscuous mode", accel_group);
 690   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(promisc_cb),
 691                 capture_opts->promisc_mode);
 692   gtk_tooltips_set_tip(tooltips, promisc_cb,
 693     "Usually a network card will only capture the traffic sent to its own network address. "
 694     "If you want to capture all traffic that the network card can \"see\", mark this option. "
 695     "See the FAQ for some more details of capturing packets from a switched network.", NULL);
 696   gtk_container_add(GTK_CONTAINER(capture_vb), promisc_cb);
 697
 698   /* Capture length row */
 699   snap_hb = gtk_hbox_new(FALSE, 3);
 700   gtk_container_add(GTK_CONTAINER(capture_vb), snap_hb);
 701
 702   snap_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC("_Limit each packet to", accel_group);
 703   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(snap_cb),
 704                 capture_opts->has_snaplen);
 705   SIGNAL_CONNECT(snap_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
 706   gtk_tooltips_set_tip(tooltips, snap_cb,
 707     "Limit the maximum number of bytes to be captured from each packet. This size includes the "
 708     "link-layer header and all subsequent headers. ", NULL);
 709   gtk_box_pack_start(GTK_BOX(snap_hb), snap_cb, FALSE, FALSE, 0);
 710
 711   snap_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) capture_opts->snaplen,
 712     MIN_PACKET_SIZE, WTAP_MAX_PACKET_SIZE, 1.0, 10.0, 0.0);
 713   snap_sb = gtk_spin_button_new (snap_adj, 0, 0);
 714   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (snap_sb), TRUE);
 715   WIDGET_SET_SIZE(snap_sb, 80, -1);
 716   gtk_box_pack_start (GTK_BOX(snap_hb), snap_sb, FALSE, FALSE, 0);
 717
 718   snap_lb = gtk_label_new("bytes");
 719   gtk_misc_set_alignment(GTK_MISC(snap_lb), 0, 0.5);
 720   gtk_box_pack_start(GTK_BOX(snap_hb), snap_lb, FALSE, FALSE, 0);
 721
 722   /* Filter row */
 723   filter_hb = gtk_hbox_new(FALSE, 3);
 724   gtk_box_pack_start(GTK_BOX(capture_vb), filter_hb, FALSE, FALSE, 0);
 725
 726   filter_bt = BUTTON_NEW_FROM_STOCK(ETHEREAL_STOCK_CAPTURE_FILTER_ENTRY);
 727   SIGNAL_CONNECT(filter_bt, "clicked", capture_filter_construct_cb, NULL);
 728   SIGNAL_CONNECT(filter_bt, "destroy", filter_button_destroy_cb, NULL);
 729   gtk_tooltips_set_tip(tooltips, filter_bt,
 730     "Select a capture filter to reduce the amount of packets to be captured. "
 731     "See \"Capture Filters\" in the online help for further information how to use it.",
 732     NULL);
 733   gtk_box_pack_start(GTK_BOX(filter_hb), filter_bt, FALSE, FALSE, 3);
 734
 735   /* Create the capture filter combo */
 736   filter_cm = gtk_combo_new();
 737
 738   filter_list = OBJECT_GET_DATA(top_level, E_CFILTER_FL_KEY);
 739   gtk_combo_disable_activate(GTK_COMBO(filter_cm));
 740   gtk_combo_set_case_sensitive(GTK_COMBO(filter_cm), TRUE);
 741   OBJECT_SET_DATA(top_level, E_CFILTER_FL_KEY, filter_list);
 742   OBJECT_SET_DATA(top_level, E_CFILTER_CM_KEY, filter_cm);
 743   filter_te = GTK_COMBO(filter_cm)->entry;
 744
 745   if (filter_list != NULL)
 746     gtk_combo_set_popdown_strings(GTK_COMBO(filter_cm), filter_list);
 747   if (capture_opts->cfilter)
 748     gtk_entry_set_text(GTK_ENTRY(filter_te), capture_opts->cfilter);
 749   gtk_tooltips_set_tip(tooltips, filter_te,
 750     "Enter a capture filter to reduce the amount of packets to be captured. "
 751     "See \"Capture Filters\" in the online help for further information how to use it.",
 752     NULL);
 753   WIDGET_SET_SIZE(filter_cm, 400, -1);
 754   gtk_box_pack_start(GTK_BOX(filter_hb), filter_cm, FALSE, FALSE, 3);
 755   main_hb = gtk_hbox_new(FALSE, 5);
 756   gtk_container_border_width(GTK_CONTAINER(main_hb), 0);
 757   gtk_container_add(GTK_CONTAINER(main_vb), main_hb);
 758
 759   left_vb = gtk_vbox_new(FALSE, 0);
 760   gtk_container_border_width(GTK_CONTAINER(left_vb), 0);
 761   gtk_box_pack_start(GTK_BOX(main_hb), left_vb, TRUE, TRUE, 0);
 762
 763   right_vb = gtk_vbox_new(FALSE, 0);
 764   gtk_container_border_width(GTK_CONTAINER(right_vb), 0);
 765   gtk_box_pack_start(GTK_BOX(main_hb), right_vb, FALSE, FALSE, 0);
 766
 767   /* let an eventually capture filters dialog know the text entry to fill in */
 768   OBJECT_SET_DATA(filter_bt, E_FILT_TE_PTR_KEY, filter_te);
 769
 770   /* Capture file-related options frame */
 771   file_fr = gtk_frame_new("Capture File(s)");
 772   gtk_container_add(GTK_CONTAINER(left_vb), file_fr);
 773
 774   file_vb = gtk_vbox_new(FALSE, 3);
 775   gtk_container_border_width(GTK_CONTAINER(file_vb), 5);
 776   gtk_container_add(GTK_CONTAINER(file_fr), file_vb);
 777
 778   /* File row */
 779   file_hb = gtk_hbox_new(FALSE, 3);
 780   gtk_box_pack_start(GTK_BOX(file_vb), file_hb, FALSE, FALSE, 0);
 781
 782   file_lb = gtk_label_new("File:");
 783   gtk_box_pack_start(GTK_BOX(file_hb), file_lb, FALSE, FALSE, 3);
 784
 785   file_te = gtk_entry_new();
 786   gtk_tooltips_set_tip(tooltips, file_te,
 787     "Enter the file name to which captured data will be written. "
 788     "If you don't enter something here, a temporary file will be used.",
 789     NULL);
 790   gtk_box_pack_start(GTK_BOX(file_hb), file_te, TRUE, TRUE, 3);
 791
 792   file_bt = BUTTON_NEW_FROM_STOCK(ETHEREAL_STOCK_BROWSE);
 793   gtk_tooltips_set_tip(tooltips, file_bt,
 794     "Select a file to which captured data will be written, "
 795     "instead of entering the file name directly. ",
 796     NULL);
 797   gtk_box_pack_start(GTK_BOX(file_hb), file_bt, FALSE, FALSE, 3);
 798
 799   SIGNAL_CONNECT(file_bt, "clicked", capture_prep_file_cb, file_te);
 800
 801   /* multiple files table */
 802   multi_tb = gtk_table_new(5, 3, FALSE);
 803   gtk_table_set_row_spacings(GTK_TABLE(multi_tb), 1);
 804   gtk_table_set_col_spacings(GTK_TABLE(multi_tb), 3);
 805   gtk_box_pack_start(GTK_BOX(file_vb), multi_tb, FALSE, FALSE, 0);
 806   row = 0;
 807
 808   /* multiple files row */
 809   multi_files_on_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC("Use _multiple files", accel_group);
 810   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(multi_files_on_cb),
 811                 capture_opts->multi_files_on);
 812   SIGNAL_CONNECT(multi_files_on_cb, "toggled", capture_prep_adjust_sensitivity,
 813                  cap_open_w);
 814   gtk_tooltips_set_tip(tooltips, multi_files_on_cb,
 815     "Instead of using a single capture file, multiple files will be created. "
 816     "The generated file names will contain an incrementing number and the start time of the capture.", NULL);
 817   gtk_table_attach_defaults(GTK_TABLE(multi_tb), multi_files_on_cb, 0, 1, row, row+1);
 818   row++;
 819
 820   /* Ring buffer filesize row */
 821   ring_filesize_cb = gtk_check_button_new_with_label("Next file every");
 822   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(ring_filesize_cb),
 823                 capture_opts->has_autostop_filesize);
 824   SIGNAL_CONNECT(ring_filesize_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
 825   gtk_tooltips_set_tip(tooltips, ring_filesize_cb,
 826     "If the selected file size is exceeded, capturing switches to the next file.\n"
 827     "PLEASE NOTE: at least one of the \"Next file every\" options MUST be selected.",
 828     NULL);
 829   gtk_table_attach_defaults(GTK_TABLE(multi_tb), ring_filesize_cb, 0, 1, row, row+1);
 830
 831   ring_filesize_adj = (GtkAdjustment *) gtk_adjustment_new(0.0,
 832     1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
 833   ring_filesize_sb = gtk_spin_button_new (ring_filesize_adj, 0, 0);
 834   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (ring_filesize_sb), TRUE);
 835   WIDGET_SET_SIZE(ring_filesize_sb, 80, -1);
 836   gtk_table_attach_defaults(GTK_TABLE(multi_tb), ring_filesize_sb, 1, 2, row, row+1);
 837
 838   ring_filesize_om = size_unit_option_menu_new(capture_opts->autostop_filesize);
 839   gtk_table_attach_defaults(GTK_TABLE(multi_tb), ring_filesize_om, 2, 3, row, row+1);
 840
 841   value = size_unit_option_menu_set_value(capture_opts->autostop_filesize);
 842   gtk_adjustment_set_value(ring_filesize_adj, (gfloat) value);
 843
 844   row++;
 845
 846   /* Ring buffer duration row */
 847   file_duration_cb = gtk_check_button_new_with_label("Next file every");
 848   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(file_duration_cb),
 849                               capture_opts->has_file_duration);
 850   SIGNAL_CONNECT(file_duration_cb, "toggled",
 851                  capture_prep_adjust_sensitivity, cap_open_w);
 852   gtk_tooltips_set_tip(tooltips, file_duration_cb,
 853     "If the selected duration is exceeded, capturing switches to the next file.\n"
 854     "PLEASE NOTE: at least one of the \"Next file every\" options MUST be selected.",
 855     NULL);
 856   gtk_table_attach_defaults(GTK_TABLE(multi_tb), file_duration_cb, 0, 1, row, row+1);
 857
 858   file_duration_adj = (GtkAdjustment *)gtk_adjustment_new(0.0,
 859     1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
 860   file_duration_sb = gtk_spin_button_new (file_duration_adj, 0, 0);
 861   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (file_duration_sb), TRUE);
 862   WIDGET_SET_SIZE(file_duration_sb, 80, -1);
 863   gtk_table_attach_defaults(GTK_TABLE(multi_tb), file_duration_sb, 1, 2, row, row+1);
 864
 865   file_duration_om = time_unit_option_menu_new(capture_opts->file_duration);
 866   gtk_table_attach_defaults(GTK_TABLE(multi_tb), file_duration_om, 2, 3, row, row+1);
 867
 868   value = time_unit_option_menu_convert_value(capture_opts->file_duration);
 869   gtk_adjustment_set_value(file_duration_adj, (gfloat) value);
 870   row++;
 871
 872   /* Ring buffer files row */
 873   ringbuffer_nbf_cb = gtk_check_button_new_with_label("Ring buffer with");
 874   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(ringbuffer_nbf_cb),
 875                 capture_opts->has_ring_num_files);
 876   SIGNAL_CONNECT(ringbuffer_nbf_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
 877   gtk_tooltips_set_tip(tooltips, ringbuffer_nbf_cb,
 878     "After capturing has switched to the next file and the given number of files has exceeded, "
 879     "the oldest file will be removed.",
 880     NULL);
 881   gtk_table_attach_defaults(GTK_TABLE(multi_tb), ringbuffer_nbf_cb, 0, 1, row, row+1);
 882
 883   ringbuffer_nbf_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) capture_opts->ring_num_files,
 884     2/*RINGBUFFER_MIN_NUM_FILES*/, RINGBUFFER_MAX_NUM_FILES, 1.0, 10.0, 0.0);
 885   ringbuffer_nbf_sb = gtk_spin_button_new (ringbuffer_nbf_adj, 0, 0);
 886   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (ringbuffer_nbf_sb), TRUE);
 887   WIDGET_SET_SIZE(ringbuffer_nbf_sb, 80, -1);
 888   SIGNAL_CONNECT(ringbuffer_nbf_sb, "changed", capture_prep_adjust_sensitivity, cap_open_w);
 889   gtk_table_attach_defaults(GTK_TABLE(multi_tb), ringbuffer_nbf_sb, 1, 2, row, row+1);
 890
 891   ringbuffer_nbf_lb = gtk_label_new("files");
 892   gtk_misc_set_alignment(GTK_MISC(ringbuffer_nbf_lb), 0, 0.5);
 893   gtk_table_attach_defaults(GTK_TABLE(multi_tb), ringbuffer_nbf_lb, 2, 3, row, row+1);
 894   row++;
 895
 896   /* Files row */
 897   stop_files_cb = gtk_check_button_new_with_label("Stop capture after");
 898   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(stop_files_cb),
 899                 capture_opts->has_autostop_files);
 900   SIGNAL_CONNECT(stop_files_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
 901   gtk_tooltips_set_tip(tooltips, stop_files_cb,
 902     "Stop capturing after the given number of \"file switches\" have been done.", NULL);
 903   gtk_table_attach_defaults(GTK_TABLE(multi_tb), stop_files_cb, 0, 1, row, row+1);
 904
 905   stop_files_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat)capture_opts->autostop_files,
 906     1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
 907   stop_files_sb = gtk_spin_button_new (stop_files_adj, 0, 0);
 908   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_files_sb), TRUE);
 909   WIDGET_SET_SIZE(stop_files_sb, 80, -1);
 910   gtk_table_attach_defaults(GTK_TABLE(multi_tb), stop_files_sb, 1, 2, row, row+1);
 911
 912   stop_files_lb = gtk_label_new("file(s)");
 913   gtk_misc_set_alignment(GTK_MISC(stop_files_lb), 0, 0.5);
 914   gtk_table_attach_defaults(GTK_TABLE(multi_tb), stop_files_lb, 2, 3, row, row+1);
 915   row++;
 916
 917   /* Capture limits frame */
 918   limit_fr = gtk_frame_new("Stop Capture ...");
 919   gtk_container_add(GTK_CONTAINER(left_vb), limit_fr);
 920
 921   limit_vb = gtk_vbox_new(FALSE, 3);
 922   gtk_container_border_width(GTK_CONTAINER(limit_vb), 5);
 923   gtk_container_add(GTK_CONTAINER(limit_fr), limit_vb);
 924
 925   /* limits table */
 926   limit_tb = gtk_table_new(3, 3, FALSE);
 927   gtk_table_set_row_spacings(GTK_TABLE(limit_tb), 1);
 928   gtk_table_set_col_spacings(GTK_TABLE(limit_tb), 3);
 929   gtk_box_pack_start(GTK_BOX(limit_vb), limit_tb, FALSE, FALSE, 0);
 930   row = 0;
 931
 932   /* Packet count row */
 933   stop_packets_cb = gtk_check_button_new_with_label("... after");
 934   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(stop_packets_cb),
 935                 capture_opts->has_autostop_packets);
 936   SIGNAL_CONNECT(stop_packets_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
 937   gtk_tooltips_set_tip(tooltips, stop_packets_cb,
 938     "Stop capturing after the given number of packets have been captured.", NULL);
 939   gtk_table_attach_defaults(GTK_TABLE(limit_tb), stop_packets_cb, 0, 1, row, row+1);
 940
 941   stop_packets_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat)capture_opts->autostop_packets,
 942     1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
 943   stop_packets_sb = gtk_spin_button_new (stop_packets_adj, 0, 0);
 944   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_packets_sb), TRUE);
 945   WIDGET_SET_SIZE(stop_packets_sb, 80, -1);
 946   gtk_table_attach_defaults(GTK_TABLE(limit_tb), stop_packets_sb, 1, 2, row, row+1);
 947
 948   stop_packets_lb = gtk_label_new("packet(s)");
 949   gtk_misc_set_alignment(GTK_MISC(stop_packets_lb), 0, 0.5);
 950   gtk_table_attach_defaults(GTK_TABLE(limit_tb), stop_packets_lb, 2, 3, row, row+1);
 951   row++;
 952
 953   /* Filesize row */
 954   stop_filesize_cb = gtk_check_button_new_with_label("... after");
 955   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(stop_filesize_cb),
 956                 capture_opts->has_autostop_filesize);
 957   SIGNAL_CONNECT(stop_filesize_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
 958   gtk_tooltips_set_tip(tooltips, stop_filesize_cb,
 959     "Stop capturing after the given amount of capture data has been captured.", NULL);
 960   gtk_table_attach_defaults(GTK_TABLE(limit_tb), stop_filesize_cb, 0, 1, row, row+1);
 961
 962   stop_filesize_adj = (GtkAdjustment *) gtk_adjustment_new(0.0,
 963     1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
 964   stop_filesize_sb = gtk_spin_button_new (stop_filesize_adj, 0, 0);
 965   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_filesize_sb), TRUE);
 966   WIDGET_SET_SIZE(stop_filesize_sb, 80, -1);
 967   gtk_table_attach_defaults(GTK_TABLE(limit_tb), stop_filesize_sb, 1, 2, row, row+1);
 968
 969   stop_filesize_om = size_unit_option_menu_new(capture_opts->autostop_filesize);
 970   gtk_table_attach_defaults(GTK_TABLE(limit_tb), stop_filesize_om, 2, 3, row, row+1);
 971
 972   value = size_unit_option_menu_set_value(capture_opts->autostop_filesize);
 973   gtk_adjustment_set_value(stop_filesize_adj, (gfloat) value);
 974
 975   row++;
 976
 977   /* Duration row */
 978   stop_duration_cb = gtk_check_button_new_with_label("... after");
 979   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(stop_duration_cb),
 980                 capture_opts->has_autostop_duration);
 981   SIGNAL_CONNECT(stop_duration_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
 982   gtk_tooltips_set_tip(tooltips, stop_duration_cb,
 983     "Stop capturing after the given time is exceeded.", NULL);
 984   gtk_table_attach_defaults(GTK_TABLE(limit_tb), stop_duration_cb, 0, 1, row, row+1);
 985
 986   stop_duration_adj = (GtkAdjustment *) gtk_adjustment_new(0.0,
 987     1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
 988   stop_duration_sb = gtk_spin_button_new (stop_duration_adj, 0, 0);
 989   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_duration_sb), TRUE);
 990   WIDGET_SET_SIZE(stop_duration_sb, 80, -1);
 991   gtk_table_attach_defaults(GTK_TABLE(limit_tb), stop_duration_sb, 1, 2, row, row+1);
 992
 993   stop_duration_om = time_unit_option_menu_new(capture_opts->autostop_duration);
 994   gtk_table_attach_defaults(GTK_TABLE(limit_tb), stop_duration_om, 2, 3, row, row+1);
 995
 996   value = time_unit_option_menu_convert_value(capture_opts->autostop_duration);
 997   gtk_adjustment_set_value(stop_duration_adj, (gfloat) value);
 998   row++;
 999
1000   /* Display-related options frame */
1001   display_fr = gtk_frame_new("Display Options");
1002   gtk_container_add(GTK_CONTAINER(right_vb), display_fr);
1003
1004   display_vb = gtk_vbox_new(FALSE, 0);
1005   gtk_container_border_width(GTK_CONTAINER(display_vb), 5);
1006   gtk_container_add(GTK_CONTAINER(display_fr), display_vb);
1007
1008   /* "Update display in real time" row */
1009   sync_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
1010       "_Update list of packets in real time", accel_group);
1011   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sync_cb),
1012                 capture_opts->sync_mode);
1013   SIGNAL_CONNECT(sync_cb, "toggled", capture_prep_adjust_sensitivity, cap_open_w);
1014   gtk_tooltips_set_tip(tooltips, sync_cb,
1015     "Using this option will show the captured packets immediately on the main screen. "
1016     "Please note: this will slow down capturing, so increased packet drops might appear.", NULL);
1017   gtk_container_add(GTK_CONTAINER(display_vb), sync_cb);
1018
1019   /* "Auto-scroll live update" row */
1020   auto_scroll_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
1021                 "_Automatic scrolling in live capture", accel_group);
1022   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(auto_scroll_cb), auto_scroll_live);
1023   gtk_tooltips_set_tip(tooltips, auto_scroll_cb,
1024     "This will scroll the \"Packet List\" automatically to the latest captured packet, "
1025     "when the \"Update List of packets in real time\" option is used.", NULL);
1026   gtk_container_add(GTK_CONTAINER(display_vb), auto_scroll_cb);
1027
1028   /* "Hide capture info" row */
1029   hide_info_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
1030                 "_Hide capture info dialog", accel_group);
1031   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(hide_info_cb), !capture_opts->show_info);
1032   gtk_tooltips_set_tip(tooltips, hide_info_cb,
1033     "Hide the capture info dialog while capturing.", NULL);
1034   gtk_container_add(GTK_CONTAINER(display_vb), hide_info_cb);
1035
1036   /* Name Resolution frame */
1037   resolv_fr = gtk_frame_new("Name Resolution");
1038   gtk_container_add(GTK_CONTAINER(right_vb), resolv_fr);
1039
1040   resolv_vb = gtk_vbox_new(FALSE, 0);
1041   gtk_container_border_width(GTK_CONTAINER(resolv_vb), 5);
1042   gtk_container_add(GTK_CONTAINER(resolv_fr), resolv_vb);
1043
1044   m_resolv_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
1045                 "Enable _MAC name resolution", accel_group);
1046   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(m_resolv_cb),
1047                 g_resolv_flags & RESOLV_MAC);
1048   gtk_tooltips_set_tip(tooltips, m_resolv_cb,
1049     "Perform MAC layer name resolution while capturing.", NULL);
1050   gtk_container_add(GTK_CONTAINER(resolv_vb), m_resolv_cb);
1051
1052   n_resolv_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
1053                 "Enable _network name resolution", accel_group);
1054   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(n_resolv_cb),
1055                 g_resolv_flags & RESOLV_NETWORK);
1056   gtk_tooltips_set_tip(tooltips, n_resolv_cb,
1057     "Perform network layer name resolution while capturing.", NULL);
1058   gtk_container_add(GTK_CONTAINER(resolv_vb), n_resolv_cb);
1059
1060   t_resolv_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC(
1061                 "Enable _transport name resolution", accel_group);
1062   gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(t_resolv_cb),
1063                 g_resolv_flags & RESOLV_TRANSPORT);
1064   gtk_tooltips_set_tip(tooltips, t_resolv_cb,
1065     "Perform transport layer name resolution while capturing.", NULL);
1066   gtk_container_add(GTK_CONTAINER(resolv_vb), t_resolv_cb);
1067
1068   /* Button row: OK and cancel buttons */
1069   bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL);
1070   gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 5);
1071
1072   ok_bt = OBJECT_GET_DATA(bbox, GTK_STOCK_OK);
1073   SIGNAL_CONNECT(ok_bt, "clicked", capture_prep_ok_cb, cap_open_w);
1074   gtk_tooltips_set_tip(tooltips, ok_bt,
1075     "Start the capture process.", NULL);
1076
1077   cancel_bt = OBJECT_GET_DATA(bbox, GTK_STOCK_CANCEL);
1078   gtk_tooltips_set_tip(tooltips, cancel_bt,
1079     "Cancel and exit dialog.", NULL);
1080   window_set_cancel_button(cap_open_w, cancel_bt, window_cancel_button_cb);
1081
1082   help_bt = OBJECT_GET_DATA(bbox, GTK_STOCK_HELP);
1083   gtk_tooltips_set_tip(tooltips, help_bt,
1084     "Show help about capturing.", NULL);
1085   SIGNAL_CONNECT(help_bt, "clicked", topic_cb, HELP_CAPTURE_OPTIONS_DIALOG);
1086
1087   gtk_widget_grab_default(ok_bt);
1088
1089   /* Attach pointers to needed widgets to the capture prefs window/object */
1090   OBJECT_SET_DATA(cap_open_w, E_CAP_IFACE_KEY, if_cb);
1091   OBJECT_SET_DATA(cap_open_w, E_CAP_SNAP_CB_KEY, snap_cb);
1092   OBJECT_SET_DATA(cap_open_w, E_CAP_SNAP_SB_KEY, snap_sb);
1093   OBJECT_SET_DATA(cap_open_w, E_CAP_LT_OM_KEY, linktype_om);
1094 #ifdef _WIN32
1095   OBJECT_SET_DATA(cap_open_w, E_CAP_BUFFER_SIZE_SB_KEY, buffer_size_sb);
1096 #endif
1097   OBJECT_SET_DATA(cap_open_w, E_CAP_PROMISC_KEY, promisc_cb);
1098   OBJECT_SET_DATA(cap_open_w, E_CAP_FILT_KEY,  filter_te);
1099   OBJECT_SET_DATA(cap_open_w, E_CAP_FILE_TE_KEY,  file_te);
1100   OBJECT_SET_DATA(cap_open_w, E_CAP_MULTI_FILES_ON_CB_KEY,  multi_files_on_cb);
1101   OBJECT_SET_DATA(cap_open_w, E_CAP_RING_NBF_CB_KEY,  ringbuffer_nbf_cb);
1102   OBJECT_SET_DATA(cap_open_w, E_CAP_RING_NBF_SB_KEY,  ringbuffer_nbf_sb);
1103   OBJECT_SET_DATA(cap_open_w, E_CAP_RING_NBF_LB_KEY,  ringbuffer_nbf_lb);
1104   OBJECT_SET_DATA(cap_open_w, E_CAP_RING_FILESIZE_CB_KEY,  ring_filesize_cb);
1105   OBJECT_SET_DATA(cap_open_w, E_CAP_RING_FILESIZE_SB_KEY,  ring_filesize_sb);
1106   OBJECT_SET_DATA(cap_open_w, E_CAP_RING_FILESIZE_OM_KEY,  ring_filesize_om);
1107   OBJECT_SET_DATA(cap_open_w, E_CAP_FILE_DURATION_CB_KEY,  file_duration_cb);
1108   OBJECT_SET_DATA(cap_open_w, E_CAP_FILE_DURATION_SB_KEY,  file_duration_sb);
1109   OBJECT_SET_DATA(cap_open_w, E_CAP_FILE_DURATION_OM_KEY,  file_duration_om);
1110   OBJECT_SET_DATA(cap_open_w, E_CAP_SYNC_KEY,  sync_cb);
1111   OBJECT_SET_DATA(cap_open_w, E_CAP_AUTO_SCROLL_KEY, auto_scroll_cb);
1112   OBJECT_SET_DATA(cap_open_w, E_CAP_HIDE_INFO_KEY, hide_info_cb);
1113   OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_PACKETS_CB_KEY, stop_packets_cb);
1114   OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_PACKETS_SB_KEY, stop_packets_sb);
1115   OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_PACKETS_LB_KEY, stop_packets_lb);
1116   OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_FILESIZE_CB_KEY, stop_filesize_cb);
1117   OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_FILESIZE_SB_KEY, stop_filesize_sb);
1118   OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_FILESIZE_OM_KEY, stop_filesize_om);
1119   OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_DURATION_CB_KEY,  stop_duration_cb);
1120   OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_DURATION_SB_KEY,  stop_duration_sb);
1121   OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_DURATION_OM_KEY,  stop_duration_om);
1122   OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_FILES_CB_KEY, stop_files_cb);
1123   OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_FILES_SB_KEY, stop_files_sb);
1124   OBJECT_SET_DATA(cap_open_w, E_CAP_STOP_FILES_LB_KEY, stop_files_lb);
1125   OBJECT_SET_DATA(cap_open_w, E_CAP_M_RESOLVE_KEY,  m_resolv_cb);
1126   OBJECT_SET_DATA(cap_open_w, E_CAP_N_RESOLVE_KEY,  n_resolv_cb);
1127   OBJECT_SET_DATA(cap_open_w, E_CAP_T_RESOLVE_KEY,  t_resolv_cb);
1128
1129   /* Set the sensitivity of various widgets as per the settings of other
1130      widgets. */
1131   capture_prep_adjust_sensitivity(NULL, cap_open_w);
1132
1133   /* Catch the "activate" signal on the text
1134      entries, so that if the user types Return there, we act as if the
1135      "OK" button had been selected, as happens if Return is typed if some
1136      widget that *doesn't* handle the Return key has the input focus. */
1137   dlg_set_activate(GTK_COMBO(if_cb)->entry, ok_bt);
1138   dlg_set_activate(filter_te, ok_bt);
1139   dlg_set_activate(file_te, ok_bt);
1140
1141   /* XXX - why does not
1142
1143      gtk_widget_grab_focus(if_cb);
1144
1145     give the initial focus to the "Interface" combo box?
1146
1147     Or should I phrase that as "why does GTK+ continually frustrate
1148     attempts to make GUIs driveable from the keyboard?"  We have to
1149     go catch the activate signal on every single GtkEntry widget
1150     (rather than having widgets whose activate signal is *not*
1151     caught not catch the Return keystroke, so that it passes on,
1152     ultimately, to the window, which can activate the default
1153     widget, i.e. the "OK" button); we have to catch the "key_press_event"
1154     signal and have the handler check for ESC, so that we can have ESC
1155     activate the "Cancel" button; in order to support Alt+<key> mnemonics
1156     for buttons and the like, we may have to construct an accelerator
1157     group by hand and set up the accelerators by hand (if that even
1158     works - I've not tried it yet); we have to do a "gtk_widget_grab_focus()"
1159     to keep some container widget from getting the initial focus, so that
1160     you don't have to tab into the first widget in order to start typing
1161     in it; and it now appears that you simply *can't* make a combo box
1162     get the initial focus, at least not in the obvious fashion. Sigh.... */
1163
1164   SIGNAL_CONNECT(cap_open_w, "delete_event", window_delete_event_cb, NULL);
1165   SIGNAL_CONNECT(cap_open_w, "destroy", capture_prep_destroy_cb, NULL);
1166
1167   /* Give the initial focus to the "Filter" entry box. */
1168   gtk_widget_grab_focus(filter_te);
1169
1170   gtk_widget_show_all(cap_open_w);
1171   window_present(cap_open_w);
1172 }
1173
1174 static void
1175 capture_prep_answered_cb(gpointer dialog _U_, gint btn, gpointer data)
1176 {
1177     switch(btn) {
1178     case(ESD_BTN_SAVE):
1179         /* save file first */
1180         file_save_as_cmd(after_save_capture_dialog, data);
1181         break;
1182     case(ESD_BTN_DONT_SAVE):
1183         capture_prep();
1184         break;
1185     case(ESD_BTN_CANCEL):
1186         break;
1187     default:
1188         g_assert_not_reached();
1189     }
1190 }
1191
1192 void
1193 capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
1194 {
1195   gpointer  dialog;
1196
1197   if((cfile.state != FILE_CLOSED) && !cfile.user_saved && prefs.gui_ask_unsaved) {
1198     /* user didn't saved his current file, ask him */
1199     dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_SAVE_DONTSAVE_CANCEL,
1200                 PRIMARY_TEXT_START "Save capture file before starting a new capture?" PRIMARY_TEXT_END "\n\n"
1201                 "If you start a new capture without saving, your current capture data will\nbe discarded.");
1202     simple_dialog_set_cb(dialog, capture_prep_answered_cb, NULL);
1203   } else {
1204     /* unchanged file, just capture a new one */
1205     capture_prep();
1206   }
1207 }
1208
1209 static void
1210 select_link_type_cb(GtkWidget *w, gpointer data)
1211 {
1212   int new_linktype = GPOINTER_TO_INT(data);
1213   GtkWidget *linktype_om = OBJECT_GET_DATA(w, E_CAP_LT_OM_KEY);
1214   int old_linktype = GPOINTER_TO_INT(OBJECT_GET_DATA(linktype_om, E_CAP_OM_LT_VALUE_KEY));
1215
1216   if (old_linktype != new_linktype)
1217     OBJECT_SET_DATA(linktype_om, E_CAP_OM_LT_VALUE_KEY, GINT_TO_POINTER(new_linktype));
1218 }
1219
1220 static void
1221 capture_prep_file_cb(GtkWidget *file_bt, GtkWidget *file_te)
1222 {
1223     file_selection_browse(file_bt, file_te, "Ethereal: Specify a Capture File", FILE_SELECTION_WRITE_BROWSE);
1224 }
1225
1226
1227 static void
1228 capture_prep_ok_cb(GtkWidget *ok_bt _U_, gpointer parent_w) {
1229   GtkWidget *if_cb, *snap_cb, *snap_sb, *promisc_cb, *filter_te, *filter_cm,
1230             *file_te, *multi_files_on_cb, *ringbuffer_nbf_sb, *ringbuffer_nbf_cb,
1231             *linktype_om, *sync_cb, *auto_scroll_cb, *hide_info_cb,
1232             *stop_packets_cb, *stop_packets_sb,
1233             *stop_filesize_cb, *stop_filesize_sb, *stop_filesize_om,
1234             *stop_duration_cb, *stop_duration_sb, *stop_duration_om,
1235             *ring_filesize_cb, *ring_filesize_sb, *ring_filesize_om,
1236             *file_duration_cb, *file_duration_sb, *file_duration_om,
1237             *stop_files_cb, *stop_files_sb,
1238             *m_resolv_cb, *n_resolv_cb, *t_resolv_cb;
1239 #ifdef _WIN32
1240   GtkWidget *buffer_size_sb;
1241 #endif
1242   gchar *entry_text;
1243   gchar *if_text;
1244   gchar *if_name;
1245   const gchar *filter_text;
1246   const gchar *g_save_file;
1247   gchar *cf_name;
1248   gchar *dirname;
1249   gint32 tmp;
1250
1251   if_cb     = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_IFACE_KEY);
1252   snap_cb   = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SNAP_CB_KEY);
1253   snap_sb   = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SNAP_SB_KEY);
1254   linktype_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_LT_OM_KEY);
1255 #ifdef _WIN32
1256   buffer_size_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_BUFFER_SIZE_SB_KEY);
1257 #endif
1258   promisc_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_PROMISC_KEY);
1259   filter_cm = OBJECT_GET_DATA(top_level, E_CFILTER_CM_KEY);
1260   filter_te = GTK_COMBO(filter_cm)->entry;
1261   file_te   = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_FILE_TE_KEY);
1262   multi_files_on_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_MULTI_FILES_ON_CB_KEY);
1263   ringbuffer_nbf_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_NBF_CB_KEY);
1264   ringbuffer_nbf_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_NBF_SB_KEY);
1265   ring_filesize_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_FILESIZE_CB_KEY);
1266   ring_filesize_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_FILESIZE_SB_KEY);
1267   ring_filesize_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_FILESIZE_OM_KEY);
1268   file_duration_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_FILE_DURATION_CB_KEY);
1269   file_duration_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_FILE_DURATION_SB_KEY);
1270   file_duration_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_FILE_DURATION_OM_KEY);
1271   sync_cb   = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SYNC_KEY);
1272   auto_scroll_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_AUTO_SCROLL_KEY);
1273   hide_info_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_HIDE_INFO_KEY);
1274   stop_packets_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_PACKETS_CB_KEY);
1275   stop_packets_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_PACKETS_SB_KEY);
1276   stop_filesize_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILESIZE_CB_KEY);
1277   stop_filesize_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILESIZE_SB_KEY);
1278   stop_filesize_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILESIZE_OM_KEY);
1279   stop_duration_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_DURATION_CB_KEY);
1280   stop_duration_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_DURATION_SB_KEY);
1281   stop_duration_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_DURATION_OM_KEY);
1282   stop_files_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILES_CB_KEY);
1283   stop_files_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILES_SB_KEY);
1284   m_resolv_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_M_RESOLVE_KEY);
1285   n_resolv_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_N_RESOLVE_KEY);
1286   t_resolv_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_T_RESOLVE_KEY);
1287
1288   entry_text =
1289     g_strdup(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(if_cb)->entry)));
1290   if_text = g_strstrip(entry_text);
1291   if_name = get_if_name(if_text);
1292   if (*if_name == '\0') {
1293     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
1294       "You didn't specify an interface on which to capture packets.");
1295     g_free(entry_text);
1296     return;
1297   }
1298   if (capture_opts->iface)
1299     g_free(capture_opts->iface);
1300   capture_opts->iface = g_strdup(if_name);
1301   g_free(entry_text);
1302
1303   capture_opts->linktype =
1304       GPOINTER_TO_INT(OBJECT_GET_DATA(linktype_om, E_CAP_OM_LT_VALUE_KEY));
1305
1306 #ifdef _WIN32
1307   capture_opts->buffer_size =
1308     gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(buffer_size_sb));
1309 #endif
1310
1311   capture_opts->has_snaplen =
1312     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb));
1313   if (capture_opts->has_snaplen) {
1314     capture_opts->snaplen =
1315       gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(snap_sb));
1316     if (capture_opts->snaplen < 1)
1317       capture_opts->snaplen = WTAP_MAX_PACKET_SIZE;
1318     else if (capture_opts->snaplen < MIN_PACKET_SIZE)
1319       capture_opts->snaplen = MIN_PACKET_SIZE;
1320   }
1321
1322   capture_opts->promisc_mode =
1323     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(promisc_cb));
1324
1325   /* XXX - don't try to get clever and set "cfile.filter" to NULL if the
1326      filter string is empty, as an indication that we don't have a filter
1327      and thus don't have to set a filter when capturing - the version of
1328      libpcap in Red Hat Linux 6.1, and versions based on later patches
1329      in that series, don't bind the AF_PACKET socket to an interface
1330      until a filter is set, which means they aren't bound at all if
1331      no filter is set, which means no packets arrive as input on that
1332      socket, which means Ethereal never sees any packets. */
1333   filter_text = gtk_entry_get_text(GTK_ENTRY(filter_te));
1334   if (capture_opts->cfilter)
1335     g_free(capture_opts->cfilter);
1336   g_assert(filter_text != NULL);
1337   capture_opts->cfilter = g_strdup(filter_text);
1338
1339   g_save_file = gtk_entry_get_text(GTK_ENTRY(file_te));
1340   if (g_save_file && g_save_file[0]) {
1341     /* User specified a file to which the capture should be written. */
1342     capture_opts->save_file = g_strdup(g_save_file);
1343     /* Save the directory name for future file dialogs. */
1344     cf_name = g_strdup(g_save_file);
1345     dirname = get_dirname(cf_name);  /* Overwrites cf_name */
1346     set_last_open_dir(dirname);
1347     g_free(cf_name);
1348   } else {
1349     /* User didn't specify a file; save to a temporary file. */
1350     capture_opts->save_file = NULL;
1351   }
1352
1353   capture_opts->has_autostop_packets =
1354     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_packets_cb));
1355   if (capture_opts->has_autostop_packets)
1356     capture_opts->autostop_packets =
1357       gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(stop_packets_sb));
1358
1359   capture_opts->has_autostop_duration =
1360     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_duration_cb));
1361   if (capture_opts->has_autostop_duration) {
1362     capture_opts->autostop_duration =
1363       gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(stop_duration_sb));
1364     capture_opts->autostop_duration =
1365       time_unit_option_menu_get_value(stop_duration_om, capture_opts->autostop_duration);
1366   }
1367
1368   capture_opts->sync_mode =
1369     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sync_cb));
1370
1371   auto_scroll_live =
1372       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(auto_scroll_cb));
1373
1374   capture_opts->show_info =
1375       !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hide_info_cb));
1376
1377   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_resolv_cb)))
1378     g_resolv_flags |= RESOLV_MAC;
1379   else
1380     g_resolv_flags &= ~RESOLV_MAC;
1381   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(n_resolv_cb)))
1382     g_resolv_flags |= RESOLV_NETWORK;
1383   else
1384     g_resolv_flags &= ~RESOLV_NETWORK;
1385   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(t_resolv_cb)))
1386     g_resolv_flags |= RESOLV_TRANSPORT;
1387   else
1388     g_resolv_flags &= ~RESOLV_TRANSPORT;
1389
1390   capture_opts->has_ring_num_files =
1391     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ringbuffer_nbf_cb));
1392
1393   capture_opts->ring_num_files =
1394     gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ringbuffer_nbf_sb));
1395   if (capture_opts->ring_num_files > RINGBUFFER_MAX_NUM_FILES)
1396     capture_opts->ring_num_files = RINGBUFFER_MAX_NUM_FILES;
1397 #if RINGBUFFER_MIN_NUM_FILES > 0
1398   else if (capture_opts->ring_num_files < RINGBUFFER_MIN_NUM_FILES)
1399     capture_opts->ring_num_files = RINGBUFFER_MIN_NUM_FILES;
1400 #endif
1401
1402   capture_opts->multi_files_on =
1403     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(multi_files_on_cb));
1404
1405   capture_opts->has_file_duration =
1406     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(file_duration_cb));
1407   if (capture_opts->has_file_duration) {
1408     capture_opts->file_duration =
1409       gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(file_duration_sb));
1410     capture_opts->file_duration =
1411       time_unit_option_menu_get_value(file_duration_om, capture_opts->file_duration);
1412   }
1413
1414   capture_opts->has_autostop_files =
1415     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_files_cb));
1416   if (capture_opts->has_autostop_files)
1417     capture_opts->autostop_files =
1418       gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(stop_files_sb));
1419
1420   if(capture_opts->sync_mode)
1421     capture_opts->multi_files_on = FALSE;
1422
1423   if (capture_opts->multi_files_on) {
1424     capture_opts->has_autostop_filesize =
1425       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ring_filesize_cb));
1426     if (capture_opts->has_autostop_filesize) {
1427       tmp = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ring_filesize_sb));
1428       tmp = size_unit_option_menu_convert_value(ring_filesize_om, tmp);
1429       if(tmp != 0) {
1430         capture_opts->autostop_filesize = tmp;
1431       } else {
1432         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
1433           PRIMARY_TEXT_START "Multiple files: Requested filesize too large!\n\n" PRIMARY_TEXT_END
1434           "The setting \"Next file every x byte(s)\" can't be greater than %u bytes (2GB).", G_MAXINT);
1435         return;
1436       }
1437     }
1438
1439     /* test if the settings are ok for a ringbuffer */
1440     if (capture_opts->save_file == NULL) {
1441       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
1442         PRIMARY_TEXT_START "Multiple files: No capture file name given!\n\n" PRIMARY_TEXT_END
1443         "You must specify a filename if you want to use multiple files.");
1444       return;
1445     } else if (!capture_opts->has_autostop_filesize && !capture_opts->has_file_duration) {
1446       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
1447         PRIMARY_TEXT_START "Multiple files: No file limit given!\n\n" PRIMARY_TEXT_END
1448         "You must specify a file size or duration at which is switched to the next capture file\n"
1449         "if you want to use multiple files.");
1450       g_free(capture_opts->save_file);
1451       capture_opts->save_file = NULL;
1452       return;
1453     }
1454   } else {
1455     capture_opts->has_autostop_filesize =
1456       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_filesize_cb));
1457     if (capture_opts->has_autostop_filesize) {
1458       tmp = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(stop_filesize_sb));
1459       tmp = size_unit_option_menu_convert_value(stop_filesize_om, tmp);
1460       if(tmp != 0) {
1461         capture_opts->autostop_filesize = tmp;
1462       } else {
1463         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
1464           PRIMARY_TEXT_START "Stop Capture: Requested filesize too large!\n\n" PRIMARY_TEXT_END
1465           "The setting \"... after x byte(s)\" can't be greater than %u bytes (2GB).", G_MAXINT);
1466         return;
1467       }
1468     }
1469   }
1470
1471   window_destroy(GTK_WIDGET(parent_w));
1472
1473   if (do_capture(capture_opts)) {
1474     /* The capture succeeded, which means the capture filter syntax is
1475        valid; add this capture filter to the recent capture filter list. */
1476     cfilter_combo_add_recent(capture_opts->cfilter);
1477   }
1478 }
1479
1480 static void
1481 capture_prep_destroy_cb(GtkWidget *win, gpointer user_data _U_)
1482 {
1483   GtkWidget *fs;
1484
1485   /* Is there a file selection dialog associated with this
1486      Capture Options dialog? */
1487   fs = OBJECT_GET_DATA(win, E_FILE_SEL_DIALOG_PTR_KEY);
1488
1489   if (fs != NULL) {
1490     /* Yes.  Destroy it. */
1491     window_destroy(fs);
1492   }
1493
1494   /* Note that we no longer have a "Capture Options" dialog box. */
1495   cap_open_w = NULL;
1496 }
1497
1498 static void
1499 capture_prep_interface_changed_cb(GtkWidget *entry, gpointer argp)
1500 {
1501   GtkWidget *linktype_om = argp;
1502
1503   set_link_type_list(linktype_om, entry);
1504 }
1505
1506 /*
1507  * Adjust the sensitivity of various widgets as per the current setting
1508  * of other widgets.
1509  */
1510 static void
1511 capture_prep_adjust_sensitivity(GtkWidget *tb _U_, gpointer parent_w)
1512 {
1513   GtkWidget *if_cb,
1514             *snap_cb, *snap_sb,
1515             *multi_files_on_cb, *ringbuffer_nbf_cb, *ringbuffer_nbf_sb, *ringbuffer_nbf_lb,
1516             *ring_filesize_cb, *ring_filesize_sb, *ring_filesize_om,
1517             *file_duration_cb, *file_duration_sb, *file_duration_om,
1518             *sync_cb, *auto_scroll_cb, *hide_info_cb,
1519             *stop_packets_cb, *stop_packets_sb, *stop_packets_lb,
1520             *stop_filesize_cb, *stop_filesize_sb, *stop_filesize_om,
1521             *stop_duration_cb, *stop_duration_sb, *stop_duration_om,
1522             *stop_files_cb, *stop_files_sb, *stop_files_lb;
1523
1524
1525   if_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_IFACE_KEY);
1526   snap_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SNAP_CB_KEY);
1527   snap_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SNAP_SB_KEY);
1528   multi_files_on_cb  = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_MULTI_FILES_ON_CB_KEY);
1529   ringbuffer_nbf_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_NBF_CB_KEY);
1530   ringbuffer_nbf_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_NBF_SB_KEY);
1531   ringbuffer_nbf_lb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_NBF_LB_KEY);
1532   ring_filesize_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_FILESIZE_CB_KEY);
1533   ring_filesize_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_FILESIZE_SB_KEY);
1534   ring_filesize_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_RING_FILESIZE_OM_KEY);
1535   file_duration_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_FILE_DURATION_CB_KEY);
1536   file_duration_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_FILE_DURATION_SB_KEY);
1537   file_duration_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_FILE_DURATION_OM_KEY);
1538   sync_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_SYNC_KEY);
1539   auto_scroll_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_AUTO_SCROLL_KEY);
1540   hide_info_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_HIDE_INFO_KEY);
1541   stop_packets_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_PACKETS_CB_KEY);
1542   stop_packets_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_PACKETS_SB_KEY);
1543   stop_packets_lb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_PACKETS_LB_KEY);
1544   stop_filesize_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILESIZE_CB_KEY);
1545   stop_filesize_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILESIZE_SB_KEY);
1546   stop_filesize_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILESIZE_OM_KEY);
1547   stop_duration_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_DURATION_CB_KEY);
1548   stop_duration_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_DURATION_SB_KEY);
1549   stop_duration_om = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_DURATION_OM_KEY);
1550   stop_files_cb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILES_CB_KEY);
1551   stop_files_sb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILES_SB_KEY);
1552   stop_files_lb = (GtkWidget *) OBJECT_GET_DATA(parent_w, E_CAP_STOP_FILES_LB_KEY);
1553
1554   /* The snapshot length spinbox is sensitive if the "Limit each packet
1555      to" checkbox is on. */
1556   gtk_widget_set_sensitive(GTK_WIDGET(snap_sb),
1557       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb)));
1558
1559
1560   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sync_cb))) {
1561     /* "Update list of packets in real time" captures enabled; we don't
1562        support ring buffer mode for those captures, so turn ring buffer
1563        mode off if it's on, and make its toggle button, and the spin
1564        button for the number of ring buffer files (and the spin button's
1565        label), insensitive. */
1566     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(multi_files_on_cb), FALSE);
1567     gtk_widget_set_sensitive(GTK_WIDGET(multi_files_on_cb), FALSE);
1568
1569     /* Auto-scroll mode is meaningful only in "Update list of packets
1570        in real time" captures, so make its toggle button sensitive. */
1571     gtk_widget_set_sensitive(GTK_WIDGET(auto_scroll_cb), TRUE);
1572
1573     gtk_widget_set_sensitive(GTK_WIDGET(hide_info_cb), TRUE);
1574   } else {
1575     /* "Update list of packets in real time" captures disabled; that
1576        means ring buffer mode is OK, so make its toggle button
1577        sensitive. */
1578     gtk_widget_set_sensitive(GTK_WIDGET(multi_files_on_cb), TRUE);
1579
1580     /* Auto-scroll mode is meaningful only in "Update list of packets
1581        in real time" captures, so make its toggle button insensitive. */
1582     gtk_widget_set_sensitive(GTK_WIDGET(auto_scroll_cb), FALSE);
1583
1584     gtk_widget_set_sensitive(GTK_WIDGET(hide_info_cb), FALSE);
1585   }
1586
1587   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(multi_files_on_cb))) {
1588     /* Ring buffer mode enabled. */
1589
1590     /* Force at least one of the "file switch" conditions (we need at least one) */
1591     if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ring_filesize_cb)) == FALSE &&
1592         gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(file_duration_cb)) == FALSE) {
1593       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ring_filesize_cb), TRUE);
1594     }
1595
1596     gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_cb), TRUE);
1597     gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_sb),
1598           gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ringbuffer_nbf_cb)));
1599     gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_lb),
1600           gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ringbuffer_nbf_cb)));
1601
1602     /* The ring filesize spinbox is sensitive if the "Next capture file
1603          after N kilobytes" checkbox is on. */
1604     gtk_widget_set_sensitive(GTK_WIDGET(ring_filesize_cb), TRUE);
1605     gtk_widget_set_sensitive(GTK_WIDGET(ring_filesize_sb),
1606           gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ring_filesize_cb)));
1607     gtk_widget_set_sensitive(GTK_WIDGET(ring_filesize_om),
1608           gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ring_filesize_cb)));
1609
1610     /* The ring duration spinbox is sensitive if the "Next capture file
1611          after N seconds" checkbox is on. */
1612     gtk_widget_set_sensitive(GTK_WIDGET(file_duration_cb), TRUE);
1613     gtk_widget_set_sensitive(GTK_WIDGET(file_duration_sb),
1614           gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(file_duration_cb)));
1615     gtk_widget_set_sensitive(GTK_WIDGET(file_duration_om),
1616           gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(file_duration_cb)));
1617
1618     gtk_widget_set_sensitive(GTK_WIDGET(stop_filesize_cb), FALSE);
1619     gtk_widget_set_sensitive(GTK_WIDGET(stop_filesize_sb), FALSE);
1620     gtk_widget_set_sensitive(GTK_WIDGET(stop_filesize_om), FALSE);
1621
1622     gtk_widget_set_sensitive(GTK_WIDGET(stop_files_cb), TRUE);
1623     gtk_widget_set_sensitive(GTK_WIDGET(stop_files_sb),
1624           gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_files_cb)));
1625     gtk_widget_set_sensitive(GTK_WIDGET(stop_files_lb),
1626           gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_files_cb)));
1627   } else {
1628     /* Ring buffer mode disabled. */
1629     gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_cb), FALSE);
1630     gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_sb), FALSE);
1631     gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_lb), FALSE);
1632
1633     gtk_widget_set_sensitive(GTK_WIDGET(ring_filesize_cb), FALSE);
1634     gtk_widget_set_sensitive(GTK_WIDGET(ring_filesize_sb),FALSE);
1635     gtk_widget_set_sensitive(GTK_WIDGET(ring_filesize_om),FALSE);
1636
1637     gtk_widget_set_sensitive(GTK_WIDGET(file_duration_cb), FALSE);
1638     gtk_widget_set_sensitive(GTK_WIDGET(file_duration_sb),FALSE);
1639     gtk_widget_set_sensitive(GTK_WIDGET(file_duration_om),FALSE);
1640
1641     /* The maximum file size spinbox is sensitive if the "Stop capture
1642          after N kilobytes" checkbox is on. */
1643     gtk_widget_set_sensitive(GTK_WIDGET(stop_filesize_cb), TRUE);
1644     gtk_widget_set_sensitive(GTK_WIDGET(stop_filesize_sb),
1645           gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_filesize_cb)));
1646     gtk_widget_set_sensitive(GTK_WIDGET(stop_filesize_om),
1647           gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_filesize_cb)));
1648
1649     gtk_widget_set_sensitive(GTK_WIDGET(stop_files_cb), FALSE);
1650     gtk_widget_set_sensitive(GTK_WIDGET(stop_files_sb), FALSE);
1651     gtk_widget_set_sensitive(GTK_WIDGET(stop_files_lb), FALSE);
1652   }
1653
1654   /* The maximum packet count spinbox is sensitive if the "Stop capture
1655      after N packets" checkbox is on. */
1656   gtk_widget_set_sensitive(GTK_WIDGET(stop_packets_sb),
1657       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_packets_cb)));
1658   gtk_widget_set_sensitive(GTK_WIDGET(stop_packets_lb),
1659       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_packets_cb)));
1660
1661   /* The capture duration spinbox is sensitive if the "Stop capture
1662      after N seconds" checkbox is on. */
1663   gtk_widget_set_sensitive(GTK_WIDGET(stop_duration_sb),
1664       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_duration_cb)));
1665   gtk_widget_set_sensitive(GTK_WIDGET(stop_duration_om),
1666       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_duration_cb)));
1667 }
1668
1669 #endif /* HAVE_LIBPCAP */