Add buffersize and snap length to the preferences.

svn path=/trunk/; revision=48163

diff --git a/capture_opts.h b/capture_opts.h
index adc05bd5f0e3b6c570c50d757efa9d962b65a5fc..7714b15b4af99de6ac47a33049d4286b6134db5d 100644 (file)
--- a/capture_opts.h
+++ b/capture_opts.h
@@ -123,6 +123,7 @@ typedef struct interface_tag {
     gint active_dlt;
     gboolean pmode;
     gboolean has_snaplen;
+    gboolean snap_pref;
     guint snaplen;
     gboolean local;
 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)

diff --git a/capture_ui_utils.c b/capture_ui_utils.c
index 5636e7eaece44707f22d9d500b23da3d70376d6e..6f525f108edc2a0de29bdaef3257db95dbfd15cb 100644 (file)
--- a/capture_ui_utils.c
+++ b/capture_ui_utils.c
@@ -132,6 +132,98 @@ capture_dev_user_linktype_find(const gchar *if_name)
   return (gint)linktype;
 }
 
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+gint
+capture_dev_user_buffersize_find(const gchar *if_name)
+{
+  gchar *p, *next;
+  gint buffersize;
+
+  if ((prefs.capture_devices_buffersize == NULL) ||
+      (*prefs.capture_devices_buffersize == '\0')) {
+    /* There are no buffersizes defined */
+    return -1;
+  }
+
+  if ((p = strstr(prefs.capture_devices_buffersize, if_name)) == NULL) {
+    /* There are, but there isn't one for this interface. */
+    return -1;
+  }
+
+  p += strlen(if_name) + 1;
+  buffersize = (gint)strtol(p, &next, 10);
+  if (next == p || *next != ')' || buffersize < 0) {
+    /* Syntax error */
+    return -1;
+  }
+  if (buffersize > G_MAXINT) {
+    /* Value doesn't fit in a gint */
+    return -1;
+  }
+
+  return (gint)buffersize;
+}
+#endif
+
+gint
+capture_dev_user_snaplen_find(const gchar *if_name)
+{
+  gchar *p, *next;
+  gint snaplen;
+
+  if ((prefs.capture_devices_snaplen == NULL) ||
+      (*prefs.capture_devices_snaplen == '\0')) {
+    /* There is no snap length defined */
+    return -1;
+  }
+
+  if ((p = strstr(prefs.capture_devices_snaplen, if_name)) == NULL) {
+    /* There are, but there isn't one for this interface. */
+    return -1;
+  }
+
+  p += strlen(if_name) + 3;
+  snaplen = (gint)strtol(p, &next, 10);
+  if (next == p || *next != ')' || snaplen < 0) {
+    /* Syntax error */
+    return -1;
+  }
+  if (snaplen > WTAP_MAX_PACKET_SIZE) {
+    /* Value doesn't fit in a gint */
+    return -1;
+  }
+
+  return (gint)snaplen;
+}
+
+gboolean
+capture_dev_user_hassnap_find(const gchar *if_name)
+{
+  gchar *p, *next;
+  gboolean hassnap;
+
+  if ((prefs.capture_devices_snaplen == NULL) ||
+      (*prefs.capture_devices_snaplen == '\0')) {
+    /* There is no snap length defined */
+    return -1;
+  }
+
+  if ((p = strstr(prefs.capture_devices_snaplen, if_name)) == NULL) {
+    /* There are, but there isn't one for this interface. */
+    return -1;
+  }
+
+  p += strlen(if_name) + 1;
+  hassnap = (gboolean)strtol(p, &next, 10);
+  if (next == p || *next != '(') {
+    /* Syntax error */
+    return -1;
+  }
+
+  return (gboolean)hassnap;
+}
+
+
 /*
  * Return as descriptive a name for an interface as we can get.
  * If the user has specified a comment, use that.  Otherwise,

diff --git a/capture_ui_utils.h b/capture_ui_utils.h
index 60b3bc165410c22ae862525286cd0855d597d663..d95a792b1cae0d916e63e2f60f8cb2849343d897 100644 (file)
--- a/capture_ui_utils.h
+++ b/capture_ui_utils.h
@@ -47,6 +47,21 @@ char *capture_dev_user_descr_find(const gchar *if_name);
  */
 gint capture_dev_user_linktype_find(const gchar *if_name);
 
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+/**
+ * Find user-specified buffer size that matches interface
+ * name, if any.
+ */
+gint capture_dev_user_buffersize_find(const gchar *if_name);
+#endif
+
+/**
+ * Find user-specified snap length that matches interface
+ * name, if any.
+ */
+gint capture_dev_user_snaplen_find(const gchar *if_name);
+gboolean capture_dev_user_hassnap_find(const gchar *if_name);
+
 /** Return as descriptive a name for an interface as we can get.
  * If the user has specified a comment, use that.  Otherwise,
  * if capture_interface_list() supplies a description, use that,

diff --git a/epan/prefs.c b/epan/prefs.c
index a0e4032e84cf29d830962b245760cd78e40e6ff3..5b2f6cc7ffb371373bfdef77b60cce06a6598b88 100644 (file)
--- a/epan/prefs.c
+++ b/epan/prefs.c
@@ -2180,6 +2180,14 @@ prefs_register_modules(void)
         "By default, capture in monitor mode on interface? (Ex: eth0,eth3,...)",
         (const char**)(&prefs.capture_devices_monitor_mode));
 
+    prefs_register_string_preference(capture_module, "devices_buffersize", "Interface buffer size",
+        "Interface buffer size (Ex: en0(1),en1(143),...)",
+        (const char**)(&prefs.capture_devices_buffersize));
+
+    prefs_register_string_preference(capture_module, "devices_snaplen", "Interface snap length",
+        "Interface snap length (Ex: en0(65535),en1(1430),...)",
+        (const char**)(&prefs.capture_devices_snaplen));
+
     prefs_register_bool_preference(capture_module, "prom_mode", "Capture in promiscuous mode",
         "Capture in promiscuous mode?", &prefs.capture_prom_mode);
 

diff --git a/epan/prefs.h b/epan/prefs.h
index d4053545fd714ea3a1a39b10f98474f308670268..241a16f5e79135d856762899ae0d53759db912ea 100644 (file)
--- a/epan/prefs.h
+++ b/epan/prefs.h
@@ -182,6 +182,10 @@ typedef struct _e_prefs {
   gchar       *capture_devices_descr;
   gchar       *capture_devices_hide;
   gchar       *capture_devices_monitor_mode;
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+  gchar       *capture_devices_buffersize;
+#endif
+  gchar       *capture_devices_snaplen;
   gboolean     capture_prom_mode;
   gboolean     capture_pcap_ng;
   gboolean     capture_real_time;

diff --git a/ui/gtk/capture_dlg.c b/ui/gtk/capture_dlg.c
index 8f92512a70eb3de8f392800038460ea7e4519a01..dadae7ec320e6d1df4c70634ce009ec240aaa887 100644 (file)
--- a/ui/gtk/capture_dlg.c
+++ b/ui/gtk/capture_dlg.c
@@ -1248,11 +1248,16 @@ insert_new_rows(GList *list)
       device.display_name = g_strdup(if_string);
     }
 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
-    device.buffer = global_capture_opts.default_options.buffer_size;
+    if ((device.buffer = capture_dev_user_buffersize_find(if_string->name)) == -1) {
+      device.buffer = global_capture_opts.default_options.buffer_size;
+    }
 #endif
     device.pmode = global_capture_opts.default_options.promisc_mode;
     device.has_snaplen = global_capture_opts.default_options.has_snaplen;
-    device.snaplen = global_capture_opts.default_options.snaplen;
+    device.snap_pref = TRUE;
+    if ((device.snaplen = capture_dev_user_buffersize_find(if_string->name)) == -1) {
+      device.snaplen = global_capture_opts.default_options.snaplen;
+    }
     device.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
     monitor_mode = prefs_capture_device_monitor_mode(if_string);
     caps = capture_get_if_capabilities(if_string, monitor_mode, NULL);
@@ -1344,9 +1349,9 @@ insert_new_rows(GList *list)
     }
 
 #if defined(HAVE_PCAP_CREATE)
-    gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link_type_name, PMODE, (device.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, BUFFER, (guint) global_capture_opts.default_options.buffer_size, MONITOR, "no",FILTER, "",-1);
+    gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link_type_name, PMODE, (device.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, BUFFER, device.buffer, MONITOR, "no",FILTER, "",-1);
 #elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
-    gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link_type_name, PMODE, (device.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, BUFFER, (guint) global_capture_opts.default_options.buffer_size, FILTER, "",-1);
+    gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link_type_name, PMODE, (device.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, BUFFER, device.buffer, FILTER, "",-1);
  #else
     gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link_type_name, PMODE, (device.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, -1);
 #endif
@@ -2476,6 +2481,9 @@ save_options_cb(GtkWidget *win _U_, gpointer user_data _U_)
   device.pmode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(promisc_cb));
   device.has_snaplen = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb));
   if (device.has_snaplen) {
+    if (device.snaplen != (guint)gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(snap_sb))) {
+      device.snap_pref = FALSE;
+    }
     device.snaplen = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(snap_sb));
     if (device.snaplen < 1)
       device.snaplen = WTAP_MAX_PACKET_SIZE;
@@ -2518,6 +2526,7 @@ adjust_snap_sensitivity(GtkWidget *tb _U_, gpointer parent_w _U_)
   gtk_widget_set_sensitive(GTK_WIDGET(snap_sb),
       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb)));
   device.has_snaplen = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb));
+  device.snap_pref = FALSE;
   g_array_insert_val(global_capture_opts.all_ifaces, marked_interface, device);
 }
 
@@ -5445,6 +5454,9 @@ create_and_fill_model(GtkTreeView *view)
   guint         i;
   link_row     *linkr = NULL;
   interface_t   device;
+  gint          buffer;
+  gint          snaplen;
+  gboolean      hassnap, has_snaplen;
 
 #if defined(HAVE_PCAP_CREATE)
   store = gtk_list_store_new (9, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING);
@@ -5470,10 +5482,31 @@ create_and_fill_model(GtkTreeView *view)
           break;
         }
       }
-      if (device.has_snaplen) {
-        snaplen_string = g_strdup_printf("%d", device.snaplen);
-      } else {
+      hassnap = capture_dev_user_hassnap_find(device.name);
+      snaplen = device.snaplen;
+      has_snaplen = device.has_snaplen;
+      if (!device.snap_pref) {
+        if (has_snaplen) {
+          snaplen_string = g_strdup_printf("%d", device.snaplen);
+        } else {
+          snaplen_string = g_strdup("default");
+        }
+      } else if ((hassnap == -1 || !hassnap)) {
         snaplen_string = g_strdup("default");
+      } else {
+        snaplen = capture_dev_user_snaplen_find(device.name);
+        device.snaplen = snaplen;
+        device.has_snaplen = TRUE;
+        global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
+        g_array_insert_val(global_capture_opts.all_ifaces, i, device);
+        snaplen_string = g_strdup_printf("%d", device.snaplen);
+      }
+      buffer = device.buffer;
+      if (buffer == DEFAULT_CAPTURE_BUFFER_SIZE && capture_dev_user_buffersize_find(device.name) != DEFAULT_CAPTURE_BUFFER_SIZE && capture_dev_user_buffersize_find(device.name) != -1) {
+        buffer = capture_dev_user_buffersize_find(device.name);
+        device.buffer = buffer;
+        global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
+        g_array_insert_val(global_capture_opts.all_ifaces, i, device);
       }
       gtk_list_store_append (store, &iter);
 #if defined(HAVE_PCAP_CREATE)

diff --git a/ui/gtk/prefs_capture.c b/ui/gtk/prefs_capture.c
index def472ef87124b7cf3d4286fb31a69b5638be32d..9db23cf3cf4fc5344bd01329cce9b95350c727b5 100644 (file)
--- a/ui/gtk/prefs_capture.c
+++ b/ui/gtk/prefs_capture.c
@@ -69,6 +69,10 @@ static GtkWidget *cur_list, *if_dev_lb, *if_name_lb, *if_linktype_lb, *if_linkty
 #ifdef HAVE_PCAP_CREATE
 static GtkWidget *if_monitor_lb, *if_monitor_cb;
 #endif
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+static GtkWidget *if_buffersize_lb, *if_buffersize_cb;
+#endif
+static GtkWidget *if_snaplen_lb, *if_snaplen_cb, *if_snaplen_tg;
 static GtkTreeSelection *if_selection; /* current interface row selected */
 static int num_linktypes;
 static gboolean interfaces_info_nochange;  /* TRUE to ignore Interface Options Properties */
