Create capture dissector tables.

They are modeled after dissection dissector tables, but for the moment, don't have/need the flexibility.  They are intended to be much simpler/faster than full dissection.
The two most used/needed are "wtap_encap" and "ethertype", so they were the basis of starting to use and test capture dissector table API.  Others may be added in the future.

The "capture dissector" function signature needed a bit of tweeking to handling "claiming" of a packet.
The current application of this is capture functions returning TRUE if they affected a "type" of packet count.  Returning FALSE ends up considering the packet an "other" type.

Change-Id: I81d06a6ccb2c03665f087258a46b9d78d513d6cd
Reviewed-on: https://code.wireshark.org/review/12607
Petri-Dish: Michael Mann <mmann78@netscape.net>
Tested-by: Petri Dish Buildbot <buildbot-no-reply@wireshark.org>
Reviewed-by: Michael Mann <mmann78@netscape.net>

61 files changed, 530 insertions, 757 deletions

diff --git a/capture_info.c b/capture_info.c
index 1f9f104963..0d4afa380e 100644
--- a/capture_info.c
+++ b/capture_info.c
@@ -251,7 +251,8 @@ static void
 capture_info_packet(packet_counts *counts, gint wtap_linktype, const guchar *pd, guint32 caplen, union wtap_pseudo_header *pseudo_header)
 {
     counts->total++;
-    call_capture_dissector(wtap_linktype, pd, 0, caplen, counts, pseudo_header);
+    if (!try_capture_dissector("wtap_encap", wtap_linktype, pd, 0, caplen, counts, pseudo_header))
+        counts->other++;
 }
 
 
diff --git a/epan/capture_dissectors.c b/epan/capture_dissectors.c
index 738bacbc90..1368c254e0 100644
--- a/epan/capture_dissectors.c
+++ b/epan/capture_dissectors.c
@@ -27,48 +27,93 @@
 
 #include "capture_dissectors.h"
 
+struct capture_dissector_table {
+    GHashTable *hash_table;
+    const char *ui_name;
+};
+
 struct capture_dissector_handle
 {
-    gint linktype;
+    guint32 pattern;
     capture_dissector_t dissector;
     protocol_t* protocol;
 };
 
-static GHashTable *registered_capture_dissectors = NULL;
+static GHashTable *capture_dissector_tables = NULL;
+
+static void
+destroy_capture_dissector_table(void *data)
+{
+    struct capture_dissector_table *table = (struct capture_dissector_table *)data;
+
+    g_hash_table_destroy(table->hash_table);
+    g_free(data);
+}
 
 void capture_dissector_init(void)
 {
-    registered_capture_dissectors = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, NULL);
+    capture_dissector_tables = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, destroy_capture_dissector_table);
 }
 
 void capture_dissector_cleanup(void)
 {
-    g_hash_table_destroy(registered_capture_dissectors);
-    registered_capture_dissectors = NULL;
+    g_hash_table_destroy(capture_dissector_tables);
 }
 
-void register_capture_dissector(gint linktype, capture_dissector_t dissector, const int proto)
+void register_capture_dissector_table(const char *name, const char *ui_name)
 {
+    struct capture_dissector_table*	sub_dissectors;
+
+    /* Make sure the registration is unique */
+    if(g_hash_table_lookup( capture_dissector_tables, name )) {
+        g_error("The capture dissector table %s (%s) is already registered - are you using a buggy plugin?", name, ui_name);
+    }
+
+    sub_dissectors = g_new(struct capture_dissector_table, 1);
+
+    sub_dissectors->hash_table = g_hash_table_new_full( g_direct_hash, g_direct_equal, NULL, NULL );
+    sub_dissectors->ui_name = ui_name;
+    g_hash_table_insert( capture_dissector_tables, (gpointer)name, (gpointer) sub_dissectors );
+
+}
+
+void register_capture_dissector(const char* name, const guint32 pattern, capture_dissector_t dissector, const int proto)
+{
+    struct capture_dissector_table*	sub_dissectors;
     struct capture_dissector_handle *handle;
 
+    /* Make sure table exists */
+    sub_dissectors = (struct capture_dissector_table*)g_hash_table_lookup( capture_dissector_tables, name );
+    g_assert(sub_dissectors != NULL);
+
     /* Make sure the registration is unique */
-    g_assert(g_hash_table_lookup(registered_capture_dissectors, GUINT_TO_POINTER(linktype)) == NULL);
+    g_assert(g_hash_table_lookup(sub_dissectors->hash_table, GUINT_TO_POINTER(pattern)) == NULL);
 
     handle                = wmem_new(wmem_epan_scope(), struct capture_dissector_handle);
-    handle->linktype      = linktype;
+    handle->pattern       = pattern;
     handle->dissector     = dissector;
     handle->protocol      = find_protocol_by_id(proto);
 
-    g_hash_table_insert(registered_capture_dissectors, GUINT_TO_POINTER(linktype), (gpointer) handle);
+    g_hash_table_insert(sub_dissectors->hash_table, GUINT_TO_POINTER(pattern), (gpointer) handle);
 }
 
-void call_capture_dissector(gint linktype, const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header)
+gboolean try_capture_dissector(const char* name, const guint32 pattern, const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header)
 {
-    struct capture_dissector_handle* handle = (struct capture_dissector_handle *)g_hash_table_lookup(registered_capture_dissectors, GUINT_TO_POINTER(linktype));
+    struct capture_dissector_table*	sub_dissectors;
+    struct capture_dissector_handle* handle;
+
+    sub_dissectors = (struct capture_dissector_table*)g_hash_table_lookup( capture_dissector_tables, name );
+    if (sub_dissectors == NULL)
+    {
+        /* XXX - ASSERT? */
+        return FALSE;
+    }
+
+    handle = (struct capture_dissector_handle *)g_hash_table_lookup(sub_dissectors->hash_table, GUINT_TO_POINTER(pattern));
     if (handle == NULL)
-        return;
+        return FALSE;
 
-    handle->dissector(pd, offset, len, ld, pseudo_header);
+    return handle->dissector(pd, offset, len, ld, pseudo_header);
 }
 
 /*
diff --git a/epan/capture_dissectors.h b/epan/capture_dissectors.h
index f5313fabf9..7d8ab37855 100644
--- a/epan/capture_dissectors.h
+++ b/epan/capture_dissectors.h
@@ -33,14 +33,18 @@ extern "C" {
 /** @file
  */
 
-/** callback function definition: is a filter available for this packet? */
-typedef void (*capture_dissector_t)(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header);
+/** callback function definition for capture dissectors */
+typedef gboolean (*capture_dissector_t)(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header);
+
+/* a protocol uses the function to register a capture sub-dissector table
+ */
+WS_DLL_PUBLIC void register_capture_dissector_table(const char *name, const char *ui_name);
 
 
 /** Register a new capture dissector. */
-WS_DLL_PUBLIC void register_capture_dissector(gint linktype, capture_dissector_t dissector, const int proto);
+WS_DLL_PUBLIC void register_capture_dissector(const char* name, const guint32 pattern, capture_dissector_t dissector, const int proto);
 
-WS_DLL_PUBLIC void call_capture_dissector(gint linktype, const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header);
+WS_DLL_PUBLIC gboolean try_capture_dissector(const char* name, const guint32 pattern, const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header);
 
 extern void capture_dissector_init(void);
 extern void capture_dissector_cleanup(void);
diff --git a/epan/dissectors/Makefile.common b/epan/dissectors/Makefile.common
index 0dec2fa646..f378a5471c 100644
--- a/epan/dissectors/Makefile.common
+++ b/epan/dissectors/Makefile.common
@@ -1427,7 +1427,6 @@ DISSECTOR_INCLUDES =	\
 	packet-bfd.h	\
 	packet-bgp.h	\
 	packet-bluetooth.h	\
-	packet-bpq.h	\
 	packet-bssap.h	\
 	packet-bssgp.h	\
 	packet-btatt.h		\
@@ -1549,7 +1548,6 @@ DISSECTOR_INCLUDES =	\
 	packet-ieee80211-radiotap-iter.h	\
 	packet-ieee80211-radiotap-defs.h	\
 	packet-ieee802154.h	\
-	packet-ieee8021ah.h	\
 	packet-ieee8023.h	\
 	packet-ieee802a.h	\
 	packet-igmp.h	\
@@ -1729,7 +1727,6 @@ DISSECTOR_INCLUDES =	\
 	packet-usb.h	\
 	packet-usb-hid.h	\
 	packet-vines.h	\
-	packet-vlan.h	\
 	packet-wap.h	\
 	packet-wccp.h	\
 	packet-windows-common.h	\
diff --git a/epan/dissectors/packet-ap1394.c b/epan/dissectors/packet-ap1394.c
index 73f3d055e8..e2446255d9 100644
--- a/epan/dissectors/packet-ap1394.c
+++ b/epan/dissectors/packet-ap1394.c
@@ -43,14 +43,13 @@ static dissector_table_t ethertype_subdissector_table;
 
 static dissector_handle_t data_handle;
 
-static void
+static gboolean
 capture_ap1394(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
   guint16    etype;
 
   if (!BYTES_ARE_IN_FRAME(offset, len, 18)) {
-    ld->other++;
-    return;
+    return FALSE;
   }
 
   /* Skip destination and source addresses */
@@ -58,7 +57,7 @@ capture_ap1394(const guchar *pd, int offset, int len, packet_counts *ld, const u
 
   etype = pntoh16(&pd[offset]);
   offset += 2;
-  capture_ethertype(etype, pd, offset, len, ld, pseudo_header);
+  return try_capture_dissector("ethertype", etype, pd, offset, len, ld, pseudo_header);
 }
 
 static int
@@ -118,8 +117,6 @@ proto_register_ap1394(void)
   proto_ap1394 = proto_register_protocol("Apple IP-over-IEEE 1394", "IP/IEEE1394", "ap1394");
   proto_register_field_array(proto_ap1394, hf, array_length(hf));
   proto_register_subtree_array(ett, array_length(ett));
-
-  register_capture_dissector(WTAP_ENCAP_APPLE_IP_OVER_IEEE1394, capture_ap1394, proto_ap1394);
 }
 
 void
@@ -133,6 +130,7 @@ proto_reg_handoff_ap1394(void)
 
   ap1394_handle = create_dissector_handle(dissect_ap1394, proto_ap1394);
   dissector_add_uint("wtap_encap", WTAP_ENCAP_APPLE_IP_OVER_IEEE1394, ap1394_handle);
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_APPLE_IP_OVER_IEEE1394, capture_ap1394, proto_ap1394);
 }
 
 /*
diff --git a/epan/dissectors/packet-arcnet.c b/epan/dissectors/packet-arcnet.c
index 7622c4cddb..7749aee0e3 100644
--- a/epan/dissectors/packet-arcnet.c
+++ b/epan/dissectors/packet-arcnet.c
@@ -81,20 +81,18 @@ static int arcnet_len(void)
   return 1;
 }
 
-static void
+static gboolean
 capture_arcnet_common(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_, gboolean has_exception)
 {
   if (!BYTES_ARE_IN_FRAME(offset, len, 1)) {
-    ld->other++;
-    return;
+    return FALSE;
   }
 
   switch (pd[offset]) {
 
   case ARCNET_PROTO_IP_1051:
     /* No fragmentation stuff in the header */
-    capture_ip(pd, offset + 1, len, ld, pseudo_header);
-    break;
+    return capture_ip(pd, offset + 1, len, ld, pseudo_header);
 
   case ARCNET_PROTO_IP_1201:
     /*
@@ -125,8 +123,7 @@ capture_arcnet_common(const guchar *pd, int offset, int len, packet_counts *ld,
      */
     offset++;
     if (!BYTES_ARE_IN_FRAME(offset, len, 1)) {
-      ld->other++;
-      return;
+      return FALSE;
     }
     if (has_exception && pd[offset] == 0xff) {
       /* This is an exception packet.  The flag value there is the
@@ -135,8 +132,7 @@ capture_arcnet_common(const guchar *pd, int offset, int len, packet_counts *ld,
          type appears after the padding. */
       offset += 4;
     }
-    capture_ip(pd, offset + 3, len, ld, pseudo_header);
-    break;
+    return capture_ip(pd, offset + 3, len, ld, pseudo_header);
 
   case ARCNET_PROTO_ARP_1051:
   case ARCNET_PROTO_ARP_1201:
@@ -151,21 +147,22 @@ capture_arcnet_common(const guchar *pd, int offset, int len, packet_counts *ld,
     break;
 
   default:
-    ld->other++;
-    break;
+    return FALSE;
   }
+
+  return TRUE;
 }
 
-static void
+static gboolean
 capture_arcnet (const guchar *pd, int offset _U_, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
-  capture_arcnet_common(pd, 4, len, ld, pseudo_header, FALSE);
+  return capture_arcnet_common(pd, 4, len, ld, pseudo_header, FALSE);
 }
 
-static void
+static gboolean
 capture_arcnet_has_exception(const guchar *pd, int offset _U_, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
-  capture_arcnet_common(pd, 2, len, ld, pseudo_header, TRUE);
+  return capture_arcnet_common(pd, 2, len, ld, pseudo_header, TRUE);
 }
 
 static void
@@ -396,9 +393,6 @@ proto_register_arcnet (void)
   proto_register_field_array (proto_arcnet, hf, array_length (hf));
   proto_register_subtree_array (ett, array_length (ett));
 
-  register_capture_dissector(WTAP_ENCAP_ARCNET_LINUX, capture_arcnet, proto_arcnet);
-  register_capture_dissector(WTAP_ENCAP_ARCNET, capture_arcnet_has_exception, proto_arcnet);
-
   arcnet_address_type = address_type_dissector_register("AT_ARCNET", "ARCNET Address", arcnet_to_str, arcnet_str_len, arcnet_col_filter_str, arcnet_len, NULL, NULL);
 }
 
@@ -411,9 +405,11 @@ proto_reg_handoff_arcnet (void)
   arcnet_handle = create_dissector_handle (dissect_arcnet, proto_arcnet);
   dissector_add_uint ("wtap_encap", WTAP_ENCAP_ARCNET, arcnet_handle);
 
-  arcnet_linux_handle = create_dissector_handle (dissect_arcnet_linux,
-                                                 proto_arcnet);
+  arcnet_linux_handle = create_dissector_handle (dissect_arcnet_linux, proto_arcnet);
   dissector_add_uint ("wtap_encap", WTAP_ENCAP_ARCNET_LINUX, arcnet_linux_handle);
+
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_ARCNET_LINUX, capture_arcnet, proto_arcnet);
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_ARCNET, capture_arcnet_has_exception, proto_arcnet);
   data_handle = find_dissector ("data");
 }
 
diff --git a/epan/dissectors/packet-arp.c b/epan/dissectors/packet-arp.c
index c89621aafd..2df7ec2a8e 100644
--- a/epan/dissectors/packet-arp.c
+++ b/epan/dissectors/packet-arp.c
@@ -26,6 +26,7 @@
 #include "config.h"
 
 #include <epan/packet.h>
+#include <epan/capture_dissectors.h>
 #include <epan/arptypes.h>
 #include <epan/addr_resolv.h>
 #include "packet-arp.h"
@@ -1358,6 +1359,13 @@ dissect_ax25arp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data
   return tvb_captured_length(tvb);
 }
 
+gboolean
+capture_arp(const guchar *pd _U_, int offset _U_, int len _U_, packet_counts *ld _U_, const union wtap_pseudo_header *pseudo_header _U_)
+{
+  ld->arp++;
+  return TRUE;
+}
+
 static const guint8 mac_allzero[6] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
 
 static int
@@ -2013,6 +2021,7 @@ proto_reg_handoff_arp(void)
   dissector_add_uint("arcnet.protocol_id", ARCNET_PROTO_ARP_1201, arp_handle);
   dissector_add_uint("arcnet.protocol_id", ARCNET_PROTO_RARP_1201, arp_handle);
   dissector_add_uint("ax25.pid", AX25_P_ARP, arp_handle);
