Merging upstream version 4.4.0.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 134 insertions, 82 deletions

diff --git a/epan/packet.h b/epan/packet.h
index 80003c6f..81c6fe2b 100644
--- a/epan/packet.h
+++ b/epan/packet.h
@@ -10,19 +10,17 @@
 
 #ifndef __PACKET_H__
 #define __PACKET_H__
-#include <wireshark.h>
 
+#include <wsutil/array.h>
 #include <wiretap/wtap_opttypes.h>
 #include "proto.h"
 #include "tvbuff.h"
 #include "epan.h"
-#include "value_string.h"
 #include "frame_data.h"
 #include "packet_info.h"
 #include "column-utils.h"
 #include "guid-utils.h"
 #include "tfs.h"
-#include "unit_strings.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -38,17 +36,14 @@ struct epan_range;
 #define hi_nibble(b) (((b) & 0xf0) >> 4)
 #define lo_nibble(b) ((b) & 0x0f)
 
-/* Useful when you have an array whose size you can tell at compile-time */
-#define array_length(x)	(sizeof x / sizeof x[0])
-
 /* Check whether the "len" bytes of data starting at "offset" is
  * entirely inside the captured data for this packet. */
 #define	BYTES_ARE_IN_FRAME(offset, captured_len, len) \
-	((guint)(offset) + (guint)(len) > (guint)(offset) && \
-	 (guint)(offset) + (guint)(len) <= (guint)(captured_len))
+	((unsigned)(offset) + (unsigned)(len) > (unsigned)(offset) && \
+	 (unsigned)(offset) + (unsigned)(len) <= (unsigned)(captured_len))
 
-/* 0 is case insenstive for backwards compatibility with tables that
- * used FALSE or BASE_NONE for case sensitive, which was the default.
+/* 0 is case insensitive for backwards compatibility with tables that
+ * used false or BASE_NONE for case sensitive, which was the default.
  */
 #define STRING_CASE_SENSITIVE 0
 #define STRING_CASE_INSENSITIVE 1
@@ -89,9 +84,9 @@ typedef int (*dissector_cb_t)(tvbuff_t *, packet_info *, proto_tree *, void *, v
  * @param tvb the tvbuff with the (remaining) packet data
  * @param pinfo the packet info of this packet (additional info)
  * @param tree the protocol tree to be build or NULL
- * @return TRUE if the packet was recognized by the sub-dissector (stop dissection here)
+ * @return true if the packet was recognized by the sub-dissector (stop dissection here)
  */
-typedef gboolean (*heur_dissector_t)(tvbuff_t *tvb, packet_info *pinfo,
+typedef bool (*heur_dissector_t)(tvbuff_t *tvb, packet_info *pinfo,
 	proto_tree *tree, void *);
 
 typedef enum {
@@ -99,12 +94,12 @@ typedef enum {
     HEURISTIC_ENABLE
 } heuristic_enable_e;
 
-typedef void (*DATFunc) (const gchar *table_name, ftenum_t selector_type,
-    gpointer key, gpointer value, gpointer user_data);
-typedef void (*DATFunc_handle) (const gchar *table_name, gpointer value,
-    gpointer user_data);
-typedef void (*DATFunc_table) (const gchar *table_name, const gchar *ui_name,
-    gpointer user_data);
+typedef void (*DATFunc) (const char *table_name, ftenum_t selector_type,
+    void *key, void *value, void *user_data);
+typedef void (*DATFunc_handle) (const char *table_name, void *value,
+    void *user_data);
+typedef void (*DATFunc_table) (const char *table_name, const char *ui_name,
+    void *user_data);
 
 /* Opaque structure - provides type checking but no access to components */
 typedef struct dtbl_entry dtbl_entry_t;
@@ -122,7 +117,7 @@ WS_DLL_PUBLIC dissector_handle_t dtbl_entry_get_initial_handle (dtbl_entry_t * e
  * @param[in] user_data User data to pass to the function.
  */
 void dissector_table_foreach_changed (const char *table_name, DATFunc func,
-    gpointer user_data);
+    void *user_data);
 
 /** Iterate over dissectors in a table.
  *
@@ -134,7 +129,7 @@ void dissector_table_foreach_changed (const char *table_name, DATFunc func,
  * @param[in] user_data User data to pass to the function.
  */
 WS_DLL_PUBLIC void dissector_table_foreach (const char *table_name, DATFunc func,
-    gpointer user_data);
+    void *user_data);
 
 /** Iterate over dissectors with non-default "decode as" settings.
  *
@@ -145,7 +140,7 @@ WS_DLL_PUBLIC void dissector_table_foreach (const char *table_name, DATFunc func
  * @param[in] user_data User data to pass to the function.
  */
 WS_DLL_PUBLIC void dissector_all_tables_foreach_changed (DATFunc func,
-    gpointer user_data);
+    void *user_data);
 
 /** Iterate over dissectors in a table by handle.
  *
@@ -157,7 +152,7 @@ WS_DLL_PUBLIC void dissector_all_tables_foreach_changed (DATFunc func,
  * @param[in] user_data User data to pass to the function.
  */
 WS_DLL_PUBLIC void dissector_table_foreach_handle(const char *table_name, DATFunc_handle func,
-    gpointer user_data);
+    void *user_data);
 
 /** Iterate over all dissector tables.
  *
@@ -168,7 +163,7 @@ WS_DLL_PUBLIC void dissector_table_foreach_handle(const char *table_name, DATFun
  * @param[in] compare_key_func Function used to sort the set of tables before
  * calling the function.  No sorting is done if NULL. */
 WS_DLL_PUBLIC void dissector_all_tables_foreach_table (DATFunc_table func,
-    gpointer user_data, GCompareFunc compare_key_func);
+    void *user_data, GCompareFunc compare_key_func);
 
 /* a protocol uses the function to register a sub-dissector table
  *
@@ -217,11 +212,11 @@ WS_DLL_PUBLIC int get_dissector_table_param(const char *name);
 WS_DLL_PUBLIC void dissector_dump_dissector_tables(void);
 
 /* Add an entry to a uint dissector table. */