@@ -84,6 +88,11 @@ static void ifopts_edit_monitor_changed_cb(GtkToggleButton *tbt, gpointer udata)
 static void ifopts_edit_linktype_changed_cb(GtkComboBox *ed, gpointer udata);
 static void ifopts_edit_descr_changed_cb(GtkEditable *ed, gpointer udata);
 static void ifopts_edit_hide_changed_cb(GtkToggleButton *tbt, gpointer udata);
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+static void ifopts_edit_buffersize_changed_cb(GtkSpinButton *ed, gpointer udata);
+#endif
+static void ifopts_edit_snaplen_changed_cb(GtkSpinButton *ed, gpointer udata);
+static void ifopts_edit_hassnap_changed_cb(GtkToggleButton *tbt, gpointer udata);
 static void ifopts_options_add(GtkListStore *list_store, if_info_t *if_info);
 static void ifopts_options_free(gchar *text[]);
 static void ifopts_if_liststore_add(void);
@@ -91,6 +100,8 @@ static void ifopts_if_liststore_add(void);
 static void ifopts_write_new_monitor_mode(void);
 #endif
 static void ifopts_write_new_linklayer(void);
+static void ifopts_write_new_buffersize(void);
+static void ifopts_write_new_snaplen(void);
 static void ifopts_write_new_descr(void);
 static void ifopts_write_new_hide(void);
 