+  register_capture_dissector("ethertype", ETHERTYPE_ARP, capture_arp, proto_arp);
 }
 
 /*
diff --git a/epan/dissectors/packet-atalk.c b/epan/dissectors/packet-atalk.c
index efe84ca76c..3255b09d2d 100644
--- a/epan/dissectors/packet-atalk.c
+++ b/epan/dissectors/packet-atalk.c
@@ -1580,10 +1580,12 @@ static const value_string llap_type_vals[] = {
 };
 static value_string_ext llap_type_vals_ext = VALUE_STRING_EXT_INIT(llap_type_vals);
 
-static void
-capture_llap(const guchar *pd _U_, int offset _U_, int len _U_, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
+static gboolean
+capture_llap(const guchar *pd _U_, int offset _U_, int len _U_, packet_counts *ld _U_, const union wtap_pseudo_header *pseudo_header _U_)
 {
-  ld->other++;
+  /* XXX - get its own counter
+  ld->other++; */
+  return FALSE;
 }
 
 static int
@@ -2066,8 +2068,6 @@ proto_register_atalk(void)
   proto_zip = proto_register_protocol("Zone Information Protocol", "ZIP", "zip");
   proto_register_field_array(proto_zip, hf_zip, array_length(hf_zip));
 
-  register_capture_dissector(WTAP_ENCAP_LOCALTALK, capture_llap, proto_llap);
-
   atp_module = prefs_register_protocol(proto_atp, NULL);
   prefs_register_bool_preference(atp_module, "desegment",
     "Reassemble ATP messages spanning multiple DDP packets",
@@ -2125,6 +2125,7 @@ proto_reg_handoff_atalk(void)
 
   llap_handle = create_dissector_handle(dissect_llap, proto_llap);
   dissector_add_uint("wtap_encap", WTAP_ENCAP_LOCALTALK, llap_handle);
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_LOCALTALK, capture_llap, proto_llap);
 
   register_init_routine( atp_init);
   register_cleanup_routine( atp_cleanup);
diff --git a/epan/dissectors/packet-atm.c b/epan/dissectors/packet-atm.c
index dba720bc95..ece373ceff 100644
--- a/epan/dissectors/packet-atm.c
+++ b/epan/dissectors/packet-atm.c
@@ -663,7 +663,7 @@ dissect_le_control(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
   }
 }
 
-static void
+static gboolean
 capture_lane(const guchar *pd, int offset _U_,
     int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header)
 {
@@ -673,19 +673,15 @@ capture_lane(const guchar *pd, int offset _U_,
   case TRAF_ST_LANE_802_3:
   case TRAF_ST_LANE_802_3_MC:
     /* Dissect as Ethernet */
-    capture_eth(pd, 2, len, ld, pseudo_header);
-    break;
+    return capture_eth(pd, 2, len, ld, pseudo_header);
 
   case TRAF_ST_LANE_802_5:
   case TRAF_ST_LANE_802_5_MC:
     /* Dissect as Token-Ring */
-    capture_tr(pd, 2, len, ld, pseudo_header);
-    break;
-
-  default:
-    ld->other++;
-    break;
+    return capture_tr(pd, 2, len, ld, pseudo_header);
   }
+
+  return FALSE;
 }
 
 static int
@@ -805,7 +801,7 @@ static const value_string ipsilon_type_vals[] = {
   { 0,                NULL }
 };
 
-static void
+static gboolean
 capture_atm(const guchar *pd, int offset _U_,
     int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header)
 {
@@ -816,19 +812,13 @@ capture_atm(const guchar *pd, int offset _U_,
       /* Dissect as WTAP_ENCAP_ATM_RFC1483 */
       /* The ATM iptrace capture that we have shows LLC at this point,
        * so that's what I'm calling */
-      capture_llc(pd, 0, len, ld, pseudo_header);
-      break;
+      return capture_llc(pd, 0, len, ld, pseudo_header);
 
     case TRAF_LANE:
-      capture_lane(pd, offset, len, ld, pseudo_header);
-      break;
-
-    default:
-      ld->other++;
-      break;
+      return capture_lane(pd, offset, len, ld, pseudo_header);
     }
-  } else
-    ld->other++;
+  }
+  return FALSE;
 }
 
 static void
@@ -2008,8 +1998,6 @@ proto_register_atm(void)
   register_dissector("atm_oam_cell", dissect_atm_oam_cell, proto_oamaal);
   register_dissector("atm_pw_oam_cell", dissect_atm_pw_oam_cell, proto_oamaal);
 
-  register_capture_dissector(WTAP_ENCAP_ATM_PDUS, capture_atm, proto_atm);
-
   atm_module = prefs_register_protocol ( proto_atm, NULL );
   prefs_register_bool_preference(atm_module, "dissect_lane_as_sscop", "Dissect LANE as SSCOP",
                                  "Autodection between LANE and SSCOP is hard. As default LANE is preferred",
@@ -2044,6 +2032,7 @@ proto_reg_handoff_atm(void)
 
   dissector_add_uint("wtap_encap", WTAP_ENCAP_ATM_PDUS_UNTRUNCATED,
                 atm_untruncated_handle);
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_ATM_PDUS, capture_atm, proto_atm);
 }
 
 /*
diff --git a/epan/dissectors/packet-ax25-kiss.c b/epan/dissectors/packet-ax25-kiss.c
index e355bd15d0..aa5a26f808 100644
--- a/epan/dissectors/packet-ax25-kiss.c
+++ b/epan/dissectors/packet-ax25-kiss.c
@@ -178,35 +178,36 @@ static const value_string kiss_frame_types[] = {
 	{ 0, NULL }
 };
 
-static void
+static gboolean
 capture_ax25_kiss( const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
 	int    l_offset;
 	guint8 kiss_cmd;
 
 	if ( ! BYTES_ARE_IN_FRAME( offset, len, KISS_HEADER_SIZE ) )
-		{
-		ld->other++;
-		return;
-		}
+		return FALSE;
 
 	l_offset  = offset;
 	kiss_cmd  = pd[ l_offset ];
 	l_offset += KISS_HEADER_SIZE; /* step over kiss header */
 	switch ( kiss_cmd & KISS_CMD_MASK )
-		{
-		case KISS_DATA_FRAME	: capture_ax25( pd, l_offset, len, ld, pseudo_header ); break;
+	{
+		case KISS_DATA_FRAME	:
+			return capture_ax25( pd, l_offset, len, ld, pseudo_header );
 		case KISS_TXDELAY	: break;
 		case KISS_PERSISTENCE	: break;
 		case KISS_SLOT_TIME	: break;
 		case KISS_TXTAIL	: break;
 		case KISS_FULLDUPLEX	: break;
 		case KISS_SETHARDWARE	: break;
-		case KISS_DATA_FRAME_ACK: l_offset += 2; capture_ax25( pd, l_offset, len, ld, pseudo_header ); break;
+		case KISS_DATA_FRAME_ACK:
+			l_offset += 2;
+			return capture_ax25( pd, l_offset, len, ld, pseudo_header );
 		case KISS_POLL_MODE	: break;
 		case KISS_RETURN	: break;
 		default			: break;
-		}
+	}
+	return FALSE;
 }
 
 /* Code to actually dissect the packets */
@@ -432,8 +433,6 @@ proto_register_ax25_kiss(void)
 	proto_register_field_array( proto_ax25_kiss, hf, array_length( hf ) );
 	proto_register_subtree_array( ett, array_length( ett ) );
 
-	register_capture_dissector(WTAP_ENCAP_AX25_KISS, capture_ax25_kiss, proto_ax25_kiss);
-
 	/* Register preferences module */
 	ax25_kiss_module = prefs_register_protocol( proto_ax25_kiss, NULL);
 