-WS_DLL_PUBLIC void dissector_add_uint(const char *name, const guint32 pattern,
+WS_DLL_PUBLIC void dissector_add_uint(const char *name, const uint32_t pattern,
     dissector_handle_t handle);
 
 /* Add an entry to a uint dissector table with "preference" automatically added. */
-WS_DLL_PUBLIC void dissector_add_uint_with_preference(const char *name, const guint32 pattern,
+WS_DLL_PUBLIC void dissector_add_uint_with_preference(const char *name, const uint32_t pattern,
     dissector_handle_t handle);
 
 /* Add an range of entries to a uint dissector table. */
@@ -234,7 +229,7 @@ WS_DLL_PUBLIC void dissector_add_uint_range_with_preference(const char *abbrev,
 
 /* Delete the entry for a dissector in a uint dissector table
    with a particular pattern. */
-WS_DLL_PUBLIC void dissector_delete_uint(const char *name, const guint32 pattern,
+WS_DLL_PUBLIC void dissector_delete_uint(const char *name, const uint32_t pattern,
     dissector_handle_t handle);
 
 /* Delete an range of entries from a uint dissector table. */
@@ -246,30 +241,30 @@ WS_DLL_PUBLIC void dissector_delete_all(const char *name, dissector_handle_t han
 
 /* Change the entry for a dissector in a uint dissector table
    with a particular pattern to use a new dissector handle. */
-WS_DLL_PUBLIC void dissector_change_uint(const char *abbrev, const guint32 pattern,
+WS_DLL_PUBLIC void dissector_change_uint(const char *abbrev, const uint32_t pattern,
     dissector_handle_t handle);
 
 /* Reset an entry in a uint dissector table to its initial value. */
-WS_DLL_PUBLIC void dissector_reset_uint(const char *name, const guint32 pattern);
+WS_DLL_PUBLIC void dissector_reset_uint(const char *name, const uint32_t pattern);
 
-/* Return TRUE if an entry in a uint dissector table is found and has been
+/* Return true if an entry in a uint dissector table is found and has been
  * changed (i.e. dissector_change_uint() has been called, such as from
  * Decode As, prefs registered via dissector_add_uint_[range_]with_preference),
- * etc.), otherwise return FALSE.
+ * etc.), otherwise return false.
  */
-WS_DLL_PUBLIC gboolean dissector_is_uint_changed(dissector_table_t const sub_dissectors, const guint32 uint_val);
+WS_DLL_PUBLIC bool dissector_is_uint_changed(dissector_table_t const sub_dissectors, const uint32_t uint_val);
 
 /* Look for a given value in a given uint dissector table and, if found,
    call the dissector with the arguments supplied, and return the number
    of bytes consumed, otherwise return 0. */
 WS_DLL_PUBLIC int dissector_try_uint(dissector_table_t sub_dissectors,
-    const guint32 uint_val, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
+    const uint32_t uint_val, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
 
 /* Look for a given value in a given uint dissector table and, if found,
    call the dissector with the arguments supplied, and return the number
    of bytes consumed, otherwise return 0. */
 WS_DLL_PUBLIC int dissector_try_uint_new(dissector_table_t sub_dissectors,
-    const guint32 uint_val, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, const gboolean add_proto_name, void *data);
+    const uint32_t uint_val, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, const bool add_proto_name, void *data);
 
 /** Look for a given value in a given uint dissector table and, if found,
  * return the current dissector handle for that value.
@@ -279,7 +274,7 @@ WS_DLL_PUBLIC int dissector_try_uint_new(dissector_table_t sub_dissectors,
  * @return The matching dissector handle on success, NULL if no match is found.
  */
 WS_DLL_PUBLIC dissector_handle_t dissector_get_uint_handle(
-    dissector_table_t const sub_dissectors, const guint32 uint_val);
+    dissector_table_t const sub_dissectors, const uint32_t uint_val);
 
 /** Look for a given value in a given uint dissector table and, if found,
  * return the default dissector handle for that value.
@@ -289,42 +284,42 @@ WS_DLL_PUBLIC dissector_handle_t dissector_get_uint_handle(
  * @return The matching dissector handle on success, NULL if no match is found.
  */
 WS_DLL_PUBLIC dissector_handle_t dissector_get_default_uint_handle(
-    const char *name, const guint32 uint_val);
+    const char *name, const uint32_t uint_val);
 
 /* Add an entry to a string dissector table. */
-WS_DLL_PUBLIC void dissector_add_string(const char *name, const gchar *pattern,
+WS_DLL_PUBLIC void dissector_add_string(const char *name, const char *pattern,
     dissector_handle_t handle);
 
 /* Delete the entry for a dissector in a string dissector table
    with a particular pattern. */
-WS_DLL_PUBLIC void dissector_delete_string(const char *name, const gchar *pattern,
+WS_DLL_PUBLIC void dissector_delete_string(const char *name, const char *pattern,
 	dissector_handle_t handle);
 
 /* Change the entry for a dissector in a string dissector table
    with a particular pattern to use a new dissector handle. */
-WS_DLL_PUBLIC void dissector_change_string(const char *name, const gchar *pattern,
+WS_DLL_PUBLIC void dissector_change_string(const char *name, const char *pattern,
     dissector_handle_t handle);
 
 /* Reset an entry in a string sub-dissector table to its initial value. */
-WS_DLL_PUBLIC void dissector_reset_string(const char *name, const gchar *pattern);
+WS_DLL_PUBLIC void dissector_reset_string(const char *name, const char *pattern);
 
-/* Return TRUE if an entry in a string dissector table is found and has been
+/* Return true if an entry in a string dissector table is found and has been
  * changed (i.e. dissector_change_string() has been called, such as from
- * Decode As), otherwise return FALSE.
+ * Decode As), otherwise return false.
  */
-WS_DLL_PUBLIC gboolean dissector_is_string_changed(dissector_table_t const subdissectors, const gchar *string);
+WS_DLL_PUBLIC bool dissector_is_string_changed(dissector_table_t const subdissectors, const char *string);
 
 /* Look for a given string in a given dissector table and, if found, call
    the dissector with the arguments supplied, and return the number of
    bytes consumed, otherwise return 0. */
 WS_DLL_PUBLIC int dissector_try_string(dissector_table_t sub_dissectors,
-    const gchar *string, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data);
+    const char *string, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, void *data);
 
 /* Look for a given string in a given dissector table and, if found, call
    the dissector with the arguments supplied, and return the number of
    bytes consumed, otherwise return 0. */
 WS_DLL_PUBLIC int dissector_try_string_new(dissector_table_t sub_dissectors,
-    const gchar *string, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, const gboolean add_proto_name,void *data);
+    const char *string, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, const bool add_proto_name,void *data);
 
 /** Look for a given value in a given string dissector table and, if found,
  * return the current dissector handle for that value.
@@ -334,7 +329,7 @@ WS_DLL_PUBLIC int dissector_try_string_new(dissector_table_t sub_dissectors,
  * @return The matching dissector handle on success, NULL if no match is found.
  */
 WS_DLL_PUBLIC dissector_handle_t dissector_get_string_handle(
-    dissector_table_t sub_dissectors, const gchar *string);
+    dissector_table_t sub_dissectors, const char *string);
 
 /** Look for a given value in a given string dissector table and, if found,
  * return the default dissector handle for that value.
@@ -344,7 +339,7 @@ WS_DLL_PUBLIC dissector_handle_t dissector_get_string_handle(
  * @return The matching dissector handle on success, NULL if no match is found.
  */
 WS_DLL_PUBLIC dissector_handle_t dissector_get_default_string_handle(
-    const char *name, const gchar *string);
+    const char *name, const char *string);
 
 /* Add an entry to a "custom" dissector table. */
 WS_DLL_PUBLIC void dissector_add_custom_table_handle(const char *name, void *pattern,
@@ -364,7 +359,7 @@ WS_DLL_PUBLIC dissector_handle_t dissector_get_custom_table_handle(
  */
 typedef struct _guid_key {
     e_guid_t guid;
-    guint16 ver;
+    uint16_t ver;
 } guid_key;
 
 /* Add an entry to a guid dissector table. */
@@ -372,16 +367,20 @@ WS_DLL_PUBLIC void dissector_add_guid(const char *name, guid_key* guid_val,
     dissector_handle_t handle);
 
 /* Look for a given value in a given guid dissector table and, if found,
-   call the dissector with the arguments supplied, and return TRUE,
-   otherwise return FALSE. */
+   call the dissector with the arguments supplied, and return true,
+   otherwise return false. */
 WS_DLL_PUBLIC int dissector_try_guid(dissector_table_t sub_dissectors,
     guid_key* guid_val, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
 
 /* Look for a given value in a given guid dissector table and, if found,
-   call the dissector with the arguments supplied, and return TRUE,
-   otherwise return FALSE. */
+   call the dissector with the arguments supplied, and return true,
+   otherwise return false. */
 WS_DLL_PUBLIC int dissector_try_guid_new(dissector_table_t sub_dissectors,
-    guid_key* guid_val, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, const gboolean add_proto_name, void *data);
+    guid_key* guid_val, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, const bool add_proto_name, void *data);
+
+/* Delete a GUID from a dissector table. */
+WS_DLL_PUBLIC void dissector_delete_guid(const char *name, guid_key* guid_val,
+    dissector_handle_t handle);
 
 /** Look for a given value in a given guid dissector table and, if found,
  * return the current dissector handle for that value.
@@ -403,7 +402,7 @@ WS_DLL_PUBLIC int dissector_try_payload(dissector_table_t sub_dissectors,
    if any, call the dissector with the arguments supplied, and return the
    number of bytes consumed, otherwise return 0. */
 WS_DLL_PUBLIC int dissector_try_payload_new(dissector_table_t sub_dissectors,
-    tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, const gboolean add_proto_name, void *data);
+    tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, const bool add_proto_name, void *data);
 
 /* Change the entry for a dissector in a payload (FT_NONE) dissector table
    with a particular pattern to use a new dissector handle. */
@@ -434,7 +433,7 @@ WS_DLL_PUBLIC GSList *dissector_table_get_dissector_handles(dissector_table_t di
 /** Get a handle to dissector out of a dissector table given the description
  * of what the dissector dissects.
  */
-WS_DLL_PUBLIC dissector_handle_t dissector_table_get_dissector_handle(dissector_table_t dissector_table, const gchar* description);
+WS_DLL_PUBLIC dissector_handle_t dissector_table_get_dissector_handle(dissector_table_t dissector_table, const char* description);
 
 /** Get a dissector table's type
  */
@@ -444,13 +443,13 @@ WS_DLL_PUBLIC ftenum_t dissector_table_get_type(dissector_table_t dissector_tabl
  */
 WS_DLL_PUBLIC void dissector_table_allow_decode_as(dissector_table_t dissector_table);
 
-/** Returns TRUE if dissector table allows "Decode As"
+/** Returns true if dissector table allows "Decode As"
  */
-WS_DLL_PUBLIC gboolean dissector_table_supports_decode_as(dissector_table_t dissector_table);
+WS_DLL_PUBLIC bool dissector_table_supports_decode_as(dissector_table_t dissector_table);
 
 /* List of "heuristic" dissectors (which get handed a packet, look at it,
    and either recognize it as being for their protocol, dissect it, and
-   return TRUE, or don't recognize it and return FALSE) to be called
+   return true, or don't recognize it and return false) to be called
    by another dissector.
 
    This is opaque outside of "packet.c". */
@@ -461,10 +460,10 @@ typedef struct heur_dissector_list *heur_dissector_list_t;
 typedef struct heur_dtbl_entry {
 	heur_dissector_t dissector;
 	protocol_t *protocol; /* this entry's protocol */
-	gchar *list_name;     /* the list name this entry is in the list of */
-	const gchar *display_name;     /* the string used to present heuristic to user */
-	gchar *short_name;     /* string used for "internal" use to uniquely identify heuristic */
-	gboolean enabled;
+	char *list_name;     /* the list name this entry is in the list of */
+	const char *display_name;     /* the string used to present heuristic to user */
+	char *short_name;     /* string used for "internal" use to uniquely identify heuristic */
+	bool enabled;
 	bool enabled_by_default;
 } heur_dtbl_entry_t;
 
@@ -472,6 +471,21 @@ typedef struct heur_dtbl_entry {
  *  Call this in the parent dissectors proto_register function.
  *
  * @param name a unique short name for the list
+ * @param ui_name the name used in the user interface
+ * @param proto the value obtained when registering the protocol
+ */
+WS_DLL_PUBLIC heur_dissector_list_t register_heur_dissector_list_with_description(const char *name, const char *ui_name, const int proto);
+
+/** Get description of heuristic sub-dissector list.
+ *
+ * @param list the dissector list
+ */
+WS_DLL_PUBLIC const char *heur_dissector_list_get_description(heur_dissector_list_t list);
+
+/** A protocol uses this function to register a heuristic sub-dissector list.
+ *  Call this in the parent dissectors proto_register function.
+ *
+ * @param name the name of this protocol
  * @param proto the value obtained when registering the protocol
  */
 WS_DLL_PUBLIC heur_dissector_list_t register_heur_dissector_list(const char *name, const int proto);
@@ -479,10 +493,10 @@ WS_DLL_PUBLIC heur_dissector_list_t register_heur_dissector_list(const char *nam
 /** Deregister a heuristic dissector list by unique short name. */
 void deregister_heur_dissector_list(const char *name);
 
-typedef void (*DATFunc_heur) (const gchar *table_name,
-    struct heur_dtbl_entry *entry, gpointer user_data);
+typedef void (*DATFunc_heur) (const char *table_name,
+    struct heur_dtbl_entry *entry, void *user_data);
 typedef void (*DATFunc_heur_table) (const char *table_name,
-    struct heur_dissector_list *table, gpointer user_data);
+    struct heur_dissector_list *table, void *user_data);
 
 /** Iterate over heuristic dissectors in a table.
  *
@@ -494,7 +508,7 @@ typedef void (*DATFunc_heur_table) (const char *table_name,
  * @param[in] user_data User data to pass to the function.
  */
 WS_DLL_PUBLIC void heur_dissector_table_foreach(const char *table_name,
-    DATFunc_heur func, gpointer user_data);
+    DATFunc_heur func, void *user_data);
 
 /** Iterate over all heuristic dissector tables.
  *
@@ -505,10 +519,10 @@ WS_DLL_PUBLIC void heur_dissector_table_foreach(const char *table_name,
  * @param[in] compare_key_func Function used to sort the set of tables before
  * calling the function.  No sorting is done if NULL. */
 WS_DLL_PUBLIC void dissector_all_heur_tables_foreach_table (DATFunc_heur_table func,
-    gpointer user_data, GCompareFunc compare_key_func);
+    void *user_data, GCompareFunc compare_key_func);
 
 /* true if a heur_dissector list of that name exists to be registered into */
-WS_DLL_PUBLIC gboolean has_heur_dissector_list(const gchar *name);
+WS_DLL_PUBLIC bool has_heur_dissector_list(const char *name);
 
 /** Try all the dissectors in a given heuristic dissector list. This is done,
  *  until we find one that recognizes the protocol.
@@ -520,9 +534,9 @@ WS_DLL_PUBLIC gboolean has_heur_dissector_list(const gchar *name);
  * @param tree the protocol tree to be build or NULL
  * @param hdtbl_entry returns the last tried dissectors hdtbl_entry.
  * @param data parameter to pass to subdissector
- * @return TRUE if the packet was recognized by the sub-dissector (stop dissection here)
+ * @return true if the packet was recognized by the sub-dissector (stop dissection here)
  */
-WS_DLL_PUBLIC gboolean dissector_try_heuristic(heur_dissector_list_t sub_dissectors,
+WS_DLL_PUBLIC bool dissector_try_heuristic(heur_dissector_list_t sub_dissectors,
     tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, heur_dtbl_entry_t **hdtbl_entry, void *data);
 
 /** Find a heuristic dissector table by table name.
@@ -601,11 +615,49 @@ WS_DLL_PUBLIC dissector_handle_t find_dissector_add_dependency(const char *name,
 /** Get a dissector name from handle. */
 WS_DLL_PUBLIC const char *dissector_handle_get_dissector_name(const dissector_handle_t handle);
 
-/** Create an anonymous handle for a dissector. */
+WS_DLL_PUBLIC const char *dissector_handle_get_pref_suffix(const dissector_handle_t handle);
+
+/** Create an anonymous, unregistered dissector handle. Unregistered means that
+ * other dissectors can't find the dissector through this API. The typical use
+ * case is dissectors added to dissector tables that shouldn't be called by other
+ * dissectors, perhaps if some data structure must be passed to the dissector.
+ *
+ * @param dissector The dissector the handle will call
+ * @param proto The value obtained when registering the protocol
+ *
+ * @note The protocol short name will be used as the user-visible description.
+ */
 WS_DLL_PUBLIC dissector_handle_t create_dissector_handle(dissector_t dissector,
     const int proto);
+
+/** Create an named, unregistered dissector handle.
+ * A non-NULL name is needed for dissector_add_for_decode_add_with_preference().
+ *
+ * @param dissector The dissector the handle will call
+ * @param proto The value obtained when registering the protocol
+ * @param name a short, machine-friendly name for the dissector. Does not have
+ * to be globally unique, but should be unique for any table the handle will be
+ * registered to. Can be NULL, which creates an anonymous dissector.
+ *
+ * @note The protocol short name will be used as the user-visible description.
+ */
 WS_DLL_PUBLIC dissector_handle_t create_dissector_handle_with_name(dissector_t dissector,
     const int proto, const char* name);
+
+/** Create an named, unregistered handle dissector handle with a description.
+ * A non-NULL name is needed for dissector_add_for_decode_add_with_preference().
+ * The description is used to allow a user to distinguish dissectors for the
+ * same protocol, e.g. when registered to the same table.
+ *
+ * @param dissector The dissector the handle will call
+ * @param proto The value obtained when registering the protocol
+ * @param name a short, machine-friendly name for the dissector. Does not have
+ * to be globally unique, but should be unique for any table the handle will be
+ * registered to. Can be NULL, which creates an anonymous dissector.
+ * @param description Freeform text designed to be shown to a user. Must be
+ * unique for any table the dissector is registered in. Can be NULL, in which
+ * case the protocol short name is used as the user-visible description.
+ */
 WS_DLL_PUBLIC dissector_handle_t create_dissector_handle_with_name_and_description(dissector_t dissector,
     const int proto, const char* name, const char* description);
 WS_DLL_PUBLIC dissector_handle_t create_dissector_handle_with_data(dissector_cb_t dissector,
@@ -673,9 +725,9 @@ typedef struct depend_dissector_list *depend_dissector_list_t;
  *
  *   @param parent "Parent" protocol short name
  *   @param dependent "Dependent" protocol short name
- *   @return  return TRUE if dependency was successfully registered
+ *   @return  return true if dependency was successfully registered
  */
-WS_DLL_PUBLIC gboolean register_depend_dissector(const char* parent, const char* dependent);
+WS_DLL_PUBLIC bool register_depend_dissector(const char* parent, const char* dependent);
 
 /** Unregister a protocol dependency
  * This is done automatically when removing from a dissector or
@@ -684,9 +736,9 @@ WS_DLL_PUBLIC gboolean register_depend_dissector(const char* parent, const char*
  *
  *   @param parent "Parent" protocol short name
  *   @param dependent "Dependent" protocol short name
- *   @return  return TRUE if dependency was successfully unregistered
+ *   @return  return true if dependency was successfully unregistered
  */
-WS_DLL_PUBLIC gboolean deregister_depend_dissector(const char* parent, const char* dependent);
+WS_DLL_PUBLIC bool deregister_depend_dissector(const char* parent, const char* dependent);
 
 /** Find the list of protocol dependencies
  *
@@ -705,7 +757,7 @@ extern void dissect_cleanup(void);
  * Given a tvbuff, and a length from a packet header, adjust the length
  * of the tvbuff to reflect the specified length.
  */
-WS_DLL_PUBLIC void set_actual_length(tvbuff_t *tvb, const guint specified_len);
+WS_DLL_PUBLIC void set_actual_length(tvbuff_t *tvb, const unsigned specified_len);
 
 /**
  * Allow protocols to register "init" routines, which are called before
@@ -788,7 +840,7 @@ extern void free_data_sources(packet_info *pinfo);
  * if the user does a File->Save-As of only the Displayed packets and the
  * current frame passed the display filter.
  */
-WS_DLL_PUBLIC void mark_frame_as_depended_upon(frame_data *fd, guint32 frame_num);
+WS_DLL_PUBLIC void mark_frame_as_depended_upon(frame_data *fd, uint32_t frame_num);
 
 /* Structure passed to the frame dissector */
 typedef struct frame_data_s
@@ -822,7 +874,7 @@ extern void dissect_file(struct epan_dissect *edt,
 /* Structure passed to the ethertype dissector */
 typedef struct ethertype_data_s
 {
-    guint16 etype;
+    uint16_t etype;
     int payload_offset;
     proto_tree *fh_tree;
     int trailer_id;
@@ -865,11 +917,11 @@ WS_DLL_PUBLIC void set_postdissector_wanted_hfids(dissector_handle_t handle,
 void deregister_postdissector(dissector_handle_t handle);
 
 /*
- * Return TRUE if we have at least one postdissector, FALSE if not.
+ * Return true if we have at least one postdissector, false if not.
  * Not for use in (post)dissectors or applications; only to be used
  * by libwireshark itself.
  */
-extern gboolean have_postdissector(void);
+extern bool have_postdissector(void);
 
 /*
  * Call all postdissectors, handing them the supplied arguments.
@@ -879,10 +931,10 @@ extern gboolean have_postdissector(void);
 extern void call_all_postdissectors(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
 
 /*
- * Return TRUE if at least one postdissector needs at least one hfid,
- * FALSE otherwise.
+ * Return true if at least one postdissector needs at least one hfid,
+ * false otherwise.
  */
-WS_DLL_PUBLIC gboolean postdissectors_want_hfids(void);
+WS_DLL_PUBLIC bool postdissectors_want_hfids(void);
 
 /*
  * Prime an epan_dissect_t with all the hfids wanted by postdissectors.