@@ -322,6 +333,11 @@ enum
 #ifdef HAVE_PCAP_CREATE
        DEF_MONITOR_MODE_COLUMN,
 #endif
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+       BUF_COLUMN,
+#endif
+       HASSNAP_COLUMN,
+       SNAPLEN_COLUMN,
        DEF_LINK_LAYER_COLUMN,
        COMMENT_COLUMN,
        HIDE_COLUMN,
@@ -553,7 +569,10 @@ ifopts_edit_cb(GtkWidget *w, gpointer data _U_)
        GtkCellRenderer   *renderer;
        GtkTreeView       *list_view;
        GtkTreeSelection  *selection;
-
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+       GtkAdjustment     *buffer_size_adj;
+#endif
+       GtkAdjustment     *snaplen_adj;
        int row = 0;
 
        GtkWidget   *caller   = gtk_widget_get_toplevel(w);
@@ -596,6 +615,11 @@ ifopts_edit_cb(GtkWidget *w, gpointer data _U_)
 #ifdef HAVE_PCAP_CREATE
                                        G_TYPE_BOOLEAN, /* Monitor mode         */
 #endif
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+                                       G_TYPE_INT,                     /* Buffer size                          */
+#endif
+                                       G_TYPE_BOOLEAN, /* Has snap length              */
+                                       G_TYPE_INT,                     /* Snap length                          */
                                        G_TYPE_STRING,  /* Default link-layer           */
                                        G_TYPE_STRING,  /* Comment                      */
                                        G_TYPE_BOOLEAN, /* Hide?                        */