@@ -448,6 +447,7 @@ void
 proto_reg_handoff_ax25_kiss(void)
 {
 	dissector_add_uint( "wtap_encap", WTAP_ENCAP_AX25_KISS, kiss_handle );
+	register_capture_dissector("wtap_encap", WTAP_ENCAP_AX25_KISS, capture_ax25_kiss, proto_ax25_kiss);
 
 	/* only currently implemented for AX.25 */
 	ax25_handle = find_dissector( "ax25" );
diff --git a/epan/dissectors/packet-ax25.c b/epan/dissectors/packet-ax25.c
index 1539379ac7..03d28b09f3 100644
--- a/epan/dissectors/packet-ax25.c
+++ b/epan/dissectors/packet-ax25.c
@@ -254,7 +254,7 @@ dissect_ax25( tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void*
 	return tvb_captured_length(tvb);
 }
 
-void
+gboolean
 capture_ax25( const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
 	guint8 control;
@@ -262,10 +262,7 @@ capture_ax25( const guchar *pd, int offset, int len, packet_counts *ld, const un
 	int l_offset;
 
 	if ( ! BYTES_ARE_IN_FRAME( offset, len, AX25_HEADER_SIZE ) )
-		{
-		ld->other++;
-		return;
-		}
+		return FALSE;
 
 	l_offset = offset;
 	l_offset += AX25_ADDR_LEN; /* step over dst addr point at src addr */
@@ -277,7 +274,7 @@ capture_ax25( const guchar *pd, int offset, int len, packet_counts *ld, const un
 
 	/* decode the pid field (if appropriate) */
 	if ( XDLC_IS_INFORMATION( control ) )
-		{
+	{
 		l_offset += 1; /* step over control byte point at pid */
 		pid = pd[ l_offset ];
 
@@ -285,19 +282,15 @@ capture_ax25( const guchar *pd, int offset, int len, packet_counts *ld, const un
 		switch ( pid & 0x0ff )
 			{
 			case AX25_P_NETROM	:
-				capture_netrom( pd, l_offset, len, ld, pseudo_header );
-				break;
+				return capture_netrom( pd, l_offset, len, ld, pseudo_header );
 			case AX25_P_IP		:
-				capture_ip( pd, l_offset, len, ld, pseudo_header );
-				break;
+				return capture_ip( pd, l_offset, len, ld, pseudo_header );
 			case AX25_P_ARP		:
 				ld->arp++;
-				break;
-			default			:
-				ld->other++;
-				break;
+				return TRUE;
 			}
-		}
+	}
+	return FALSE;
 }
 
 void
@@ -435,8 +428,6 @@ proto_register_ax25(void)
 	proto_register_field_array( proto_ax25, hf, array_length(hf ) );
 	proto_register_subtree_array(ett, array_length(ett ) );
 
-	register_capture_dissector(WTAP_ENCAP_AX25, capture_ax25, proto_ax25);
-
 	/* Register dissector table for protocol IDs */
 	ax25_dissector_table = register_dissector_table("ax25.pid", "AX.25 protocol ID", FT_UINT8, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE);
 }
@@ -447,6 +438,8 @@ proto_reg_handoff_ax25(void)
 	dissector_add_uint("wtap_encap", WTAP_ENCAP_AX25, ax25_handle);
 	dissector_add_uint("ip.proto", IP_PROTO_AX25, ax25_handle);
 
+	register_capture_dissector("wtap_encap", WTAP_ENCAP_AX25, capture_ax25, proto_ax25);
+
 	data_handle  = find_dissector( "data" );
 
 }
diff --git a/epan/dissectors/packet-ax25.h b/epan/dissectors/packet-ax25.h
index eb99711428..8f92f7df1b 100644
--- a/epan/dissectors/packet-ax25.h
+++ b/epan/dissectors/packet-ax25.h
@@ -26,6 +26,6 @@
 #define __PACKET_AX25_H__
 
 extern
-void capture_ax25(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_ax25(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
 
 #endif
diff --git a/epan/dissectors/packet-bpq.c b/epan/dissectors/packet-bpq.c
index f6b127338e..5c6fb1ff97 100644
--- a/epan/dissectors/packet-bpq.c
+++ b/epan/dissectors/packet-bpq.c
@@ -37,8 +37,8 @@
 
 #include <epan/packet.h>
 #include <epan/etypes.h>
+#include <epan/capture_dissectors.h>
 
-#include "packet-bpq.h"
 #include "packet-ax25.h"
 
 #define STRLEN	80
@@ -101,20 +101,17 @@ dissect_bpq( tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void* d
 	return tvb_captured_length(tvb);
 }
 
-void
+static gboolean
 capture_bpq( const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
 	int l_offset;
 
 	if ( ! BYTES_ARE_IN_FRAME( offset, len, BPQ_HEADER_SIZE ) )
-		{
-		ld->other++;
-		return;
-		}
+		return FALSE;
 
 	l_offset = offset;
 	l_offset += BPQ_HEADER_SIZE; /* step over bpq header to point at the AX.25 packet*/
-	capture_ax25( pd, l_offset, len, ld, pseudo_header );
+	return capture_ax25( pd, l_offset, len, ld, pseudo_header );
 }
 
 void
@@ -152,6 +149,7 @@ proto_reg_handoff_bpq(void)
 
 	bpq_handle = create_dissector_handle( dissect_bpq, proto_bpq );
 	dissector_add_uint("ethertype", ETHERTYPE_BPQ, bpq_handle);
+	register_capture_dissector("ethertype", ETHERTYPE_BPQ, capture_bpq, proto_bpq);
 
 	/* BPQ is only implemented for AX.25 */
 	ax25_handle     = find_dissector( "ax25" );
diff --git a/epan/dissectors/packet-bpq.h b/epan/dissectors/packet-bpq.h
deleted file mode 100644
index e0d7055cd9..0000000000
--- a/epan/dissectors/packet-bpq.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/* packet-bpq.h
- *
- * Routines for Amateur Packet Radio protocol dissection
- * Copyright 2005,2006,2007,2008,2009,2010,2012 R.W. Stearn <richard@rns-stearn.demon.co.uk>
- *
- * Wireshark - Network traffic analyzer
- * By Gerald Combs <gerald@wireshark.org>
- * Copyright 1998 Gerald Combs
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#ifndef __PACKET_BPQ_H__
-#define __PACKET_BPQ_H__
-
-void capture_bpq(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
-
-#endif
diff --git a/epan/dissectors/packet-chdlc.c b/epan/dissectors/packet-chdlc.c
index 3706b44d80..d125552dca 100644
--- a/epan/dissectors/packet-chdlc.c
+++ b/epan/dissectors/packet-chdlc.c
@@ -113,20 +113,17 @@ const value_string chdlc_vals[] = {
   {0,                     NULL}
 };
 
-void
+gboolean
 capture_chdlc( const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_ ) {
-  if (!BYTES_ARE_IN_FRAME(offset, len, 4)) {
-    ld->other++;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(offset, len, 4))
+    return FALSE;
+
   switch (pntoh16(&pd[offset + 2])) {
     case ETHERTYPE_IP:
-      capture_ip(pd, offset + 4, len, ld, pseudo_header);
-      break;
-    default:
-      ld->other++;
-      break;
+      return capture_ip(pd, offset + 4, len, ld, pseudo_header);
   }
+
+  return FALSE;
 }
 
 void
@@ -233,8 +230,6 @@ proto_register_chdlc(void)
   proto_register_field_array(proto_chdlc, hf, array_length(hf));
   proto_register_subtree_array(ett, array_length(ett));
 
-  register_capture_dissector(WTAP_ENCAP_CHDLC, capture_chdlc, proto_chdlc);
-
   /* subdissector code */
   subdissector_table = register_dissector_table("chdlc.protocol",
                                                 "Cisco HDLC protocol",
@@ -265,6 +260,8 @@ proto_reg_handoff_chdlc(void)
   dissector_add_uint("wtap_encap", WTAP_ENCAP_CHDLC_WITH_PHDR, chdlc_handle);
   dissector_add_uint("juniper.proto", JUNIPER_PROTO_CHDLC, chdlc_handle);
   dissector_add_uint("l2tp.pw_type", L2TPv3_PROTOCOL_CHDLC, chdlc_handle);
+
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_CHDLC, capture_chdlc, proto_chdlc);
 }
 
 
diff --git a/epan/dissectors/packet-chdlc.h b/epan/dissectors/packet-chdlc.h
index be7f96995c..4cbd7ef4e6 100644
--- a/epan/dissectors/packet-chdlc.h
+++ b/epan/dissectors/packet-chdlc.h
@@ -32,7 +32,7 @@
 #define CHDLC_ADDR_MULTICAST	0x8f
 
 extern
-void capture_chdlc(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_chdlc(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
 
 extern const value_string chdlc_vals[];
 
diff --git a/epan/dissectors/packet-clip.c b/epan/dissectors/packet-clip.c
index 60528c12fa..634ff224b0 100644
--- a/epan/dissectors/packet-clip.c
+++ b/epan/dissectors/packet-clip.c
@@ -43,10 +43,10 @@ static expert_field ei_no_link_info = EI_INIT;
 
 static dissector_handle_t ip_handle;
 
-static void
+static gboolean
 capture_clip( const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_ ) {
 
-    capture_ip(pd, offset, len, ld, pseudo_header);
+    return capture_ip(pd, offset, len, ld, pseudo_header);
 }
 
 static int
@@ -109,8 +109,6 @@ proto_register_clip(void)
   proto_register_subtree_array(ett, array_length(ett));
   expert_clip = expert_register_protocol(proto_clip);
   expert_register_field_array(expert_clip, ei, array_length(ei));
-
-  register_capture_dissector(WTAP_ENCAP_LINUX_ATM_CLIP, capture_clip, proto_clip);
 }
 
 void
@@ -126,6 +124,8 @@ proto_reg_handoff_clip(void)
   clip_handle = create_dissector_handle(dissect_clip, proto_clip);
       /* XXX - no protocol, can't be disabled */
   dissector_add_uint("wtap_encap", WTAP_ENCAP_LINUX_ATM_CLIP, clip_handle);
+
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_LINUX_ATM_CLIP, capture_clip, proto_clip);
 }
 
 /*
diff --git a/epan/dissectors/packet-enc.c b/epan/dissectors/packet-enc.c
index 327f68db61..029fd2baad 100644
--- a/epan/dissectors/packet-enc.c
+++ b/epan/dissectors/packet-enc.c
@@ -65,31 +65,25 @@ static int hf_enc_flags = -1;
 
 static gint ett_enc = -1;
 
-static void
+static gboolean
 capture_enc(const guchar *pd, int offset _U_, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
   guint32 af;
 
-  if (!BYTES_ARE_IN_FRAME(0, len, (int)BSD_ENC_HDRLEN)) {
-    ld->other++;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(0, len, (int)BSD_ENC_HDRLEN))
+    return FALSE;
 
   af = pntoh32(pd + offsetof(struct enchdr, af));
   switch (af) {
 
   case BSD_AF_INET:
-    capture_ip(pd, BSD_ENC_HDRLEN, len, ld, pseudo_header);
-    break;
+    return capture_ip(pd, BSD_ENC_HDRLEN, len, ld, pseudo_header);
 
   case BSD_AF_INET6_BSD:
-    capture_ipv6(pd, BSD_ENC_HDRLEN, len, ld, pseudo_header);
-    break;
-
-  default:
-    ld->other++;
-    break;
+    return capture_ipv6(pd, BSD_ENC_HDRLEN, len, ld, pseudo_header);
   }
+
+  return FALSE;
 }
 
 static const value_string af_vals[] = {
@@ -181,8 +175,6 @@ proto_register_enc(void)
                                       "ENC", "enc");
   proto_register_field_array(proto_enc, hf, array_length(hf));
   proto_register_subtree_array(ett, array_length(ett));
-
-  register_capture_dissector(WTAP_ENCAP_ENC, capture_enc, proto_enc);
 }
 
 void
@@ -196,6 +188,8 @@ proto_reg_handoff_enc(void)
 
   enc_handle  = create_dissector_handle(dissect_enc, proto_enc);
   dissector_add_uint("wtap_encap", WTAP_ENCAP_ENC, enc_handle);
+
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_ENC, capture_enc, proto_enc);
 }
 
 /*
diff --git a/epan/dissectors/packet-eth.c b/epan/dissectors/packet-eth.c
index 6b0be85f56..390bb0b783 100644
--- a/epan/dissectors/packet-eth.c
+++ b/epan/dissectors/packet-eth.c
@@ -191,16 +191,14 @@ eth_build_filter(packet_info *pinfo)
 #define ETHERNET_802_3  2
 #define ETHERNET_SNAP   3
 
-void
+gboolean
 capture_eth(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
   guint16 etype, length;
   int ethhdr_type;          /* the type of ethernet frame */
 
-  if (!BYTES_ARE_IN_FRAME(offset, len, ETH_HEADER_SIZE)) {
-    ld->other++;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(offset, len, ETH_HEADER_SIZE))
+    return FALSE;
 
   etype = pntoh16(&pd[offset+12]);
 
@@ -212,8 +210,7 @@ capture_eth(const guchar *pd, int offset, int len, packet_counts *ld, const unio
     if ((pd[offset] == 0x01 || pd[offset] == 0x0C) && pd[offset+1] == 0x00
         && pd[offset+2] == 0x0C && pd[offset+3] == 0x00
         && pd[offset+4] == 0x00) {
-      capture_isl(pd, offset, len, ld, pseudo_header);
-      return;
+      return capture_isl(pd, offset, len, ld, pseudo_header);
     }
   }
 
@@ -236,10 +233,8 @@ capture_eth(const guchar *pd, int offset, int len, packet_counts *ld, const unio
    * frame; the dissector for those frames registers itself with
    * an ethernet type of ETHERTYPE_UNK.
    */
-  if (etype > IEEE_802_3_MAX_LEN && etype < ETHERNET_II_MIN_LEN) {
-    ld->other++;
-    return;
-  }
+  if (etype > IEEE_802_3_MAX_LEN && etype < ETHERNET_II_MIN_LEN)
+    return FALSE;
 
   if (etype <= IEEE_802_3_MAX_LEN && etype != ETHERTYPE_UNK) {
     length = etype;
@@ -272,15 +267,14 @@ capture_eth(const guchar *pd, int offset, int len, packet_counts *ld, const unio
 
   switch (ethhdr_type) {
     case ETHERNET_802_3:
-      capture_ipx(pd, offset, len, ld, pseudo_header);
-      break;
+      return capture_ipx(pd, offset, len, ld, pseudo_header);
     case ETHERNET_802_2:
-      capture_llc(pd, offset, len, ld, pseudo_header);
-      break;
+      return capture_llc(pd, offset, len, ld, pseudo_header);
     case ETHERNET_II:
-      capture_ethertype(etype, pd, offset, len, ld, pseudo_header);
-      break;
+      return try_capture_dissector("ethertype", etype, pd, offset, len, ld, pseudo_header);
   }
+
+  return FALSE;
 }
 
 static gboolean check_is_802_2(tvbuff_t *tvb, int fcs_len);
@@ -1014,7 +1008,6 @@ proto_register_eth(void)
   register_dissector("eth_withoutfcs", dissect_eth_withoutfcs, proto_eth);
   register_dissector("eth_withfcs", dissect_eth_withfcs, proto_eth);
   register_dissector("eth", dissect_eth_maybefcs, proto_eth);
-  register_capture_dissector(WTAP_ENCAP_ETHERNET, capture_eth, proto_eth);
   eth_tap = register_tap("eth");
 
   register_conversation_table(proto_eth, TRUE, eth_conversation_packet, eth_hostlist_packet);
@@ -1057,6 +1050,8 @@ proto_reg_handoff_eth(void)
   dissector_add_for_decode_as("udp.port", eth_withoutfcs_handle);
 
   dissector_add_for_decode_as("pcli.payload", eth_withoutfcs_handle);
+
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_ETHERNET, capture_eth, proto_eth);
 }
 
 /*
diff --git a/epan/dissectors/packet-eth.h b/epan/dissectors/packet-eth.h
index 2d42ecf2f5..ac1d66fdd0 100644
--- a/epan/dissectors/packet-eth.h
+++ b/epan/dissectors/packet-eth.h
@@ -29,7 +29,7 @@ typedef struct _eth_hdr {
 } eth_hdr;
 
 extern
-void capture_eth(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_eth(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
 
 void add_ethernet_trailer(packet_info *pinfo, proto_tree *tree, proto_tree *fh_tree,
 			  int trailer_id, tvbuff_t *tvb, tvbuff_t *trailer_tvb,
diff --git a/epan/dissectors/packet-ethertype.c b/epan/dissectors/packet-ethertype.c
index 72ddce9ea6..88bbcaceee 100644
--- a/epan/dissectors/packet-ethertype.c
+++ b/epan/dissectors/packet-ethertype.c
@@ -32,16 +32,8 @@
 #include <epan/ppptypes.h>
 #include <epan/show_exception.h>
 #include <epan/decode_as.h>
-#include "packet-bpq.h"
+#include <epan/capture_dissectors.h>
 #include "packet-eth.h"
-#include "packet-ip.h"
-#include "packet-ipv6.h"
-#include "packet-ipx.h"
-#include "packet-vlan.h"
-#include "packet-ieee8021ah.h"
-#include "packet-vines.h"
-#include "packet-llc.h"
-
 
 void proto_register_ethertype(void);
 void proto_reg_handoff_ethertype(void);
@@ -204,46 +196,6 @@ static void add_dix_trailer(packet_info *pinfo, proto_tree *tree, proto_tree *fh
 			    int trailer_id, tvbuff_t *tvb, tvbuff_t *next_tvb, int offset_after_etype,
 			    guint length_before, gint fcs_len);
 
-void
-capture_ethertype(guint16 etype, const guchar *pd, int offset, int len,
-		  packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
-{
-	switch (etype) {
-	case ETHERTYPE_ARP:
-		ld->arp++;
-		break;
-	case ETHERTYPE_IP:
-		capture_ip(pd, offset, len, ld, pseudo_header);
-		break;
-	case ETHERTYPE_IPv6:
-		capture_ipv6(pd, offset, len, ld, pseudo_header);
-		break;
-	case ETHERTYPE_IPX:
-		capture_ipx(pd, offset, len, ld, pseudo_header);
-		break;
-	case ETHERTYPE_VLAN:
-		capture_vlan(pd, offset, len, ld, pseudo_header);
-		break;
-	case ETHERTYPE_IEEE_802_1AD:
-	case ETHERTYPE_IEEE_802_1AH:
-		capture_ieee8021ah(pd, offset, len, ld, pseudo_header);
-		break;
-	case ETHERTYPE_VINES_IP:
-	case ETHERTYPE_VINES_ECHO:
-		capture_vines(pd, offset, len, ld, pseudo_header);
-		break;
-	case ETHERTYPE_BPQ:
-		capture_bpq(pd, offset, len, ld, pseudo_header);
-		break;
-	case ETHERTYPE_JUMBO_LLC:
-		capture_llc(pd, offset, len, ld, pseudo_header);
-		break;
-	default:
-		ld->other++;
-		break;
-	}
-}
-
 /*
 void
 ethertype(guint16 etype, tvbuff_t *tvb, int offset_after_etype,
@@ -400,6 +352,7 @@ proto_register_ethertype(void)
 	/* subdissector code */
 	ethertype_dissector_table = register_dissector_table("ethertype",
 								"Ethertype", FT_UINT16, BASE_HEX, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE);
+	register_capture_dissector_table("ethertype", "Ethertype");
 
 	register_decode_as(&ethertype_da);
 }
diff --git a/epan/dissectors/packet-fddi.c b/epan/dissectors/packet-fddi.c
index afb6b92535..cd28e8ec1e 100644
--- a/epan/dissectors/packet-fddi.c
+++ b/epan/dissectors/packet-fddi.c
@@ -199,15 +199,14 @@ fddi_hostlist_packet(void *pit, packet_info *pinfo, epan_dissect_t *edt _U_, con
   return 1;
 }
 
-static void
+static gboolean
 capture_fddi(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
   int fc;
 
-  if (!BYTES_ARE_IN_FRAME(0, len, FDDI_HEADER_SIZE + FDDI_PADDING)) {
-    ld->other++;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(0, len, FDDI_HEADER_SIZE + FDDI_PADDING))
+    return FALSE;
+
   offset = FDDI_PADDING + FDDI_HEADER_SIZE;
 
   fc = (int) pd[FDDI_P_FC+FDDI_PADDING];
@@ -232,14 +231,10 @@ capture_fddi(const guchar *pd, int offset, int len, packet_counts *ld, const uni
     case FDDI_FC_LLC_ASYNC + 13 :
     case FDDI_FC_LLC_ASYNC + 14 :
     case FDDI_FC_LLC_ASYNC + 15 :
-      capture_llc(pd, offset, len, ld, pseudo_header);
-      return;
-    default :
-      ld->other++;
-      return;
-
+      return capture_llc(pd, offset, len, ld, pseudo_header);
   } /* fc */
 
+  return FALSE;
 } /* capture_fddi */
 
 static const gchar *
@@ -519,9 +514,6 @@ proto_register_fddi(void)
    */
   register_dissector("fddi", dissect_fddi_not_bitswapped, proto_fddi);
 
-  register_capture_dissector(WTAP_ENCAP_FDDI, capture_fddi, proto_fddi);
-  register_capture_dissector(WTAP_ENCAP_FDDI_BITSWAPPED, capture_fddi, proto_fddi);
-
   fddi_module = prefs_register_protocol(proto_fddi, NULL);
   prefs_register_bool_preference(fddi_module, "padding",
                                  "Add 3-byte padding to all FDDI packets",
@@ -552,6 +544,9 @@ proto_reg_handoff_fddi(void)
     create_dissector_handle(dissect_fddi_bitswapped, proto_fddi);
   dissector_add_uint("wtap_encap", WTAP_ENCAP_FDDI_BITSWAPPED,
                      fddi_bitswapped_handle);
+
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_FDDI, capture_fddi, proto_fddi);
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_FDDI_BITSWAPPED, capture_fddi, proto_fddi);
 }
 
 /*
diff --git a/epan/dissectors/packet-fr.c b/epan/dissectors/packet-fr.c
index bc3d18b945..139bd78221 100644
--- a/epan/dissectors/packet-fr.c
+++ b/epan/dissectors/packet-fr.c
@@ -206,7 +206,7 @@ static const xdlc_cf_items fr_cf_items_ext = {
   &hf_fr_ftype_s_u_ext
 };
 
-void
+static gboolean
 capture_fr(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
   guint8  fr_octet;
@@ -217,10 +217,9 @@ capture_fr(const guchar *pd, int offset, int len, packet_counts *ld, const union
   /*
    * OK, fetch the address field - keep going until we get an EA bit.
    */
-  if (!BYTES_ARE_IN_FRAME(offset, len, 1)) {
-    ld->other++;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(offset, len, 1))
+    return FALSE;
+
   fr_octet = pd[offset];
   if (fr_octet & FRELAY_EA) {
     /*
@@ -228,8 +227,7 @@ capture_fr(const guchar *pd, int offset, int len, packet_counts *ld, const union
      * XXX - is this FRF.12 frame relay fragmentation?  If so, can
      * we handle that?
      */
-    ld->other++;
-    return;
+     return FALSE;
   }
   /*
    * The first octet contains the upper 6 bits of the DLCI, as well
@@ -242,10 +240,9 @@ capture_fr(const guchar *pd, int offset, int len, packet_counts *ld, const union
    * The second octet contains 4 more bits of DLCI, as well as FECN,
    * BECN, and DE.
    */
-  if (!BYTES_ARE_IN_FRAME(offset, len, 1)) {
-    ld->other++;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(offset, len, 1))
+    return FALSE;
+
   fr_octet = pd[offset];
   addr = (addr << 4) | ((fr_octet & FRELAY_SECOND_DLCI) >> 4);
   offset++;