@@ -653,6 +677,37 @@ ifopts_edit_cb(GtkWidget *w, gpointer data _U_)
        gtk_tree_view_append_column (list_view, column);
 #endif
 
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+       renderer = gtk_cell_renderer_spin_new ();
+       buffer_size_adj = (GtkAdjustment *) gtk_adjustment_new(DEFAULT_CAPTURE_BUFFER_SIZE, 1, 65535, 1.0, 10.0, 0.0);
+       g_object_set(G_OBJECT(renderer), "adjustment", buffer_size_adj, NULL);
+       column = gtk_tree_view_column_new_with_attributes ("Default buffer size", renderer,
+                                                          "text", BUF_COLUMN,
+                                                          NULL);
+
+       gtk_tree_view_column_set_resizable(column, TRUE);
+       gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
+       /* Add the column to the view. */
+       gtk_tree_view_append_column (list_view, column);
+#endif
+  renderer = gtk_cell_renderer_toggle_new ();
+       column = gtk_tree_view_column_new_with_attributes ("Has snap length mode", renderer,
+                                                          "active", HASSNAP_COLUMN,
+                                                          NULL);
+       gtk_tree_view_column_set_resizable(column, FALSE);
+       /*gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);*/
+       renderer = gtk_cell_renderer_spin_new ();
+       snaplen_adj = (GtkAdjustment *) gtk_adjustment_new(WTAP_MAX_PACKET_SIZE, 1, WTAP_MAX_PACKET_SIZE, 1.0, 10.0, 0.0);
+       g_object_set(G_OBJECT(renderer), "adjustment", snaplen_adj, NULL);
+       column = gtk_tree_view_column_new_with_attributes ("Default snap length", renderer,
+                                                          "text", SNAPLEN_COLUMN,
+                                                          NULL);
+
+       gtk_tree_view_column_set_resizable(column, TRUE);
+       gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
+       /* Add the column to the view. */
+       gtk_tree_view_append_column (list_view, column);
+
        renderer = gtk_cell_renderer_text_new ();
        column = gtk_tree_view_column_new_with_attributes ("Default link-layer", renderer,
                                                           "text", DEF_LINK_LAYER_COLUMN,
@@ -767,9 +822,41 @@ ifopts_edit_cb(GtkWidget *w, gpointer data _U_)
                        cur_list);
        ws_gtk_grid_attach_defaults(GTK_GRID(main_grid), if_monitor_cb, 1, row, 1, 1);
        gtk_widget_show(if_monitor_cb);
-        row++;
+       row++;
 #endif
 
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+       if_buffersize_lb = gtk_label_new("Default buffer size:");
+       ws_gtk_grid_attach_defaults(GTK_GRID(main_grid), if_buffersize_lb, 0, row, 1, 1);
+       gtk_misc_set_alignment(GTK_MISC(if_buffersize_lb), 1.0f, 0.5f);
+       gtk_widget_show(if_buffersize_lb);
+       buffer_size_adj = (GtkAdjustment *) gtk_adjustment_new(DEFAULT_CAPTURE_BUFFER_SIZE, 1, 65535, 1.0, 10.0, 0.0);
+       if_buffersize_cb = gtk_spin_button_new (buffer_size_adj, 0, 0);
+       g_signal_connect(if_buffersize_cb, "value-changed", G_CALLBACK(ifopts_edit_buffersize_changed_cb),
+                       cur_list);
+       ws_gtk_grid_attach_defaults(GTK_GRID(main_grid), if_buffersize_cb, 1, row, 1, 1);
+       gtk_widget_show(if_buffersize_cb);
+       row++;
+#endif
+
+       if_snaplen_lb = gtk_label_new("Limit each packet to:");
+       ws_gtk_grid_attach_defaults(GTK_GRID(main_grid), if_snaplen_lb, 0, row, 1, 1);
+       gtk_misc_set_alignment(GTK_MISC(if_snaplen_lb), 1.0f, 0.5f);
+       gtk_widget_show(if_snaplen_lb);
+       if_snaplen_tg = gtk_check_button_new();
+       g_signal_connect(if_snaplen_tg, "toggled", G_CALLBACK(ifopts_edit_hassnap_changed_cb),
+                       cur_list);
+       ws_gtk_grid_attach_defaults(GTK_GRID(main_grid), if_snaplen_tg, 2, row, 1, 1);
+       gtk_widget_show(if_snaplen_tg);
+       snaplen_adj = (GtkAdjustment *) gtk_adjustment_new(65535, 1, 65535, 1.0, 10.0, 0.0);
+       if_snaplen_cb = gtk_spin_button_new (snaplen_adj, 0, 0);
+       g_signal_connect(if_snaplen_cb, "value-changed", G_CALLBACK(ifopts_edit_snaplen_changed_cb),
+                       cur_list);
+       gtk_spin_button_set_numeric(GTK_SPIN_BUTTON (if_snaplen_cb), TRUE);
+       ws_gtk_grid_attach_defaults(GTK_GRID(main_grid), if_snaplen_cb, 1, row, 1, 1);
+       gtk_widget_show(if_snaplen_cb);
+       row++;
+
        if_linktype_lb = gtk_label_new("Default link-layer header type:");
        ws_gtk_grid_attach_defaults(GTK_GRID(main_grid), if_linktype_lb, 0, row, 1, 1);
        gtk_misc_set_alignment(GTK_MISC(if_linktype_lb), 1.0f, 0.5f);