@@ -258,10 +255,9 @@ capture_fr(const guchar *pd, int offset, int len, packet_counts *ld, const union
      * and lower DLCI or DL-CORE control plus the DLCI or DL-CORE
      * control indicator flag if EA is set.
      */
-    if (!BYTES_ARE_IN_FRAME(offset, len, 1)) {
-      ld->other++;
-      return;
-    }
+    if (!BYTES_ARE_IN_FRAME(offset, len, 1))
+      return FALSE;
+
     fr_octet = pd[offset];
     if (!(fr_octet & FRELAY_EA)) {
       /*
@@ -269,20 +265,18 @@ capture_fr(const guchar *pd, int offset, int len, packet_counts *ld, const union
        */
       addr = (addr << 7) | ((fr_octet & FRELAY_THIRD_DLCI) >> 1);
       offset++;
-      if (!BYTES_ARE_IN_FRAME(offset, len, 1)) {
-        ld->other++;
-        return;
-      }
+      if (!BYTES_ARE_IN_FRAME(offset, len, 1))
+        return FALSE;
+
       fr_octet = pd[offset];
       while (!(fr_octet & FRELAY_EA)) {
         /*
          * Bogus!  More than 4 octets of address.
          */
         offset++;
-        if (!BYTES_ARE_IN_FRAME(offset, len, 1)) {
-          ld->other++;
-          return;
-        }
+        if (!BYTES_ARE_IN_FRAME(offset, len, 1))
+          return FALSE;
+
         fr_octet = pd[offset];
       }
     }
@@ -306,10 +300,9 @@ capture_fr(const guchar *pd, int offset, int len, packet_counts *ld, const union
   switch (fr_encap) {
 
   case FRF_3_2:
-    if (!BYTES_ARE_IN_FRAME(offset, len, 1)) {
-      ld->other++;
-      return;
-    }
+    if (!BYTES_ARE_IN_FRAME(offset, len, 1))
+      return FALSE;
+
     fr_ctrl = pd[offset];
     if (fr_ctrl == XDLC_U) {
       offset++;
@@ -320,41 +313,34 @@ capture_fr(const guchar *pd, int offset, int len, packet_counts *ld, const union
        * protocols which do not have an NLPID assigned or do not
        * have a SNAP encapsulation" stuff from RFC 2427.
        */
-      if (!BYTES_ARE_IN_FRAME(offset, len, 1)) {
-        ld->other++;
-        return;
-      }
+      if (!BYTES_ARE_IN_FRAME(offset, len, 1))
+        return FALSE;
+
       fr_nlpid = pd[offset];
       if (fr_nlpid == 0) {
         offset++;
-        if (!BYTES_ARE_IN_FRAME(offset, len, 1)) {
-          ld->other++;
-          return;
-        }
+        if (!BYTES_ARE_IN_FRAME(offset, len, 1))
+          return FALSE;
+
         fr_nlpid = pd[offset];
       }
       offset++;
       switch (fr_nlpid) {
 
       case NLPID_IP:
-        capture_ip(pd, offset, len, ld, pseudo_header);
-        break;
+        return capture_ip(pd, offset, len, ld, pseudo_header);
 
       case NLPID_IP6:
-        capture_ipv6(pd, offset, len, ld, pseudo_header);
-        break;
+        return capture_ipv6(pd, offset, len, ld, pseudo_header);
 
       case NLPID_PPP:
-        capture_ppp_hdlc(pd, offset, len, ld, pseudo_header);
-        break;
+        return capture_ppp_hdlc(pd, offset, len, ld, pseudo_header);
 
       case NLPID_SNAP:
-        capture_snap(pd, offset, len, ld, pseudo_header);
-        break;
+        return capture_snap(pd, offset, len, ld, pseudo_header);
 
       default:
-        ld->other++;
-        break;
+        return FALSE;
       }
     } else {
       if (addr == 0) {
@@ -368,36 +354,34 @@ capture_fr(const guchar *pd, int offset, int len, packet_counts *ld, const union
          * XXX - but what is it?  Is Q.933 carried inside UI
          * frames or other types of frames or both?
          */
-        ld->other++;
-        return;
+        return FALSE;
       }
       if (fr_ctrl == (XDLC_U|XDLC_XID)) {
         /*
          * XID.
          */
-        ld->other++;
-        return;
+        return FALSE;
       }
 
       /*
        * If the data does not start with unnumbered information (03) and
        * the DLCI# is not 0, then there may be Cisco Frame Relay encapsulation.
        */
-      capture_chdlc(pd, offset, len, ld, pseudo_header);
+      return capture_chdlc(pd, offset, len, ld, pseudo_header);
     }
     break;
 
   case GPRS_NS:
-    ld->other++;
-    break;
+    return FALSE;
 
   case RAW_ETHER:
     if (addr != 0)
-      capture_eth(pd, offset, len, ld, pseudo_header);
-    else
-      ld->other++;
-    break;
+      return capture_eth(pd, offset, len, ld, pseudo_header);
+
+    return FALSE;
   }
+
+  return FALSE;
 }
 
 static void
@@ -988,8 +972,6 @@ proto_register_fr(void)
   register_dissector("fr_uncompressed", dissect_fr_uncompressed, proto_fr);
   register_dissector("fr", dissect_fr, proto_fr);
   register_dissector("fr_stripped_address", dissect_fr_stripped_address, proto_fr);
-  register_capture_dissector(WTAP_ENCAP_FRELAY, capture_fr, proto_fr);
-  register_capture_dissector(WTAP_ENCAP_FRELAY_WITH_PHDR, capture_fr, proto_fr);
 
   frencap_module = prefs_register_protocol(proto_fr, NULL);
   /*
@@ -1021,6 +1003,9 @@ proto_reg_handoff_fr(void)
   fr_phdr_handle = create_dissector_handle(dissect_fr_phdr, proto_fr);
   dissector_add_uint("wtap_encap", WTAP_ENCAP_FRELAY_WITH_PHDR, fr_phdr_handle);
 
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_FRELAY, capture_fr, proto_fr);
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_FRELAY_WITH_PHDR, capture_fr, proto_fr);
+
   eth_withfcs_handle = find_dissector("eth_withfcs");
   gprs_ns_handle = find_dissector("gprs_ns");
   data_handle = find_dissector("data");
diff --git a/epan/dissectors/packet-frame.c b/epan/dissectors/packet-frame.c
index 4521d24d1b..0776295f6c 100644
--- a/epan/dissectors/packet-frame.c
+++ b/epan/dissectors/packet-frame.c
@@ -28,6 +28,7 @@
 #endif
 
 #include <epan/packet.h>
+#include <epan/capture_dissectors.h>
 #include <epan/epan.h>
 #include <epan/exceptions.h>
 #include <epan/show_exception.h>
@@ -879,6 +880,7 @@ proto_register_frame(void)
 	    "Wiretap encapsulation type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE);
 	wtap_fts_rec_dissector_table = register_dissector_table("wtap_fts_rec",
 	    "Wiretap file type for file-type-specific records", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_ALLOW_DUPLICATE);
+	register_capture_dissector_table("wtap_encap", "Wiretap encapsulation type");
 
 	proto_frame = proto_register_protocol("Frame", "Frame", "frame");
 	proto_pkt_comment = proto_register_protocol("Packet comments", "Pkt_Comment", "pkt_comment");
diff --git a/epan/dissectors/packet-i2c.c b/epan/dissectors/packet-i2c.c
index 63a8bb152c..f62eee079a 100644
--- a/epan/dissectors/packet-i2c.c
+++ b/epan/dissectors/packet-i2c.c
@@ -84,7 +84,7 @@ static gpointer i2c_value(packet_info *pinfo _U_)
 	return 0;
 }
 
-static void
+static gboolean
 capture_i2c(const guchar *pd _U_, int offset _U_, int len _U_, packet_counts *ld, const union wtap_pseudo_header *pseudo_header)
 {
 	if (pseudo_header->i2c.is_event) {
@@ -92,6 +92,8 @@ capture_i2c(const guchar *pd _U_, int offset _U_, int len _U_, packet_counts *ld
 	} else {
 		ld->i2c_data++;
 	}
+
+	return TRUE;
 }
 
 static const char *
@@ -247,8 +249,6 @@ proto_register_i2c(void)
 	proto_register_field_array(proto_i2c, hf, array_length(hf));
 	proto_register_subtree_array(ett, array_length(ett));
 
-	register_capture_dissector(WTAP_ENCAP_I2C, capture_i2c, proto_i2c);
-
 	subdissector_table = register_dissector_table("i2c.message", "I2C messages dissector", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE);
 
 	m = prefs_register_protocol(proto_i2c, NULL);
@@ -266,6 +266,7 @@ proto_reg_handoff_i2c(void)
 
 	i2c_handle = create_dissector_handle(dissect_i2c, proto_i2c);
 	dissector_add_uint("wtap_encap", WTAP_ENCAP_I2C, i2c_handle);
+	register_capture_dissector("wtap_encap", WTAP_ENCAP_I2C, capture_i2c, proto_i2c);
 }
 
 /*
diff --git a/epan/dissectors/packet-ieee80211-prism.c b/epan/dissectors/packet-ieee80211-prism.c
index 6d223d8dee..50b69a9567 100644
--- a/epan/dissectors/packet-ieee80211-prism.c
+++ b/epan/dissectors/packet-ieee80211-prism.c
@@ -237,33 +237,29 @@ prism_rate_return(guint32 rate)
 }
 
 
-static void
+static gboolean
 capture_prism(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
   guint32 cookie;
 
-  if (!BYTES_ARE_IN_FRAME(offset, len, 4)) {
-    ld->other++;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(offset, len, 4))
+    return FALSE;
 
   /* Some captures with DLT_PRISM have the AVS WLAN header */
   cookie = pntoh32(pd);
   if ((cookie == WLANCAP_MAGIC_COOKIE_V1) ||
       (cookie == WLANCAP_MAGIC_COOKIE_V2)) {
-    capture_wlancap(pd, offset, len, ld, pseudo_header);
-    return;
+    return capture_wlancap(pd, offset, len, ld, pseudo_header);
   }
 
   /* Prism header */
-  if (!BYTES_ARE_IN_FRAME(offset, len, PRISM_HEADER_LENGTH)) {
-    ld->other++;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(offset, len, PRISM_HEADER_LENGTH))
+    return FALSE;
+
   offset += PRISM_HEADER_LENGTH;
 
   /* 802.11 header follows */
-  capture_ieee80211(pd, offset, len, ld, pseudo_header);
+  return capture_ieee80211(pd, offset, len, ld, pseudo_header);
 }
 
 static int
@@ -558,8 +554,6 @@ void proto_register_ieee80211_prism(void)
                                         "prism");
   proto_register_field_array(proto_prism, hf_prism, array_length(hf_prism));
   proto_register_subtree_array(tree_array, array_length(tree_array));
-
-  register_capture_dissector(WTAP_ENCAP_IEEE_802_11_PRISM, capture_prism, proto_prism);
 }
 
 void proto_reg_handoff_ieee80211_prism(void)
@@ -571,6 +565,8 @@ void proto_reg_handoff_ieee80211_prism(void)
   ieee80211_handle = find_dissector("wlan");
   ieee80211_radio_handle = find_dissector("wlan_radio");
   wlancap_handle = find_dissector("wlancap");
+
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_IEEE_802_11_PRISM, capture_prism, proto_prism);
 }
 
 /*
diff --git a/epan/dissectors/packet-ieee80211-radiotap.c b/epan/dissectors/packet-ieee80211-radiotap.c
index 1e08cd6c49..e346422200 100644
--- a/epan/dissectors/packet-ieee80211-radiotap.c
+++ b/epan/dissectors/packet-ieee80211-radiotap.c
@@ -455,7 +455,7 @@ static const true_false_string preamble_type = {
  *    dissectors, such as tcpdump(8), expect the padding.
  */
 