@@ -913,7 +1000,15 @@ ifopts_edit_ok_cb(GtkWidget *w _U_, gpointer parent_w)
 
                /* create/write new "hidden" interfaces string */
                ifopts_write_new_hide();
-       }
+
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+               /* create/write new "buffersize" interfaces string */
+               ifopts_write_new_buffersize();
+#endif
+
+               /* create/write new "snaplen" interfaces string */
+               ifopts_write_new_snaplen();
+}
 
        /* Update everything that shows an interface list that includes
           local interfaces. */
@@ -1004,7 +1099,11 @@ ifopts_edit_ifsel_cb(GtkTreeSelection    *selection _U_,
 #ifdef HAVE_PCAP_CREATE
        gboolean            monitor_mode;
 #endif
-       gboolean            hide, hide_enabled = TRUE;
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+       gint                buffersize;
+#endif
+       gint                snaplen;
+       gboolean            hide, hide_enabled = TRUE, hassnap = FALSE;
        if_capabilities_t  *caps;
        gint                selected = 0;
 
@@ -1018,6 +1117,11 @@ ifopts_edit_ifsel_cb(GtkTreeSelection    *selection _U_,
 #ifdef HAVE_PCAP_CREATE
                           DEF_MONITOR_MODE_COLUMN,   &monitor_mode,
 #endif
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+                          BUF_COLUMN,                &buffersize,
+#endif
+                          HASSNAP_COLUMN,            &hassnap,
+                          SNAPLEN_COLUMN,            &snaplen,
                           DEF_LINK_LAYER_COLUMN,     &linktype,
                           COMMENT_COLUMN,            &comment,
                           HIDE_COLUMN,               &hide,
@@ -1029,6 +1133,14 @@ ifopts_edit_ifsel_cb(GtkTreeSelection    *selection _U_,
        /* display the interface name from current interfaces selection */
        gtk_label_set_text(GTK_LABEL(if_name_lb), desc);
 
+       /* display the buffer size from current interfaces selection */
+       gtk_spin_button_set_value(GTK_SPIN_BUTTON (if_buffersize_cb), buffersize);
+
+       /* display the snap length from current interfaces selection */
+       gtk_spin_button_set_value(GTK_SPIN_BUTTON (if_snaplen_cb), snaplen);
+       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(if_snaplen_tg), hassnap);
+       gtk_widget_set_sensitive(GTK_WIDGET(if_snaplen_cb), hassnap);
+
        /* Ignore "changed" callbacks while we update the Properties widgets */
        interfaces_info_nochange = TRUE;
 
@@ -1257,6 +1369,95 @@ ifopts_edit_linktype_changed_cb(GtkComboBox *cb, gpointer udata)
        }
 }
 
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+/*
+ * Buffer size entry changed callback; update list_store for currently selected interface.
+ */
+static void
+ifopts_edit_buffersize_changed_cb(GtkSpinButton *sb, gpointer udata)
+{
+       gint          buffersize;
+       GtkTreeModel *list_model;
+       GtkTreeIter   list_iter;
+       GtkListStore *list_store;
+
+       if (if_selection == NULL)  /* XXX: Cannot be NULL ?? */
+               return;
+
+       if (!gtk_tree_selection_get_selected (if_selection, &list_model, &list_iter)){
+               return;
+       }
+
+
+       /* get current description text and set value in list_store for currently selected interface */
+       buffersize = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sb));
+       list_store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW (udata))); /* Get store */
+       gtk_list_store_set  (list_store, &list_iter,
+                                    BUF_COLUMN, buffersize,
+                                    -1);
+}
+#endif
+
+/*
+ * Snap length entry changed callback; update list_store for currently selected interface.
+ */
+static void
+ifopts_edit_snaplen_changed_cb(GtkSpinButton *sb _U_, gpointer udata _U_)
+{
+       gint          snaplen;
+       gboolean      hassnap;
+       GtkTreeModel *list_model;
+       GtkTreeIter   list_iter;
+       GtkListStore *list_store;
+
+       if (if_selection == NULL)  /* XXX: Cannot be NULL ?? */
+               return;
+
+       if (!gtk_tree_selection_get_selected (if_selection, &list_model, &list_iter)){
+               return;
+       }
+
+
+       /* get current description text and set value in list_store for currently selected interface */
+       snaplen = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(sb));
+       if (snaplen != WTAP_MAX_PACKET_SIZE) {
+               hassnap = TRUE;
+       } else {
+               hassnap = FALSE;
+       }
+       list_store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW (udata))); 
+       gtk_list_store_set  (list_store, &list_iter,
+                                    SNAPLEN_COLUMN, snaplen,
+                                    HASSNAP_COLUMN, hassnap,
+                                    -1);
+}
+
+/*
+ * Checkbutton for the Snap length changed callback; update list_store for currently selected interface.
+ */
+static void
+ifopts_edit_hassnap_changed_cb(GtkToggleButton *tbt, gpointer udata)
+{
+       gboolean      hassnap;
+       GtkTreeModel *list_model;
+       GtkTreeIter   list_iter;
+       GtkListStore *list_store;
+
+       if (if_selection == NULL)  /* XXX: Cannot be NULL ?? */
+               return;
+
+       if (!gtk_tree_selection_get_selected (if_selection, &list_model, &list_iter)){
+               return;
+       }
+       hassnap = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tbt));
+       
+       list_store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW (udata))); 
+       gtk_list_store_set  (list_store, &list_iter,
+                                    HASSNAP_COLUMN, hassnap,
+                                    -1);
+       gtk_widget_set_sensitive(GTK_WIDGET(if_snaplen_cb), hassnap);
+}
+
 /*
  * Comment text entry changed callback; update list_store for currently selected interface.
  */
@@ -1345,7 +1546,11 @@ ifopts_options_add(GtkListStore *list_store, if_info_t *if_info)
        gboolean monitor_mode;
 #endif
        gint     linktype;
-       gboolean hide;
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+       gint buffersize;
+#endif
+       gint snaplen;
+       gboolean hide, hassnap = TRUE;
        GtkTreeIter  iter;
 
        /* set device name text */
@@ -1387,6 +1592,20 @@ ifopts_options_add(GtkListStore *list_store, if_info_t *if_info)
                }
                free_if_capabilities(caps);
        }
+
+       buffersize = capture_dev_user_buffersize_find(if_info->name);
+       if (buffersize == -1) {
+               buffersize = DEFAULT_CAPTURE_BUFFER_SIZE;
+       }
+
+       snaplen = capture_dev_user_snaplen_find(if_info->name);
+       hassnap = capture_dev_user_hassnap_find(if_info->name);
+       if (!hassnap || hassnap == -1) {
+               snaplen = WTAP_MAX_PACKET_SIZE;
+               hassnap = FALSE;
+       }
+
+
        /* if we have no link-layer */
        if (text[2] == NULL)
                text[2] = g_strdup("");
@@ -1451,6 +1670,11 @@ ifopts_options_add(GtkListStore *list_store, if_info_t *if_info)
 #ifdef HAVE_PCAP_CREATE
                             DEF_MONITOR_MODE_COLUMN, monitor_mode,
 #endif
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+                            BUF_COLUMN,              buffersize,
+#endif
+                            HASSNAP_COLUMN,          hassnap,
+                            SNAPLEN_COLUMN,          snaplen,
                             DEF_LINK_LAYER_COLUMN,   text[2],
                             COMMENT_COLUMN,          text[3],
                             HIDE_COLUMN,             hide,