-static void
+static gboolean
 capture_radiotap(const guchar * pd, int offset, int len, packet_counts * ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
 	guint16 it_len;
@@ -465,26 +465,21 @@ capture_radiotap(const guchar * pd, int offset, int len, packet_counts * ld, con
 
 	if (!BYTES_ARE_IN_FRAME(offset, len,
 				sizeof(struct ieee80211_radiotap_header))) {
-		ld->other++;
-		return;
+		return FALSE;
 	}
 	hdr = (const struct ieee80211_radiotap_header *)pd;
 	it_len = pletoh16(&hdr->it_len);
-	if (!BYTES_ARE_IN_FRAME(offset, len, it_len)) {
-		ld->other++;
-		return;
-	}
+	if (!BYTES_ARE_IN_FRAME(offset, len, it_len))
+		return FALSE;
 
 	if (it_len > len) {
 		/* Header length is bigger than total packet length */
-		ld->other++;
-		return;
+		return FALSE;
 	}
 
 	if (it_len < sizeof(struct ieee80211_radiotap_header)) {
 		/* Header length is shorter than fixed-length portion of header */
-		ld->other++;
-		return;
+		return FALSE;
 	}
 
 	present = pletoh32(&hdr->it_present);
@@ -495,8 +490,7 @@ capture_radiotap(const guchar * pd, int offset, int len, packet_counts * ld, con
 	xpresent = present;
 	while (xpresent & BIT(IEEE80211_RADIOTAP_EXT)) {
 		if (!BYTES_ARE_IN_FRAME(offset, 4, it_len)) {
-			ld->other++;
-			return;
+			return FALSE;
 		}
 		xpresent = pletoh32(pd + offset);
 		offset += 4;
@@ -519,8 +513,7 @@ capture_radiotap(const guchar * pd, int offset, int len, packet_counts * ld, con
 
 		if (it_len < 8) {
 			/* No room in header for this field. */
-			ld->other++;
-			return;
+			return FALSE;
 		}
 		/* That field is present, and it's 8 bytes long. */
 		offset += 8;
@@ -533,22 +526,20 @@ capture_radiotap(const guchar * pd, int offset, int len, packet_counts * ld, con
 	if (present & BIT(IEEE80211_RADIOTAP_FLAGS)) {
 		if (it_len < 1) {
 			/* No room in header for this field. */
-			ld->other++;
-			return;
+			return FALSE;
 		}
 		/* That field is present; fetch it. */
 		if (!BYTES_ARE_IN_FRAME(offset, len, 1)) {
-			ld->other++;
-			return;
+			return FALSE;
 		}
 		rflags = pd[offset];
 	}
 
 	/* 802.11 header follows */
 	if (rflags & IEEE80211_RADIOTAP_F_DATAPAD)
-		capture_ieee80211_datapad(pd, offset + it_len, len, ld, pseudo_header);
-	else
-		capture_ieee80211(pd, offset + it_len, len, ld, pseudo_header);
+		return capture_ieee80211_datapad(pd, offset + it_len, len, ld, pseudo_header);
+
+	return capture_ieee80211(pd, offset + it_len, len, ld, pseudo_header);
 }
 
 static int
@@ -2662,7 +2653,6 @@ void proto_register_radiotap(void)
 	expert_radiotap = expert_register_protocol(proto_radiotap);
 	expert_register_field_array(expert_radiotap, ei, array_length(ei));
 	register_dissector("radiotap", dissect_radiotap, proto_radiotap);
-	register_capture_dissector(WTAP_ENCAP_IEEE_802_11_RADIOTAP, capture_radiotap, proto_radiotap);
 
 	radiotap_tap = register_tap("radiotap");
 
@@ -2686,6 +2676,8 @@ void proto_reg_handoff_radiotap(void)
 
 	dissector_add_uint("wtap_encap", WTAP_ENCAP_IEEE_802_11_RADIOTAP,
 			   radiotap_handle);
+
+	register_capture_dissector("wtap_encap", WTAP_ENCAP_IEEE_802_11_RADIOTAP, capture_radiotap, proto_radiotap);
 }
 
 /*
diff --git a/epan/dissectors/packet-ieee80211-wlancap.c b/epan/dissectors/packet-ieee80211-wlancap.c
index ad53c78a30..a3efb2ff1f 100644
--- a/epan/dissectors/packet-ieee80211-wlancap.c
+++ b/epan/dissectors/packet-ieee80211-wlancap.c
@@ -72,27 +72,23 @@ static gint ett_wlancap = -1;
 
 static dissector_handle_t wlancap_handle;
 
-void
+gboolean
 capture_wlancap(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
   guint32 length;
 
-  if (!BYTES_ARE_IN_FRAME(offset, len, sizeof(guint32)*2)) {
-    ld->other++;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(offset, len, sizeof(guint32)*2))
+    return FALSE;
 
   length = pntoh32(pd+sizeof(guint32));
 
-  if (!BYTES_ARE_IN_FRAME(offset, len, length)) {
-    ld->other++;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(offset, len, length))
+    return FALSE;
 
   offset += length;
 
   /* 802.11 header follows */
-  capture_ieee80211(pd, offset, len, ld, pseudo_header);
+  return capture_ieee80211(pd, offset, len, ld, pseudo_header);
 }
 
 /*
@@ -849,7 +845,6 @@ void proto_register_ieee80211_wlancap(void)
   proto_register_field_array(proto_wlancap, hf_wlancap,
                              array_length(hf_wlancap));
   register_dissector("wlancap", dissect_wlancap, proto_wlancap);
-  register_capture_dissector(WTAP_ENCAP_IEEE_802_11_AVS, capture_wlancap, proto_wlancap);
 
   wlancap_handle = create_dissector_handle(dissect_wlancap, proto_wlancap);
   dissector_add_uint("wtap_encap", WTAP_ENCAP_IEEE_802_11_AVS,
@@ -860,6 +855,7 @@ void proto_register_ieee80211_wlancap(void)
 void proto_reg_handoff_ieee80211_wlancap(void)
 {
   ieee80211_radio_handle = find_dissector("wlan_radio");
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_IEEE_802_11_AVS, capture_wlancap, proto_wlancap);
 }
 
 /*
diff --git a/epan/dissectors/packet-ieee80211.c b/epan/dissectors/packet-ieee80211.c
index a5e4567247..1cd76a9e9e 100644
--- a/epan/dissectors/packet-ieee80211.c
+++ b/epan/dissectors/packet-ieee80211.c
@@ -5620,23 +5620,19 @@ add_mimo_compressed_beamforming_feedback_report (proto_tree *tree, tvbuff_t *tvb
 /* ************************************************************************* */
 /*          This is the capture function used to update packet counts        */
 /* ************************************************************************* */
-static void
+static gboolean
 capture_ieee80211_common (const guchar * pd, int offset, int len,
                           packet_counts * ld, const union wtap_pseudo_header *pseudo_header _U_, gboolean datapad)
 {
   guint16 fcf, hdr_length;
 
-  if (!BYTES_ARE_IN_FRAME(offset, len, 2)) {
-    ld->other += 1;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(offset, len, 2))
+    return FALSE;
 
   fcf = pletoh16 (&pd[offset]);
 
-  if (IS_PROTECTED(FCF_FLAGS(fcf)) && (wlan_ignore_wep == WLAN_IGNORE_WEP_NO)) {
-    ld->other += 1;
-    return;
-  }
+  if (IS_PROTECTED(FCF_FLAGS(fcf)) && (wlan_ignore_wep == WLAN_IGNORE_WEP_NO))
+    return FALSE;
 
   switch (COMPOSE_FRAME_TYPE (fcf)) {
 
@@ -5670,10 +5666,9 @@ capture_ieee80211_common (const guchar * pd, int offset, int len,
          * Look at the Mesh Control subfield of the QoS field and at the
          * purported mesh flag fields.
          */
-        if (!BYTES_ARE_IN_FRAME(offset, hdr_length, 1)) {
-          ld->other += 1;
-          return;
-        }
+        if (!BYTES_ARE_IN_FRAME(offset, hdr_length, 1))
+          return FALSE;
+
         mesh_flags = pd[hdr_length];
         if (has_mesh_control(fcf, pletoh16(&pd[qosoff]), mesh_flags)) {
           /* Yes, add the length of that in as well. */
@@ -5723,10 +5718,9 @@ capture_ieee80211_common (const guchar * pd, int offset, int len,
            as an encapsulated IPX frame, and then check whether the
            packet starts with 0x00 0x00 and, if so, treat it as an OLPC
            frame. */
-      if (!BYTES_ARE_IN_FRAME(offset+hdr_length, len, 2)) {
-        ld->other += 1;
-        return;
-      }
+      if (!BYTES_ARE_IN_FRAME(offset+hdr_length, len, 2))
+        return FALSE;
+
       if ((pd[offset+hdr_length] != 0xaa) && (pd[offset+hdr_length+1] != 0xaa)) {
 #if 0
         /* XXX - this requires us to parse the header to find the source
@@ -5735,45 +5729,42 @@ capture_ieee80211_common (const guchar * pd, int offset, int len,
           /* We have two MAC addresses after the header. */
           if ((memcmp(&pd[offset+hdr_length+6], pinfo->dl_src.data, 6) == 0) ||
               (memcmp(&pd[offset+hdr_length+6], pinfo->dl_dst.data, 6) == 0)) {
-            capture_eth (pd, offset + hdr_length, len, ld);
-            return;
+            return capture_eth (pd, offset + hdr_length, len, ld);
           }
         }
 #endif
         if ((pd[offset+hdr_length] == 0xff) && (pd[offset+hdr_length+1] == 0xff))
-          capture_ipx (pd, offset+hdr_length, len, ld, pseudo_header);
+          return capture_ipx (pd, offset+hdr_length, len, ld, pseudo_header);
         else if ((pd[offset+hdr_length] == 0x00) && (pd[offset+hdr_length+1] == 0x00))
-          capture_llc (pd, offset + hdr_length + 2, len, ld, pseudo_header);
+          return capture_llc (pd, offset + hdr_length + 2, len, ld, pseudo_header);
       }
       else {
-        capture_llc (pd, offset + hdr_length, len, ld, pseudo_header);
+        return capture_llc (pd, offset + hdr_length, len, ld, pseudo_header);
       }
       break;
     }
-
-    default:
-      ld->other += 1;
-      break;
   }
+
+  return FALSE;
 }
 
 /*
  * Handle 802.11 with a variable-length link-layer header.
  */
-void
+gboolean
 capture_ieee80211 (const guchar * pd, int offset, int len, packet_counts * ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
-  capture_ieee80211_common (pd, offset, len, ld, pseudo_header, FALSE);
+  return capture_ieee80211_common (pd, offset, len, ld, pseudo_header, FALSE);
 }
 
 /*
  * Handle 802.11 with a variable-length link-layer header and data padding.
  */
-void
+gboolean
 capture_ieee80211_datapad (const guchar * pd, int offset, int len,
                            packet_counts * ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
-  capture_ieee80211_common (pd, offset, len, ld, pseudo_header, TRUE);
+  return capture_ieee80211_common (pd, offset, len, ld, pseudo_header, TRUE);
 }
 
 
@@ -27074,9 +27065,6 @@ proto_register_ieee80211 (void)
   register_dissector("wlan_withoutfcs",         dissect_ieee80211_withoutfcs,         proto_wlan);
   register_dissector("wlan_bsfc",               dissect_ieee80211_bsfc,               proto_wlan);
 
-  register_capture_dissector(WTAP_ENCAP_IEEE_802_11, capture_ieee80211, proto_wlan);
-  register_capture_dissector(WTAP_ENCAP_IEEE_802_11_WITH_RADIO, capture_ieee80211, proto_wlan);
-
   register_init_routine(wlan_defragment_init);
   register_cleanup_routine(wlan_defragment_cleanup);
   register_init_routine(wlan_retransmit_init);
@@ -27304,6 +27292,9 @@ proto_reg_handoff_ieee80211(void)
   centrino_handle = create_dissector_handle( dissect_ieee80211_centrino, proto_centrino );
   dissector_add_uint("ethertype", ETHERTYPE_CENTRINO_PROMISC, centrino_handle);
 
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_IEEE_802_11, capture_ieee80211, proto_wlan);
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_IEEE_802_11_WITH_RADIO, capture_ieee80211, proto_wlan);
+
   /* Register handoff to Aruba GRE */
   dissector_add_uint("gre.proto", GRE_ARUBA_8200, ieee80211_handle);
   dissector_add_uint("gre.proto", GRE_ARUBA_8210, ieee80211_handle);
diff --git a/epan/dissectors/packet-ieee80211.h b/epan/dissectors/packet-ieee80211.h
index d14afa6021..3179f92be8 100644
--- a/epan/dissectors/packet-ieee80211.h
+++ b/epan/dissectors/packet-ieee80211.h
@@ -32,11 +32,11 @@ extern "C" {
 #endif /* __cplusplus */
 
 extern
-void capture_ieee80211 (const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
-void capture_ieee80211_datapad (const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_ieee80211 (const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_ieee80211_datapad (const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
 
 extern
-void capture_wlancap(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_wlancap(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
 
 void dissect_wifi_p2p_ie(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb,
                          int offset, gint size);
diff --git a/epan/dissectors/packet-ieee8021ah.c b/epan/dissectors/packet-ieee8021ah.c
index 2ac42caf63..e6769638ec 100644
--- a/epan/dissectors/packet-ieee8021ah.c
+++ b/epan/dissectors/packet-ieee8021ah.c
@@ -23,10 +23,10 @@
 #include "config.h"
 
 #include <epan/packet.h>
+#include <epan/capture_dissectors.h>
 #include <wsutil/pint.h>
 #include <epan/addr_resolv.h>
 
-#include "packet-ieee8021ah.h"
 #include "packet-ipx.h"
 #include "packet-llc.h"
 #include <epan/etypes.h>
@@ -72,31 +72,33 @@ static int hf_ieee8021ah_trailer = -1;
 static gint ett_ieee8021ah = -1;
 static gint ett_ieee8021ad = -1;
 
+#define IEEE8021AD_LEN 4
+#define IEEE8021AH_LEN 18
+#define IEEE8021AH_ISIDMASK 0x00FFFFFF
+
 /* FUNCTIONS ************************************************************/
 
 
-void
+static gboolean
 capture_ieee8021ah(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
     guint16 encap_proto;
 
-    if (!BYTES_ARE_IN_FRAME(offset, len, IEEE8021AH_LEN + 1)) {
-        ld->other++;
-        return;
-    }
+    if (!BYTES_ARE_IN_FRAME(offset, len, IEEE8021AH_LEN + 1))
+        return FALSE;
+
     encap_proto = pntoh16( &pd[offset + IEEE8021AH_LEN - 2] );
     if (encap_proto <= IEEE_802_3_MAX_LEN) {
         if ( pd[offset + IEEE8021AH_LEN] == 0xff
              && pd[offset + IEEE8021AH_LEN + 1] == 0xff ) {
-            capture_ipx(pd, offset + IEEE8021AH_LEN, len, ld, pseudo_header);
+            return capture_ipx(pd, offset + IEEE8021AH_LEN, len, ld, pseudo_header);
         }
         else {
-            capture_llc(pd, offset + IEEE8021AH_LEN, len, ld, pseudo_header);
+            return capture_llc(pd, offset + IEEE8021AH_LEN, len, ld, pseudo_header);
         }
     }
-    else {
-        capture_ethertype(encap_proto, pd, offset + IEEE8021AH_LEN, len, ld, pseudo_header);
-    }
+
+    return try_capture_dissector("ethertype", encap_proto, pd, offset + IEEE8021AH_LEN, len, ld, pseudo_header);
 }
 
 /* Dissector *************************************************************/
@@ -438,6 +440,8 @@ proto_reg_handoff_ieee8021ah(void)
 
     old_ieee8021ah_ethertype = ieee8021ah_ethertype;
     dissector_add_uint("ethertype", ieee8021ah_ethertype, ieee8021ah_handle);
+    register_capture_dissector("ethertype", ETHERTYPE_IEEE_802_1AD, capture_ieee8021ah, proto_ieee8021ah);
+    register_capture_dissector("ethertype", ETHERTYPE_IEEE_802_1AH, capture_ieee8021ah, proto_ieee8021ah);
 
 }
 
diff --git a/epan/dissectors/packet-ieee8021ah.h b/epan/dissectors/packet-ieee8021ah.h
deleted file mode 100644
index b1ad038807..0000000000
--- a/epan/dissectors/packet-ieee8021ah.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/* packet-ieee8021ah.h
- *
- * Wireshark - Network traffic analyzer
- * By Gerald Combs <gerald@wireshark.org>
- * Copyright 1998 Gerald Combs
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#ifndef __PACKET_IEEE8021AH_H__
-#define __PACKET_IEEE8021AH_H__
-
-#define IEEE8021AD_LEN 4
-#define IEEE8021AH_LEN 18
-#define IEEE8021AH_ISIDMASK 0x00FFFFFF
-
-void capture_ieee8021ah(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
-
-#endif
diff --git a/epan/dissectors/packet-ip.c b/epan/dissectors/packet-ip.c
index 894a461409..77debead48 100644
--- a/epan/dissectors/packet-ip.c
+++ b/epan/dissectors/packet-ip.c
@@ -28,6 +28,7 @@
 #include "config.h"
 
 #include <epan/packet.h>
+#include <epan/capture_dissectors.h>
 #include <epan/addr_resolv.h>
 #include <epan/ipproto.h>
 #include <epan/expert.h>
@@ -566,12 +567,11 @@ ip_defragment_cleanup(void)
   reassembly_table_destroy(&ip_reassembly_table);
 }
 
-void
+gboolean
 capture_ip(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_) {
-  if (!BYTES_ARE_IN_FRAME(offset, len, IPH_MIN_LEN)) {
-    ld->other++;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(offset, len, IPH_MIN_LEN))
+    return FALSE;
+
   switch (pd[offset + 9]) {
     case IP_PROTO_TCP:
       ld->tcp++;
@@ -599,6 +599,9 @@ capture_ip(const guchar *pd, int offset, int len, packet_counts *ld, const union
     default:
       ld->other++;
   }
+
+  /* We're incrementing "other", so consider this our packet */
+  return TRUE;
 }
 
 #ifdef HAVE_GEOIP
@@ -3215,6 +3218,7 @@ proto_reg_handoff_ip(void)
   dissector_add_uint("wtap_encap", WTAP_ENCAP_RAW_IP4, ip_handle);
 
   heur_dissector_add("tipc", dissect_ip_heur, "IP over TIPC", "ip_tipc", proto_ip, HEURISTIC_ENABLE);
+  register_capture_dissector("ethertype", ETHERTYPE_IP, capture_ip, proto_ip);
 }
 
 /*
diff --git a/epan/dissectors/packet-ip.h b/epan/dissectors/packet-ip.h
index 8ab6f3962e..441e620640 100644
--- a/epan/dissectors/packet-ip.h
+++ b/epan/dissectors/packet-ip.h
@@ -50,7 +50,7 @@ typedef struct _ws_ip
 #define IPDSFIELD_ECN_MASK      0x03
 #define IPDSFIELD_ECN(dsfield)  ((dsfield) & IPDSFIELD_ECN_MASK)
 
-void capture_ip(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_ip(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
 
 gboolean ip_try_dissect(gboolean heur_first, tvbuff_t *tvb,
                         packet_info *pinfo, proto_tree *tree, ws_ip *iph);
diff --git a/epan/dissectors/packet-ipfc.c b/epan/dissectors/packet-ipfc.c
index b7b4f16c6d..711ea29d44 100644
--- a/epan/dissectors/packet-ipfc.c
+++ b/epan/dissectors/packet-ipfc.c
@@ -45,15 +45,13 @@ static int hf_ipfc_network_sa = -1;
 static gint ett_ipfc = -1;
 static dissector_handle_t llc_handle;
 
-static void
+static gboolean
 capture_ipfc (const guchar *pd, int offset _U_, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
-  if (!BYTES_ARE_IN_FRAME(0, len, 16)) {
-    ld->other++;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(0, len, 16))
+    return FALSE;
 
-  capture_llc(pd, 16, len, ld, pseudo_header);
+  return capture_llc(pd, 16, len, ld, pseudo_header);
 }
 
 static int
@@ -114,8 +112,6 @@ proto_register_ipfc (void)
     /* Required function calls to register the header fields and subtrees used */
     proto_register_field_array(proto_ipfc, hf, array_length(hf));
     proto_register_subtree_array(ett, array_length(ett));
-
-    register_capture_dissector(WTAP_ENCAP_IP_OVER_FC, capture_ipfc, proto_ipfc);
 }
 
 /* If this dissector uses sub-dissector registration add a registration routine.
@@ -131,6 +127,8 @@ proto_reg_handoff_ipfc (void)
     dissector_add_uint("wtap_encap", WTAP_ENCAP_IP_OVER_FC, ipfc_handle);
 
     llc_handle = find_dissector ("llc");
+
+    register_capture_dissector("wtap_encap", WTAP_ENCAP_IP_OVER_FC, capture_ipfc, proto_ipfc);
 }
 
 /*
diff --git a/epan/dissectors/packet-ipv6.c b/epan/dissectors/packet-ipv6.c
index 4466f6c4fb..3a0048fdcb 100644
--- a/epan/dissectors/packet-ipv6.c
+++ b/epan/dissectors/packet-ipv6.c
@@ -28,6 +28,7 @@
 
 #include <math.h>
 #include <epan/packet.h>
+#include <epan/capture_dissectors.h>
 #include <epan/expert.h>
 #include <epan/ip_opts.h>
 #include <epan/addr_resolv.h>
@@ -524,16 +525,15 @@ static const value_string ipv6_opt_vals[] = {
 };
 
 
-void
+gboolean
 capture_ipv6(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
     guint8 nxt;
     int    advance;
 
-    if (!BYTES_ARE_IN_FRAME(offset, len, 4+4+16+16)) {
-        ld->other++;
-        return;
-    }
+    if (!BYTES_ARE_IN_FRAME(offset, len, 4+4+16+16))
+        return FALSE;
+
     nxt = pd[offset+6];           /* get the "next header" value */
     offset += 4+4+16+16;          /* skip past the IPv6 header */
 
@@ -542,55 +542,47 @@ again:
     case IP_PROTO_HOPOPTS:
     case IP_PROTO_ROUTING:
     case IP_PROTO_DSTOPTS:
-        if (!BYTES_ARE_IN_FRAME(offset, len, 2)) {
-            ld->other++;
-            return;
-        }
+        if (!BYTES_ARE_IN_FRAME(offset, len, 2))
+            return FALSE;
+
         nxt = pd[offset];
         advance = (pd[offset+1] + 1) << 3;
-        if (!BYTES_ARE_IN_FRAME(offset, len, advance)) {
-            ld->other++;
-            return;
-        }
+        if (!BYTES_ARE_IN_FRAME(offset, len, advance))
+            return FALSE;
+
         offset += advance;
         goto again;
     case IP_PROTO_FRAGMENT:
-        if (!BYTES_ARE_IN_FRAME(offset, len, 2)) {
-            ld->other++;
-            return;
-        }
+        if (!BYTES_ARE_IN_FRAME(offset, len, 2))
+            return FALSE;
+
         nxt = pd[offset];
         advance = 8;
-        if (!BYTES_ARE_IN_FRAME(offset, len, advance)) {
-            ld->other++;
-            return;
-        }
+        if (!BYTES_ARE_IN_FRAME(offset, len, advance))
+            return FALSE;
+
         offset += advance;
         goto again;
     case IP_PROTO_AH:
-        if (!BYTES_ARE_IN_FRAME(offset, len, 2)) {
-            ld->other++;
-            return;
-        }
+        if (!BYTES_ARE_IN_FRAME(offset, len, 2))
+            return FALSE;
+
         nxt = pd[offset];
         advance = 8 + ((pd[offset+1] - 1) << 2);
-        if (!BYTES_ARE_IN_FRAME(offset, len, advance)) {
-            ld->other++;
-            return;
-        }
+        if (!BYTES_ARE_IN_FRAME(offset, len, advance))
+            return FALSE;
+
         offset += advance;
         goto again;
     case IP_PROTO_SHIM6:
-        if (!BYTES_ARE_IN_FRAME(offset, len, 2)) {
-            ld->other++;
-            return;
-        }
+        if (!BYTES_ARE_IN_FRAME(offset, len, 2))
+            return FALSE;
+
         nxt = pd[offset];
         advance = (pd[offset+1] + 1) << 3;
-        if (!BYTES_ARE_IN_FRAME(offset, len, advance)) {
-            ld->other++;
-            return;
-        }
+        if (!BYTES_ARE_IN_FRAME(offset, len, advance))
+            return FALSE;
+
         offset += advance;
         goto again;
     }
@@ -620,8 +612,9 @@ again:
         ld->vines++;
         break;
     default:
-        ld->other++;
+        return FALSE;
     }
+    return TRUE;
 }
 
 /**
@@ -3567,6 +3560,7 @@ proto_reg_handoff_ipv6(void)
     dissector_add_uint("ipv6.nxt", IP_PROTO_DSTOPTS, ipv6_dstopts_handle);
 
     ip_dissector_table = find_dissector_table("ip.proto");
+    register_capture_dissector("ethertype", ETHERTYPE_IPv6, capture_ipv6, proto_ipv6);
 }
 
 /*
diff --git a/epan/dissectors/packet-ipv6.h b/epan/dissectors/packet-ipv6.h
index 514ee749ec..3020ce86fc 100644
--- a/epan/dissectors/packet-ipv6.h
+++ b/epan/dissectors/packet-ipv6.h
@@ -168,7 +168,7 @@ struct ip6_shim {
 extern "C" {
 #endif /* __cplusplus */
 
-void capture_ipv6(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_ipv6(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
 
 #ifdef __cplusplus
 }
diff --git a/epan/dissectors/packet-ipx.c b/epan/dissectors/packet-ipx.c
index a39961e56a..3e6940cf40 100644
--- a/epan/dissectors/packet-ipx.c
+++ b/epan/dissectors/packet-ipx.c
@@ -28,6 +28,7 @@
 #include "config.h"
 
 #include <epan/packet.h>
+#include <epan/capture_dissectors.h>
 #include "packet-ipx.h"
 #include "packet-sll.h"
 #include <epan/addr_resolv.h>
@@ -272,10 +273,11 @@ static const value_string ipxmsg_sigchar_vals[] = {
 	{ 0, NULL }
 };
 
-void
+gboolean
 capture_ipx(const guchar *pd _U_, int offset _U_, int len _U_, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
 	ld->ipx++;
+	return TRUE;
 }
 
 static int
@@ -1622,6 +1624,7 @@ proto_reg_handoff_ipx(void)
 	dissector_add_uint("ipx.socket", IPX_SOCKET_IPX_MESSAGE, ipxmsg_handle);
 	dissector_add_uint("ipx.socket", IPX_SOCKET_IPX_MESSAGE1, ipxmsg_handle);
 
+	register_capture_dissector("ethertype", ETHERTYPE_IPX, capture_ipx, proto_ipx);
 	data_handle = find_dissector("data");
 }
 
diff --git a/epan/dissectors/packet-ipx.h b/epan/dissectors/packet-ipx.h
index c5f5ae54e2..770590ebfe 100644
--- a/epan/dissectors/packet-ipx.h
+++ b/epan/dissectors/packet-ipx.h
@@ -147,7 +147,7 @@ struct ipx_rip_packet
 extern value_string_ext ipx_socket_vals_ext;
 extern value_string_ext novell_server_vals_ext;
 
-void capture_ipx(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_ipx(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header);
 
 /*
  * Structure passed to SPX subdissectors, containing information from
diff --git a/epan/dissectors/packet-isl.c b/epan/dissectors/packet-isl.c
index e3a34eab16..830cb4ada7 100644
--- a/epan/dissectors/packet-isl.c
+++ b/epan/dissectors/packet-isl.c
@@ -88,15 +88,13 @@ static dissector_handle_t eth_withfcs_handle;
 static dissector_handle_t tr_handle;
 static dissector_handle_t data_handle;
 
-void
+gboolean
 capture_isl(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
   guint8 type;
 
-  if (!BYTES_ARE_IN_FRAME(offset, len, ISL_HEADER_SIZE)) {
-    ld->other++;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(offset, len, ISL_HEADER_SIZE))
+    return FALSE;
 
   type = (pd[offset+5] >> 4)&0x0F;
 
@@ -104,18 +102,15 @@ capture_isl(const guchar *pd, int offset, int len, packet_counts *ld, const unio
 
   case TYPE_ETHER:
     offset += 14+12;    /* skip the header */
-    capture_eth(pd, offset, len, ld, pseudo_header);
-    break;
+    return capture_eth(pd, offset, len, ld, pseudo_header);
 
   case TYPE_TR:
     offset += 14+17;    /* skip the header */
-    capture_tr(pd, offset, len, ld, pseudo_header);
-    break;
-
-  default:
-    ld->other++;
+    return capture_tr(pd, offset, len, ld, pseudo_header);
     break;
   }
+
+  return FALSE;
 }
 
 static const value_string type_vals[] = {
diff --git a/epan/dissectors/packet-isl.h b/epan/dissectors/packet-isl.h
index 1f08570089..4d31454db1 100644
--- a/epan/dissectors/packet-isl.h
+++ b/epan/dissectors/packet-isl.h
@@ -22,7 +22,7 @@
 #ifndef __PACKET_ISL_H__
 #define __PACKET_ISL_H__
 
-void capture_isl(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_isl(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
 
 void dissect_isl(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree,
     int fcs_len);
diff --git a/epan/dissectors/packet-llc.c b/epan/dissectors/packet-llc.c
index 402fa94f76..0c226894bc 100644
--- a/epan/dissectors/packet-llc.c
+++ b/epan/dissectors/packet-llc.c
@@ -24,6 +24,7 @@
 #include "config.h"
 
 #include <epan/packet.h>
+#include <epan/capture_dissectors.h>
 #include <wiretap/wtap.h>
 #include <wsutil/pint.h>
 #include <epan/oui.h>
@@ -250,17 +251,16 @@ llc_add_oui(guint32 oui, const char *table_name, const char *table_ui_name,
 	g_hash_table_insert(oui_info_table, GUINT_TO_POINTER(oui), new_info);
 }
 
-void
+gboolean
 capture_llc(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_) {
 
 	int		is_snap;
 	guint16		control;
 	int		llc_header_len;
 
-	if (!BYTES_ARE_IN_FRAME(offset, len, 2)) {
-		ld->other++;
-		return;
-	}
+	if (!BYTES_ARE_IN_FRAME(offset, len, 2))
+		return FALSE;
+
 	is_snap = (pd[offset] == SAP_SNAP) && (pd[offset+1] == SAP_SNAP);
 	llc_header_len = 2;	/* DSAP + SSAP */
 
@@ -272,56 +272,43 @@ capture_llc(const guchar *pd, int offset, int len, packet_counts *ld, const unio
 	 */
 	control = get_xdlc_control(pd, offset+2, pd[offset+1] & SSAP_CR_BIT);
 	llc_header_len += XDLC_CONTROL_LEN(control, TRUE);
-	if (!BYTES_ARE_IN_FRAME(offset, len, llc_header_len)) {
-		ld->other++;
-		return;
-	}
+	if (!BYTES_ARE_IN_FRAME(offset, len, llc_header_len))
+		return FALSE;
+
+	if (!XDLC_IS_INFORMATION(control))
+		return FALSE;
 
-	if (!XDLC_IS_INFORMATION(control)) {
-		ld->other++;
-		return;
-	}
 	if (is_snap)
-		capture_snap(pd, offset+llc_header_len, len, ld, pseudo_header);
-	else {
-		/* non-SNAP */
-		switch (pd[offset]) {
+		return capture_snap(pd, offset+llc_header_len, len, ld, pseudo_header);
 
-		case SAP_IP:
-			capture_ip(pd, offset + llc_header_len, len, ld, pseudo_header);
-			break;
+	/* non-SNAP */
+	switch (pd[offset]) {
 
-		case SAP_NETWARE1:
-		case SAP_NETWARE2:
-			capture_ipx(pd, offset + llc_header_len, len, ld, pseudo_header);
-			break;
+	case SAP_IP:
+		return capture_ip(pd, offset + llc_header_len, len, ld, pseudo_header);
 
-		case SAP_NETBIOS:
-			capture_netbios(pd, offset + llc_header_len, len, ld, pseudo_header);
-			break;
+	case SAP_NETWARE1:
+	case SAP_NETWARE2:
+		return capture_ipx(pd, offset + llc_header_len, len, ld, pseudo_header);
 
-		case SAP_VINES1:
-		case SAP_VINES2:
-			capture_vines(pd, offset + llc_header_len, len, ld, pseudo_header);
-			break;
+	case SAP_NETBIOS:
+		return capture_netbios(pd, offset + llc_header_len, len, ld, pseudo_header);
 
-		default:
-			ld->other++;
-			break;
-		}
+	case SAP_VINES1:
+	case SAP_VINES2:
+		return capture_vines(pd, offset + llc_header_len, len, ld, pseudo_header);
 	}
+	return FALSE;
 }
 
-void
+gboolean
 capture_snap(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
 	guint32		oui;
 	guint16		etype;
 
-	if (!BYTES_ARE_IN_FRAME(offset, len, 5)) {
-		ld->other++;
-		return;
-	}
+	if (!BYTES_ARE_IN_FRAME(offset, len, 5))
+		return FALSE;
 
 	oui = pd[offset] << 16 | pd[offset+1] << 8 | pd[offset+2];
 	etype = pntoh16(&pd[offset+3]);
@@ -337,12 +324,10 @@ capture_snap(const guchar *pd, int offset, int len, packet_counts *ld, const uni
 		   AppleTalk data packets - but used
 		   OUI_ENCAP_ETHER and an Ethernet
 		   packet type for AARP packets. */
-		capture_ethertype(etype, pd, offset+5, len, ld, pseudo_header);
-		break;
+		return try_capture_dissector("ethertype", etype, pd, offset+5, len, ld, pseudo_header);
 
 	case OUI_CISCO:
-		capture_ethertype(etype, pd, offset+5, len, ld, pseudo_header);
-		break;
+		return try_capture_dissector("ethertype", etype, pd, offset+5, len, ld, pseudo_header);
 
 	case OUI_MARVELL:
 		/*
@@ -351,13 +336,10 @@ capture_snap(const guchar *pd, int offset, int len, packet_counts *ld, const uni
 		 * the payload.  (We assume the header is
 		 * 5 bytes, for now).
 		 */
-		capture_ethertype(etype, pd, offset+5+5, len, ld, pseudo_header);
-		break;
-
-	default:
-		ld->other++;
-		break;
+		return try_capture_dissector("ethertype", etype, pd, offset+5+5, len, ld, pseudo_header);
 	}
+
+	return FALSE;
 }
 
 /* Used only for U frames */
@@ -945,6 +927,8 @@ proto_reg_handoff_llc(void)
 	dissector_add_uint("juniper.proto", JUNIPER_PROTO_LLC, llc_handle);
 	dissector_add_uint("juniper.proto", JUNIPER_PROTO_LLC_SNAP, llc_handle);
 
+	register_capture_dissector("ethertype", ETHERTYPE_JUMBO_LLC, capture_llc, proto_llc);
+
 	/*
 	 * Register all the fields for PIDs for various OUIs.
 	 */
diff --git a/epan/dissectors/packet-llc.h b/epan/dissectors/packet-llc.h
index ea40ed2460..99fa5a2448 100644
--- a/epan/dissectors/packet-llc.h
+++ b/epan/dissectors/packet-llc.h
@@ -24,11 +24,11 @@
 
 #include "ws_symbol_export.h"
 
-void capture_llc(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_llc(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
 
 extern const value_string sap_vals[];
 
-void capture_snap(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_snap(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
 
 void dissect_snap(tvbuff_t *, int, packet_info *, proto_tree *,
     proto_tree *, int, int, int, int, int);
diff --git a/epan/dissectors/packet-netbios.c b/epan/dissectors/packet-netbios.c
index e0c8d41739..06aa57fc11 100644
--- a/epan/dissectors/packet-netbios.c
+++ b/epan/dissectors/packet-netbios.c
@@ -284,10 +284,11 @@ static const value_string max_frame_size_vals[] = {
 };
 
 
-void
+gboolean
 capture_netbios(const guchar *pd _U_, int offset _U_, int len _U_, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
 	ld->netbios++;
+	return TRUE;
 }
 
 
diff --git a/epan/dissectors/packet-netbios.h b/epan/dissectors/packet-netbios.h
index 8011ac3d57..c34ec49ea1 100644
--- a/epan/dissectors/packet-netbios.h
+++ b/epan/dissectors/packet-netbios.h
@@ -30,7 +30,7 @@
 /* Length of NetBIOS names */
 #define NETBIOS_NAME_LEN	16
 
-void capture_netbios(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_netbios(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header);
 
 extern int process_netbios_name(const guchar *name_ptr, char *name_ret, int name_ret_len);
 extern int get_netbios_name(tvbuff_t *tvb, int offset,
diff --git a/epan/dissectors/packet-netrom.c b/epan/dissectors/packet-netrom.c
index 7238876e48..6c34abac05 100644
--- a/epan/dissectors/packet-netrom.c
+++ b/epan/dissectors/packet-netrom.c
@@ -488,16 +488,14 @@ dissect_netrom(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void* data _
 	return tvb_captured_length(tvb);
 }
 
-void
-capture_netrom( const guchar *pd _U_, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
+gboolean
+capture_netrom( const guchar *pd _U_, int offset, int len, packet_counts *ld _U_, const union wtap_pseudo_header *pseudo_header _U_)
 {
 	if ( ! BYTES_ARE_IN_FRAME( offset, len, NETROM_MIN_SIZE ) )
-		{
-		ld->other++;
-		return;
-		}
+		return FALSE;
+
 	/* XXX - check for IP-over-NetROM here! */
-	ld->other++;
+	return FALSE;
 }
 
 void
diff --git a/epan/dissectors/packet-netrom.h b/epan/dissectors/packet-netrom.h
index 62f9183e1b..c6e8828914 100644
--- a/epan/dissectors/packet-netrom.h
+++ b/epan/dissectors/packet-netrom.h
@@ -25,6 +25,6 @@
 #ifndef __PACKET_NETROM_H__
 #define __PACKET_NETROM_H__
 
-void capture_netrom(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_netrom(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
 
 #endif
diff --git a/epan/dissectors/packet-null.c b/epan/dissectors/packet-null.c
index 41d7b12cad..ee514ebdc9 100644
--- a/epan/dissectors/packet-null.c
+++ b/epan/dissectors/packet-null.c
@@ -65,7 +65,7 @@ static const value_string family_vals[] = {
 static dissector_handle_t ppp_hdlc_handle;
 static dissector_handle_t data_handle;
 
-static void
+static gboolean
 capture_null( const guchar *pd, int offset _U_, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_ )
 {
   guint32 null_header;
@@ -252,23 +252,21 @@ capture_null( const guchar *pd, int offset _U_, int len, packet_counts *ld, cons
    * digits would be zero and the next 2 hex digits would not be zero.
    * Furthermore, the third hex digit from the bottom would be <
    */
-  if (!BYTES_ARE_IN_FRAME(0, len, 2)) {
-    ld->other++;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(0, len, 2))
+    return FALSE;
+
   if (pd[0] == 0xFF && pd[1] == 0x03) {
     /*
      * Hand it to PPP.
      */
-    capture_ppp_hdlc(pd, 0, len, ld, pseudo_header);
+    return capture_ppp_hdlc(pd, 0, len, ld, pseudo_header);
   } else {
     /*
      * Treat it as a normal DLT_NULL header.
      */
-    if (!BYTES_ARE_IN_FRAME(0, len, (int)sizeof(null_header))) {
-      ld->other++;
-      return;
-    }
+    if (!BYTES_ARE_IN_FRAME(0, len, (int)sizeof(null_header)))
+      return FALSE;
+
     memcpy((char *)&null_header, (const char *)&pd[0], sizeof(null_header));
 
     if ((null_header & 0xFFFF0000) != 0) {
@@ -317,56 +315,47 @@ capture_null( const guchar *pd, int offset _U_, int len, packet_counts *ld, cons
      * BSD derivatives have different values?).
      */
     if (null_header > IEEE_802_3_MAX_LEN)
-      capture_ethertype((guint16) null_header, pd, 4, len, ld, pseudo_header);
+      return try_capture_dissector("ethertype", null_header, pd, 4, len, ld, pseudo_header);
     else {
 
       switch (null_header) {
 
       case BSD_AF_INET:
-        capture_ip(pd, 4, len, ld, pseudo_header);
-        break;
+        return capture_ip(pd, 4, len, ld, pseudo_header);
 
       case BSD_AF_INET6_BSD:
       case BSD_AF_INET6_FREEBSD:
       case BSD_AF_INET6_DARWIN:
-        capture_ipv6(pd, 4, len, ld, pseudo_header);
-        break;
-
-      default:
-        ld->other++;
-        break;
+        return capture_ipv6(pd, 4, len, ld, pseudo_header);
       }
     }
   }
+
+  return FALSE;
 }
 
-static void
+static gboolean
 capture_loop( const guchar *pd, int offset _U_, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_ )
 {
   guint32 loop_family;
 
-  if (!BYTES_ARE_IN_FRAME(0, len, (int)sizeof(loop_family))) {
-    ld->other++;
-    return;
-  }
+  if (!BYTES_ARE_IN_FRAME(0, len, (int)sizeof(loop_family)))
+    return FALSE;
+
   loop_family = pntoh32(&pd[0]);
 
   switch (loop_family) {
 
   case BSD_AF_INET:
-    capture_ip(pd, 4, len, ld, pseudo_header);
-    break;
+    return capture_ip(pd, 4, len, ld, pseudo_header);
 
   case BSD_AF_INET6_BSD:
   case BSD_AF_INET6_FREEBSD:
   case BSD_AF_INET6_DARWIN:
-    capture_ipv6(pd, 4, len, ld, pseudo_header);
-    break;
-
-  default:
-    ld->other++;
-    break;
+    return capture_ipv6(pd, 4, len, ld, pseudo_header);
   }
+
+  return FALSE;
 }
 
 static int
@@ -535,9 +524,6 @@ proto_register_null(void)
   proto_register_field_array(proto_null, hf, array_length(hf));
   proto_register_subtree_array(ett, array_length(ett));
 
-  register_capture_dissector(WTAP_ENCAP_NULL, capture_null, proto_null);
-  register_capture_dissector(WTAP_ENCAP_LOOP, capture_loop, proto_null);
-
   /* subdissector code */
   null_dissector_table = register_dissector_table("null.type",
                                                   "Null type", FT_UINT32, BASE_DEC, DISSECTOR_TABLE_NOT_ALLOW_DUPLICATE);
@@ -562,6 +548,9 @@ proto_reg_handoff_null(void)
 
   loop_handle = create_dissector_handle(dissect_loop, proto_null);
   dissector_add_uint("wtap_encap", WTAP_ENCAP_LOOP, loop_handle);
+
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_NULL, capture_null, proto_null);
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_LOOP, capture_loop, proto_null);
 }
 
 /*
diff --git a/epan/dissectors/packet-pktap.c b/epan/dissectors/packet-pktap.c
index bf7c08658b..b4508808c3 100644
--- a/epan/dissectors/packet-pktap.c
+++ b/epan/dissectors/packet-pktap.c
@@ -94,22 +94,18 @@ static dissector_handle_t pktap_handle;
  * to host byte order in libwiretap.
  */
 
-static void
+static gboolean
 capture_pktap(const guchar *pd, int offset _U_, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
 	guint32  hdrlen, rectype, dlt;
 
 	hdrlen = pletoh32(pd);
-	if (hdrlen < MIN_PKTAP_HDR_LEN || !BYTES_ARE_IN_FRAME(0, len, hdrlen)) {
-		ld->other++;
-		return;
-	}
+	if (hdrlen < MIN_PKTAP_HDR_LEN || !BYTES_ARE_IN_FRAME(0, len, hdrlen))
+		return FALSE;
 
 	rectype = pletoh32(pd+4);
-	if (rectype != PKT_REC_PACKET) {
-		ld->other++;
-		return;
-	}
+	if (rectype != PKT_REC_PACKET)
+		return FALSE;
 
 	dlt = pletoh32(pd+4);
 
@@ -117,14 +113,11 @@ capture_pktap(const guchar *pd, int offset _U_, int len, packet_counts *ld, cons
 	switch (dlt) {
 
 	case 1: /* DLT_EN10MB */
-		capture_eth(pd, hdrlen, len, ld, pseudo_header);
-		return;
+		return capture_eth(pd, hdrlen, len, ld, pseudo_header);
 
-	default:
-		break;
 	}
 
-	ld->other++;
+	return FALSE;
 }
 
 static int
@@ -278,13 +271,6 @@ proto_register_pktap(void)
 	expert_pktap = expert_register_protocol(proto_pktap);
 	expert_register_field_array(expert_pktap, ei, array_length(ei));
 
-	/* XXX - WTAP_ENCAP_USER2 to handle Mavericks' botch wherein it
-		uses DLT_USER2 for PKTAP; if you are using DLT_USER2 for your
-		own purposes, feel free to call your own capture_ routine for
-		WTAP_ENCAP_USER2. */
-	register_capture_dissector(WTAP_ENCAP_PKTAP, capture_pktap, proto_pktap);
-	register_capture_dissector(WTAP_ENCAP_USER2, capture_pktap, proto_pktap);
-
 	pktap_handle = register_dissector("pktap", dissect_pktap, proto_pktap);
 }
 
@@ -292,6 +278,13 @@ void
 proto_reg_handoff_pktap(void)
 {
 	dissector_add_uint("wtap_encap", WTAP_ENCAP_PKTAP, pktap_handle);
+
+	/* XXX - WTAP_ENCAP_USER2 to handle Mavericks' botch wherein it
+		uses DLT_USER2 for PKTAP; if you are using DLT_USER2 for your
+		own purposes, feel free to call your own capture_ routine for
+		WTAP_ENCAP_USER2. */
+	register_capture_dissector("wtap_encap", WTAP_ENCAP_PKTAP, capture_pktap, proto_pktap);
+	register_capture_dissector("wtap_encap", WTAP_ENCAP_USER2, capture_pktap, proto_pktap);
 }
 
 /*
diff --git a/epan/dissectors/packet-ppi.c b/epan/dissectors/packet-ppi.c
index 1094172bea..78ca36c363 100644
--- a/epan/dissectors/packet-ppi.c
+++ b/epan/dissectors/packet-ppi.c
@@ -386,33 +386,27 @@ static reassembly_table ampdu_reassembly_table;
 static gboolean ppi_ampdu_reassemble = TRUE;
 
 
-static void
+static gboolean
 capture_ppi(const guchar *pd, int offset _U_, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
     guint32  dlt;
     guint    ppi_len;
 
     ppi_len = pletoh16(pd+2);
-    if(ppi_len < PPI_V0_HEADER_LEN || !BYTES_ARE_IN_FRAME(0, len, ppi_len)) {
-        ld->other++;
-        return;
-    }
+    if(ppi_len < PPI_V0_HEADER_LEN || !BYTES_ARE_IN_FRAME(0, len, ppi_len))
+        return FALSE;
 
     dlt = pletoh32(pd+4);
 
     /* XXX - We should probably combine this with capture_info.c:capture_info_packet() */
     switch(dlt) {
         case 1: /* DLT_EN10MB */
-            capture_eth(pd, ppi_len, len, ld, pseudo_header);
-            return;
+            return capture_eth(pd, ppi_len, len, ld, pseudo_header);
         case 105: /* DLT_DLT_IEEE802_11 */
-            capture_ieee80211(pd, ppi_len, len, ld, pseudo_header);
-            return;
-        default:
-            break;
+            return capture_ieee80211(pd, ppi_len, len, ld, pseudo_header);
     }
 
-    ld->other++;
+    return FALSE;
 }
 
 static void
@@ -1495,7 +1489,6 @@ proto_register_ppi(void)
     expert_register_field_array(expert_ppi, ei, array_length(ei));
 
     ppi_handle = register_dissector("ppi", dissect_ppi, proto_ppi);
-    register_capture_dissector(WTAP_ENCAP_PPI, capture_ppi, proto_ppi);
 
     register_init_routine(ampdu_reassemble_init);
     register_cleanup_routine(ampdu_reassemble_cleanup);
@@ -1520,6 +1513,7 @@ proto_reg_handoff_ppi(void)
     ppi_fnet_handle = find_dissector("ppi_fnet");
 
     dissector_add_uint("wtap_encap", WTAP_ENCAP_PPI, ppi_handle);
+    register_capture_dissector("wtap_encap", WTAP_ENCAP_PPI, capture_ppi, proto_ppi);
 }
 
 /*
diff --git a/epan/dissectors/packet-ppp.c b/epan/dissectors/packet-ppp.c
index 5b5585a82e..68a468bbc9 100644
--- a/epan/dissectors/packet-ppp.c
+++ b/epan/dissectors/packet-ppp.c
@@ -1950,35 +1950,28 @@ decode_fcs(tvbuff_t *tvb, proto_tree *fh_tree, int fcs_decode, int proto_offset)
     return next_tvb;
 }
 
-void
+gboolean
 capture_ppp_hdlc(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
-    if (!BYTES_ARE_IN_FRAME(offset, len, 2)) {
-        ld->other++;
-        return;
-    }
-    if (pd[0] == CHDLC_ADDR_UNICAST || pd[0] == CHDLC_ADDR_MULTICAST) {
-        capture_chdlc(pd, offset, len, ld, pseudo_header);
-        return;
-    }
-    if (!BYTES_ARE_IN_FRAME(offset, len, 4)) {
-        ld->other++;
-        return;
-    }
+    if (!BYTES_ARE_IN_FRAME(offset, len, 2))
+        return FALSE;
+
+    if (pd[0] == CHDLC_ADDR_UNICAST || pd[0] == CHDLC_ADDR_MULTICAST)
+        return capture_chdlc(pd, offset, len, ld, pseudo_header);
+
+    if (!BYTES_ARE_IN_FRAME(offset, len, 4))
+        return FALSE;
+
     switch (pntoh16(&pd[offset + 2])) {
     case PPP_IP:
-        capture_ip(pd, offset + 4, len, ld, pseudo_header);
-        break;
+        return capture_ip(pd, offset + 4, len, ld, pseudo_header);
     case PPP_IPX:
-        capture_ipx(pd, offset + 4, len, ld, pseudo_header);
-        break;
+        return capture_ipx(pd, offset + 4, len, ld, pseudo_header);
     case PPP_VINES:
-        capture_vines(pd, offset + 4, len, ld, pseudo_header);
-        break;
-    default:
-        ld->other++;
-        break;
+        return capture_vines(pd, offset + 4, len, ld, pseudo_header);
     }
+
+    return FALSE;
 }
 
 static void
@@ -5598,8 +5591,6 @@ proto_register_ppp_raw_hdlc(void)
         "PPP-HDLC", "ppp_hdlc");
     proto_register_subtree_array(ett, array_length(ett));
     proto_register_field_array(proto_ppp_hdlc, hf, array_length(hf));
-
-    register_capture_dissector(WTAP_ENCAP_PPP, capture_ppp_hdlc, proto_ppp_hdlc);
 }
 
 void
@@ -5613,6 +5604,7 @@ proto_reg_handoff_ppp_raw_hdlc(void)
     dissector_add_uint("gre.proto", ETHERTYPE_3GPP2, ppp_raw_hdlc_handle);
 
     heur_dissector_add("usb.bulk", dissect_ppp_usb, "PPP USB bulk endpoint", "ppp_usb_bulk", proto_ppp, HEURISTIC_ENABLE);
+    register_capture_dissector("wtap_encap", WTAP_ENCAP_PPP, capture_ppp_hdlc, proto_ppp_hdlc);
 }
 
 /*
diff --git a/epan/dissectors/packet-ppp.h b/epan/dissectors/packet-ppp.h
index aeb5e54981..85f4b24602 100644
--- a/epan/dissectors/packet-ppp.h
+++ b/epan/dissectors/packet-ppp.h
@@ -29,7 +29,7 @@
 extern gboolean ppp_vj_decomp;/* FALSE = No VJ header decompression,
                                  TRUE  = Decompress VJ */
 extern
-void capture_ppp_hdlc(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header _U_);
+gboolean capture_ppp_hdlc(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header _U_);
 
 tvbuff_t *decode_fcs(tvbuff_t *tvb, proto_tree *fh_tree, int fcs_decode, int proto_offset);
 
diff --git a/epan/dissectors/packet-raw.c b/epan/dissectors/packet-raw.c
index f4faf407d9..87655ede01 100644
--- a/epan/dissectors/packet-raw.c
+++ b/epan/dissectors/packet-raw.c
@@ -43,7 +43,7 @@ static dissector_handle_t ipv6_handle;
 static dissector_handle_t data_handle;
 static dissector_handle_t ppp_hdlc_handle;
 
-static void
+static gboolean
 capture_raw(const guchar *pd, int offset _U_, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
   /* So far, the only time we get raw connection types are with Linux and
@@ -55,21 +55,21 @@ capture_raw(const guchar *pd, int offset _U_, int len, packet_counts *ld, const
    * sometimes.  This check should be removed when 2.2 is out.
    */
   if (BYTES_ARE_IN_FRAME(0,len,2) && pd[0] == 0xff && pd[1] == 0x03) {
-    capture_ppp_hdlc(pd, 0, len, ld, pseudo_header);
+    return capture_ppp_hdlc(pd, 0, len, ld, pseudo_header);
   }
   /* The Linux ISDN driver sends a fake MAC address before the PPP header
    * on its ippp interfaces... */
   else if (BYTES_ARE_IN_FRAME(0,len,8) && pd[6] == 0xff && pd[7] == 0x03) {
-    capture_ppp_hdlc(pd, 6, len, ld, pseudo_header);
+    return capture_ppp_hdlc(pd, 6, len, ld, pseudo_header);
   }
   /* ...except when it just puts out one byte before the PPP header... */
   else if (BYTES_ARE_IN_FRAME(0,len,3) && pd[1] == 0xff && pd[2] == 0x03) {
-    capture_ppp_hdlc(pd, 1, len, ld, pseudo_header);
+    return capture_ppp_hdlc(pd, 1, len, ld, pseudo_header);
   }
   /* ...and if the connection is currently down, it sends 10 bytes of zeroes
    * instead of a fake MAC address and PPP header. */
   else if (BYTES_ARE_IN_FRAME(0,len,10) && memcmp(pd, zeroes, 10) == 0) {
-    capture_ip(pd, 10, len, ld, pseudo_header);
+    return capture_ip(pd, 10, len, ld, pseudo_header);
   }
   else {
     /*
@@ -80,18 +80,18 @@ capture_raw(const guchar *pd, int offset _U_, int len, packet_counts *ld, const
 
       case 0x40:
         /* IPv4 */
-        capture_ip(pd, 0, len, ld, pseudo_header);
-        break;
+        return capture_ip(pd, 0, len, ld, pseudo_header);
 
 #if 0
       case 0x60:
         /* IPv6 */
-        capture_ipv6(pd, 0, len, ld, pseudo_header);
-        break;
+        return capture_ipv6(pd, 0, len, ld, pseudo_header);
 #endif
       }
     }
   }
+
+  return FALSE;
 }
 
 static int
@@ -172,8 +172,6 @@ proto_register_raw(void)
 
   proto_raw = proto_register_protocol("Raw packet data", "Raw", "raw");
   proto_register_subtree_array(ett, array_length(ett));
-
-  register_capture_dissector(WTAP_ENCAP_RAW_IP, capture_raw, proto_raw);
 }
 
 void
@@ -191,6 +189,7 @@ proto_reg_handoff_raw(void)
   ppp_hdlc_handle = find_dissector("ppp_hdlc");
   raw_handle = create_dissector_handle(dissect_raw, proto_raw);
   dissector_add_uint("wtap_encap", WTAP_ENCAP_RAW_IP, raw_handle);
+  register_capture_dissector("wtap_encap", WTAP_ENCAP_RAW_IP, capture_raw, proto_raw);
 }
 
 /*
diff --git a/epan/dissectors/packet-sll.c b/epan/dissectors/packet-sll.c
index 18205f155c..dc1253dcf9 100644
--- a/epan/dissectors/packet-sll.c
+++ b/epan/dissectors/packet-sll.c
@@ -137,15 +137,14 @@ static dissector_table_t sll_linux_dissector_table;
 static dissector_table_t gre_dissector_table;
 static dissector_handle_t data_handle;
 
-static void
+static gboolean
 capture_sll(const guchar *pd, int offset _U_, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
 	guint16 protocol;
 
-	if (!BYTES_ARE_IN_FRAME(0, len, SLL_HEADER_SIZE)) {
-		ld->other++;
-		return;
-	}
+	if (!BYTES_ARE_IN_FRAME(0, len, SLL_HEADER_SIZE))
+		return FALSE;
+
 	protocol = pntoh16(&pd[14]);
 	if (protocol <= 1536) {	/* yes, 1536 - that's how Linux does it */
 		/*
@@ -158,37 +157,31 @@ capture_sll(const guchar *pd, int offset _U_, int len, packet_counts *ld, const
 			/*
 			 * 802.2 LLC.
 			 */
-			capture_llc(pd, len, SLL_HEADER_SIZE, ld, pseudo_header);
-			break;
+			return capture_llc(pd, len, SLL_HEADER_SIZE, ld, pseudo_header);
 
 		case LINUX_SLL_P_ETHERNET:
 			/*
 			 * Ethernet.
 			 */
-			capture_eth(pd, SLL_HEADER_SIZE, len, ld, pseudo_header);
-			break;
+			return capture_eth(pd, SLL_HEADER_SIZE, len, ld, pseudo_header);
 
 		case LINUX_SLL_P_802_3:
 			/*
 			 * Novell IPX inside 802.3 with no 802.2 LLC
 			 * header.
 			 */
-			capture_ipx(pd, SLL_HEADER_SIZE, len, ld, pseudo_header);
-			break;
+			return capture_ipx(pd, SLL_HEADER_SIZE, len, ld, pseudo_header);
 
 		case LINUX_SLL_P_PPPHDLC:
 			/*
 			 * PPP HDLC.
 			 */
-			capture_ppp_hdlc(pd, len, SLL_HEADER_SIZE, ld, pseudo_header);
-			break;
-
-		default:
-			ld->other++;
-			break;
+			return capture_ppp_hdlc(pd, len, SLL_HEADER_SIZE, ld, pseudo_header);
 		}
-	} else
-		capture_ethertype(protocol, pd, SLL_HEADER_SIZE, len, ld, pseudo_header);
+	} else {
+		return try_capture_dissector("ethertype", protocol, pd, SLL_HEADER_SIZE, len, ld, pseudo_header);
+	}
+	return FALSE;
 }
 
 static int
@@ -336,8 +329,6 @@ proto_register_sll(void)
 	proto_register_fields(proto_sll, hfi, array_length(hfi));
 	proto_register_subtree_array(ett, array_length(ett));
 
-	register_capture_dissector(WTAP_ENCAP_SLL, capture_sll, proto_sll);
-
 	sll_handle = create_dissector_handle(dissect_sll, proto_sll);
 
 	sll_linux_dissector_table = register_dissector_table (
@@ -359,6 +350,7 @@ proto_reg_handoff_sll(void)
 	ethertype_handle = find_dissector("ethertype");
 
 	dissector_add_uint("wtap_encap", WTAP_ENCAP_SLL, sll_handle);
+	register_capture_dissector("wtap_encap", WTAP_ENCAP_SLL, capture_sll, hfi_sll->id);
 }
 
 /*
diff --git a/epan/dissectors/packet-tr.c b/epan/dissectors/packet-tr.c
index bebdfdfc3a..2227d6ff8e 100644
--- a/epan/dissectors/packet-tr.c
+++ b/epan/dissectors/packet-tr.c
@@ -246,7 +246,7 @@ int check_for_old_linux(const guchar * pd)
 static void
 add_ring_bridge_pairs(int rcf_len, tvbuff_t*, proto_tree *tree);
 
-void
+gboolean
 capture_tr(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_) {
 
 	int			source_routed = 0;
@@ -260,10 +260,8 @@ capture_tr(const guchar *pd, int offset, int len, packet_counts *ld, const union
 	guint8			trn_fc;		/* field control field */
 	const guint8		*trn_shost;	/* source host */
 
-	if (!BYTES_ARE_IN_FRAME(offset, len, TR_MIN_HEADER_LEN)) {
-		ld->other++;
-		return;
-	}
+	if (!BYTES_ARE_IN_FRAME(offset, len, TR_MIN_HEADER_LEN))
+		return FALSE;
 
 	if ((x = check_for_old_linux(pd)))
 	{
@@ -359,20 +357,13 @@ capture_tr(const guchar *pd, int offset, int len, packet_counts *ld, const union
 
 	offset += actual_rif_bytes + TR_MIN_HEADER_LEN;
 
-	/* The package is either MAC or LLC */
+	/* The package is either MAC (0) or LLC (1)*/
 	switch (frame_type) {
-		/* MAC */
-		case 0:
-			ld->other++;
-			break;
 		case 1:
-			capture_llc(pd, offset, len, ld, pseudo_header);
-			break;
-		default:
-			/* non-MAC, non-LLC, i.e., "Reserved" */
-			ld->other++;
-			break;
+			return capture_llc(pd, offset, len, ld, pseudo_header);
 	}
+
+	return FALSE;
 }
 
 
@@ -801,7 +792,6 @@ proto_register_tr(void)
 	    &fix_linux_botches);
 
 	register_dissector("tr", dissect_tr, proto_tr);
-	register_capture_dissector(WTAP_ENCAP_TOKEN_RING, capture_tr, proto_tr);
 	tr_tap=register_tap("tr");
 
 	register_conversation_table(proto_tr, TRUE, tr_conversation_packet, tr_hostlist_packet);
@@ -822,6 +812,8 @@ proto_reg_handoff_tr(void)
 	tr_handle = find_dissector("tr");
 	dissector_add_uint("wtap_encap", WTAP_ENCAP_TOKEN_RING, tr_handle);
 	dissector_add_uint("sflow_245.header_protocol", SFLOW_245_HEADER_TOKENRING, tr_handle);
+
+	register_capture_dissector("wtap_encap", WTAP_ENCAP_TOKEN_RING, capture_tr, proto_tr);
 }
 
 /*
diff --git a/epan/dissectors/packet-tr.h b/epan/dissectors/packet-tr.h
index 6880f23c7f..1eacd51b3f 100644
--- a/epan/dissectors/packet-tr.h
+++ b/epan/dissectors/packet-tr.h
@@ -32,6 +32,6 @@ typedef struct _tr_hdr {
 } tr_hdr;
 
 extern
-void capture_tr(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_tr(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
 
 #endif
diff --git a/epan/dissectors/packet-vines.c b/epan/dissectors/packet-vines.c
index 07e2cc524f..58cf57d01b 100644
--- a/epan/dissectors/packet-vines.c
+++ b/epan/dissectors/packet-vines.c
@@ -83,6 +83,7 @@
 #include "config.h"
 
 #include <epan/packet.h>
+#include <epan/capture_dissectors.h>
 #include "packet-vines.h"
 #include <epan/etypes.h>
 #include <epan/ppptypes.h>
@@ -308,10 +309,11 @@ typedef struct _e_vipc {
 	guint16 vipc_err_len;
 } e_vipc;
 
-void
+gboolean
 capture_vines(const guchar *pd _U_, int offset _U_, int len _U_, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_)
 {
 	ld->vines++;
+	return TRUE;
 }
 
 static dissector_handle_t vines_ip_handle;
@@ -2015,6 +2017,8 @@ proto_reg_handoff_vines_icp(void)
 	vines_icp_handle = create_dissector_handle(dissect_vines_icp,
 	    proto_vines_icp);
 	dissector_add_uint("vines_ip.protocol", VIP_PROTO_ICP, vines_icp_handle);
+	register_capture_dissector("ethertype", ETHERTYPE_VINES_IP, capture_vines, proto_vines_ip);
+	register_capture_dissector("ethertype", ETHERTYPE_VINES_ECHO, capture_vines, proto_vines_echo);
 }
 
 /*
diff --git a/epan/dissectors/packet-vines.h b/epan/dissectors/packet-vines.h
index b33d7092c5..d7902df0c5 100644
--- a/epan/dissectors/packet-vines.h
+++ b/epan/dissectors/packet-vines.h
@@ -26,6 +26,6 @@
 #ifndef __PACKETVINES_H__
 #define __PACKETVINES_H__
 
-void capture_vines(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header);
+gboolean capture_vines(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header);
 
 #endif /* packet-vines.h */
diff --git a/epan/dissectors/packet-vlan.c b/epan/dissectors/packet-vlan.c
index 778f512e6a..061840f488 100644
--- a/epan/dissectors/packet-vlan.c
+++ b/epan/dissectors/packet-vlan.c
@@ -25,12 +25,12 @@
 #include "config.h"
 
 #include <epan/packet.h>
+#include <epan/capture_dissectors.h>
 #include <wsutil/pint.h>
 #include <epan/expert.h>
 #include "packet-ieee8023.h"
 #include "packet-ipx.h"
 #include "packet-llc.h"
-#include "packet-vlan.h"
 #include <epan/etypes.h>
 #include <epan/prefs.h>
 #include <epan/to_str.h>
@@ -98,23 +98,22 @@ static gint ett_vlan = -1;
 
 static expert_field ei_vlan_len = EI_INIT;
 
-void
+static gboolean
 capture_vlan(const guchar *pd, int offset, int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header _U_ ) {
   guint16 encap_proto;
-  if ( !BYTES_ARE_IN_FRAME(offset,len,5) ) {
-    ld->other++;
-    return;
-  }
+  if ( !BYTES_ARE_IN_FRAME(offset,len,5) )
+    return FALSE;
+
   encap_proto = pntoh16( &pd[offset+2] );
   if ( encap_proto <= IEEE_802_3_MAX_LEN) {
     if ( pd[offset+4] == 0xff && pd[offset+5] == 0xff ) {
-      capture_ipx(pd,offset+4,len,ld, pseudo_header);
+      return capture_ipx(pd,offset+4,len,ld, pseudo_header);
     } else {
-      capture_llc(pd,offset+4,len,ld, pseudo_header);
+      return capture_llc(pd,offset+4,len,ld, pseudo_header);
     }
-  } else {
-    capture_ethertype(encap_proto, pd, offset+4, len, ld, pseudo_header);
   }
+
+  return try_capture_dissector("ethertype", encap_proto, pd, offset+4, len, ld, pseudo_header);
 }
 
 static void
@@ -269,6 +268,7 @@ proto_reg_handoff_vlan(void)
   ethertype_handle = find_dissector("ethertype");
 
   dissector_add_uint("ethertype", q_in_q_ethertype, vlan_handle);
+  register_capture_dissector("ethertype", ETHERTYPE_VLAN, capture_vlan, hfi_vlan->id);
 }
 
 /*
diff --git a/epan/dissectors/packet-vlan.h b/epan/dissectors/packet-vlan.h
deleted file mode 100644
index 4523f5ea64..0000000000
--- a/epan/dissectors/packet-vlan.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/* packet-vlan.h
- *
- * Wireshark - Network traffic analyzer
- * By Gerald Combs <gerald@wireshark.org>
- * Copyright 1998 Gerald Combs
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-#ifndef __PACKET_VLAN_H__
-#define __PACKET_VLAN_H__
-
-void capture_vlan(const guchar *, int, int, packet_counts *, const union wtap_pseudo_header *pseudo_header);
-
-#endif
diff --git a/epan/packet.h b/epan/packet.h
index 5b98f2396d..a075b6afcf 100644
--- a/epan/packet.h
+++ b/epan/packet.h
@@ -699,9 +699,6 @@ extern void dissect_file(struct epan_dissect *edt,
     struct wtap_pkthdr *phdr, tvbuff_t *tvb,
     frame_data *fd, column_info *cinfo);
 
-/* These functions are in packet-ethertype.c */
-extern void capture_ethertype(guint16 etype, const guchar *pd, int offset,
-		int len, packet_counts *ld, const union wtap_pseudo_header *pseudo_header);
 /* Structure passed to the ethertype dissector */
 typedef struct ethertype_data_s
 {