@@ -1618,6 +1842,123 @@ ifopts_write_new_linklayer(void)
        }
 }
 
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+/*
+ * Create/write new interfaces buffer size string based on current CList.
+ * Put it into the preferences value.
+ */
+static void
+ifopts_write_new_buffersize(void)
+{
+       GtkListStore    *store;
+       GtkTreeIter      iter;
+       GtkTreeModel    *model;
+
+       gboolean         more_items = TRUE, first_if = TRUE;  /* flag to check if first in list */
+       gchar           *ifnm;
+       gint             buffersize;
+       gchar           *tmp_buffersize;
+       gchar           *new_buffersize;
+
+       /* new preferences interfaces buffer size string */
+       new_buffersize = g_malloc0(MAX_VAL_LEN);
+
+       /* get buffer size for each row (interface) */
+       model = gtk_tree_view_get_model(GTK_TREE_VIEW(cur_list));
+       store = GTK_LIST_STORE(model);
+       if( gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter) ) {
+
+               while (more_items) {
+                       gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,
+                                          DEVICE_COLUMN, &ifnm,
+                                          BUF_COLUMN,    &buffersize,
+                                          -1);
+                       if (buffersize == -1){
+                               more_items = gtk_tree_model_iter_next (model,&iter);
+                               continue;
+                       }
+
+                       if (first_if != TRUE) {
+                               g_strlcat (new_buffersize, ",", MAX_VAL_LEN);
+                       }
+                       /*
+                        * create/cat interface buffersize to new string
+                        * (leave space for parens, comma and terminator)
+                        */
+                       tmp_buffersize = g_strdup_printf("%s(%d)", ifnm, buffersize);
+                       g_strlcat(new_buffersize, tmp_buffersize, MAX_VAL_LEN);
+                       g_free(tmp_buffersize);
+                       g_free(ifnm);
+                       /* set first-in-list flag to false */
+                       first_if = FALSE;
+                       more_items = gtk_tree_model_iter_next (model,&iter);
+               }
+
+               /* write new buffersize string to preferences */
+               g_free(prefs.capture_devices_buffersize);
+               prefs.capture_devices_buffersize = new_buffersize;
+       }
+}
+#endif
+
+/*
+ * Create/write new interfaces buffer size string based on current CList.
+ * Put it into the preferences value.
+ */
+static void
+ifopts_write_new_snaplen(void)
+{
+       GtkListStore    *store;
+       GtkTreeIter      iter;
+       GtkTreeModel    *model;
+
+       gboolean         more_items = TRUE, first_if = TRUE;  /* flag to check if first in list */
+       gchar           *ifnm;
+       gint             snaplen;
+       gboolean hassnap;
+       gchar           *tmp_snaplen;
+       gchar           *new_snaplen;
+
+       /* new preferences interfaces snap length string */
+       new_snaplen = g_malloc0(MAX_VAL_LEN);
+
+       /* get snap length for each row (interface) */
+       model = gtk_tree_view_get_model(GTK_TREE_VIEW(cur_list));
+       store = GTK_LIST_STORE(model);
+       if( gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter) ) {
+
+               while (more_items) {
+                       gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,
+                                          DEVICE_COLUMN, &ifnm,
+                                          SNAPLEN_COLUMN,    &snaplen,
+                                          HASSNAP_COLUMN,    &hassnap,
+                                          -1);
+                       if (snaplen == -1){
+                               more_items = gtk_tree_model_iter_next (model,&iter);
+                               continue;
+                       }
+                       if (first_if != TRUE) {
+                               g_strlcat (new_snaplen, ",", MAX_VAL_LEN);
+                       }
+                       /*
+                        * create/cat interface snap length to new string
+                        * (leave space for parens, comma and terminator)
+                        */
+                       tmp_snaplen = g_strdup_printf("%s:%d(%d)", ifnm, hassnap, (hassnap?snaplen:WTAP_MAX_PACKET_SIZE));
+                       g_strlcat(new_snaplen, tmp_snaplen, MAX_VAL_LEN);
+                       g_free(tmp_snaplen);
+                       g_free(ifnm);
+                       /* set first-in-list flag to false */
+                       first_if = FALSE;
+                       more_items = gtk_tree_model_iter_next (model,&iter);
+               }
+
+               /* write new snap length string to preferences */
+               g_free(prefs.capture_devices_snaplen);
+               prefs.capture_devices_snaplen = new_snaplen;
+       }
+}
+
 /*
  * Create/write new interfaces description string based on current CList.
  * Put it into the preferences value.