proto.h

Go to the documentation of this file.

/* proto.h
 * Definitions for protocol display
 *
 * Wireshark - Network traffic analyzer
 * By Gerald Combs <gerald@wireshark.org>
 * Copyright 1998 Gerald Combs
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 
#ifndef __PROTO_H__
#define __PROTO_H__
 
#include "wsutil/nstime.h"
#include "tvbuff.h"
#include "value_string.h"
#include "packet_info.h"
#include "ftypes/ftypes.h"
#include "register.h"
#include "ws_symbol_export.h"
#include "ws_attributes.h"
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
WS_DLL_PUBLIC int hf_text_only;
 
#define ITEM_LABEL_LENGTH       240
 
#define ITEM_LABEL_UNKNOWN_STR  "Unknown"
 
struct expert_field;
 
/* Type-check that 'x' is compatible with 'type', should give compiler warnings otherwise. */
#define cast_same(type, x) (0 ? (type)0 : (x))
 
#define VALS(x)     (cast_same(const struct _value_string*, (x)))
 
#define VALS64(x)   (cast_same(const struct _val64_string*, (x)))
 
#define VALS_EXT_PTR(x) (cast_same(value_string_ext*, (x)))
 
#define TIME_VALS(x)     (cast_same(const struct _time_value_string*, (x)))
 
#define TFS(x)      (cast_same(const struct true_false_string*, (x)))
 
#define UNS(x)      (cast_same(const struct unit_name_string*, (x)))
 
typedef void (*custom_fmt_func_t)(char *, uint32_t);
 
typedef void (*custom_fmt_func_64_t)(char *, uint64_t);
 
typedef void (*custom_fmt_func_double_t)(char *, double);
 
#define CF_FUNC(x) ((const void *) (size_t) (x))
 
#define RVALS(x) (cast_same(const struct _range_string*, (x)))
 
#define FRAMENUM_TYPE(x) GINT_TO_POINTER(x)
 
struct _protocol;
 
typedef struct _protocol protocol_t;
 
WS_DLL_PUBLIC WS_NORETURN
void proto_report_dissector_bug(const char *format, ...)
    G_GNUC_PRINTF(1, 2);
 
#define REPORT_DISSECTOR_BUG(...)  \
    proto_report_dissector_bug(__VA_ARGS__)
 
#ifdef _MSC_VER
/* XXX - Is there a way to say "quit checking at this point"? */
#define __DISSECTOR_ASSERT_STATIC_ANALYSIS_HINT(expression) \
  ; __analysis_assume(expression);
#else
#define __DISSECTOR_ASSERT_STATIC_ANALYSIS_HINT(expression)
#endif
 
#define __DISSECTOR_ASSERT_STRINGIFY(s) # s
 
#define __DISSECTOR_ASSERT(expression, file, lineno)  \
  (REPORT_DISSECTOR_BUG("%s:%u: failed assertion \"%s\"", \
        file, lineno, __DISSECTOR_ASSERT_STRINGIFY(expression)))
 
#define __DISSECTOR_ASSERT_HINT(expression, file, lineno, hint)  \
  (REPORT_DISSECTOR_BUG("%s:%u: failed assertion \"%s\" (%s)", \
        file, lineno, __DISSECTOR_ASSERT_STRINGIFY(expression), hint))
 
#define DISSECTOR_ASSERT(expression)  \
  ((void) ((expression) ? (void)0 : \
   __DISSECTOR_ASSERT (expression, __FILE__, __LINE__))) \
   __DISSECTOR_ASSERT_STATIC_ANALYSIS_HINT(expression)
 
#define DISSECTOR_ASSERT_HINT(expression, hint)  \
  ((void) ((expression) ? (void)0 : \
   __DISSECTOR_ASSERT_HINT (expression, __FILE__, __LINE__, hint))) \
   __DISSECTOR_ASSERT_STATIC_ANALYSIS_HINT(expression)
#define DISSECTOR_ASSERT_HINT(expression, hint)  \ …
 
#if 0
/* win32: using a debug breakpoint (int 3) can be very handy while debugging,
 * as the assert handling of GTK/GLib is currently not very helpful */
#define DISSECTOR_ASSERT(expression)  \
{ if(!(expression)) _asm { int 3}; }
#endif
 
#define DISSECTOR_ASSERT_NOT_REACHED()  \
  (REPORT_DISSECTOR_BUG("%s:%u: failed assertion \"DISSECTOR_ASSERT_NOT_REACHED\"", \
        __FILE__, __LINE__))
#define DISSECTOR_ASSERT_NOT_REACHED()  \ …
 
#define __DISSECTOR_ASSERT_CMPINT(a, op, b, type, fmt) \
  (REPORT_DISSECTOR_BUG("%s:%u: failed assertion " #a " " #op " " #b " (" fmt " " #op " " fmt ")", \
        __FILE__, __LINE__, (type)a, (type)b))
#define __DISSECTOR_ASSERT_CMPINT(a, op, b, type, fmt) \ …
 
#define DISSECTOR_ASSERT_CMPINT(a, op, b)  \
  ((void) ((a op b) ? (void)0 : \
   __DISSECTOR_ASSERT_CMPINT (a, op, b, int64_t, "%" PRId64))) \
   __DISSECTOR_ASSERT_STATIC_ANALYSIS_HINT(a op b)
 
#define DISSECTOR_ASSERT_CMPUINT(a, op, b)  \
  ((void) ((a op b) ? (void)0 : \
   __DISSECTOR_ASSERT_CMPINT (a, op, b, uint64_t, "%" PRIu64))) \
   __DISSECTOR_ASSERT_STATIC_ANALYSIS_HINT(a op b)
#define DISSECTOR_ASSERT_CMPUINT(a, op, b)  \ …
 
#define DISSECTOR_ASSERT_CMPUINTHEX(a, op, b)  \
  ((void) ((a op b) ? (void)0 : \
   __DISSECTOR_ASSERT_CMPINT (a, op, b, uint64_t, "0x%" PRIX64))) \
  __DISSECTOR_ASSERT_STATIC_ANALYSIS_HINT(a op b)
#define DISSECTOR_ASSERT_CMPUINTHEX(a, op, b)  \ …
 
/*
 * This is similar to DISSECTOR_ASSERT(hfinfo->type == type) except that
 * it will report the name of the field with the wrong type as well as
 * the type.
 *
 * @param hfinfo  The hfinfo for the field being tested
 * @param type    The type it's expected to have
 */
#define __DISSECTOR_ASSERT_FIELD_TYPE(hfinfo, t) \
  (REPORT_DISSECTOR_BUG("%s:%u: field %s is not of type "#t, \
        __FILE__, __LINE__, (hfinfo)->abbrev))
 
#define DISSECTOR_ASSERT_FIELD_TYPE(hfinfo, t)  \
  ((void) (((hfinfo)->type == t) ? (void)0 : \
   __DISSECTOR_ASSERT_FIELD_TYPE ((hfinfo), t))) \
   __DISSECTOR_ASSERT_STATIC_ANALYSIS_HINT((hfinfo)->type == t)
 
#define DISSECTOR_ASSERT_FIELD_TYPE_IS_INTEGRAL(hfinfo)  \
  ((void) ((FT_IS_INTEGER((hfinfo)->type)) ? (void)0 : \
   REPORT_DISSECTOR_BUG("%s:%u: field %s is not of type FT_CHAR or an FT_{U}INTn type", \
         __FILE__, __LINE__, (hfinfo)->abbrev))) \
   __DISSECTOR_ASSERT_STATIC_ANALYSIS_HINT(FT_IS_INTEGER((hfinfo)->type))
 
#define __DISSECTOR_ASSERT_FIELD_TYPE_IS_STRING(hfinfo) \
  (REPORT_DISSECTOR_BUG("%s:%u: field %s is not of type FT_STRING, FT_STRINGZ, FT_STRINGZPAD, FT_STRINGZTRUNC, or FT_UINT_STRING", \
        __FILE__, __LINE__, (hfinfo)->abbrev))
 
#define DISSECTOR_ASSERT_FIELD_TYPE_IS_STRING(hfinfo)  \
  ((void) (FT_IS_STRING((hfinfo)->type) ? (void)0 : \
   __DISSECTOR_ASSERT_FIELD_TYPE_IS_STRING ((hfinfo)))) \
   __DISSECTOR_ASSERT_STATIC_ANALYSIS_HINT(FT_IS_STRING((hfinfo)->type))
 
#define __DISSECTOR_ASSERT_FIELD_TYPE_IS_TIME(hfinfo) \
  (REPORT_DISSECTOR_BUG("%s:%u: field %s is not of type FT_ABSOLUTE_TIME or FT_RELATIVE_TIME", \
        __FILE__, __LINE__, (hfinfo)->abbrev))
 
#define DISSECTOR_ASSERT_FIELD_TYPE_IS_TIME(hfinfo)  \
  ((void) (((hfinfo)->type == FT_ABSOLUTE_TIME || \
            (hfinfo)->type == FT_RELATIVE_TIME) ? (void)0 : \
   __DISSECTOR_ASSERT_FIELD_TYPE_IS_TIME ((hfinfo)))) \
   __DISSECTOR_ASSERT_STATIC_ANALYSIS_HINT((hfinfo)->type == FT_ABSOLUTE_TIME || \
                                           (hfinfo)->type == FT_RELATIVE_TIME)
 
/*
 * Encoding flags that apply to multiple data types.
 */
/*
 * The encoding of a field of a particular type may involve more
 * than just whether it's big-endian or little-endian and its size.
 *
 * For integral values, that's it, as 99.9999999999999% of the machines
 * out there are 2's complement binary machines with 8-bit bytes,
 * so the protocols out there expect that and, for example, any Unisys
 * 2200 series machines out there just have to translate between 2's
 * complement and 1's complement (and nobody's put any IBM 709x's on
 * any networks lately :-)).
 *
 * However:
 *
 *  for floating-point numbers, in addition to IEEE decimal
 *  floating-point, there's also IBM System/3x0 and PDP-11/VAX
 *  floating-point - most protocols use IEEE binary, but DCE RPC
 *  can use other formats if that's what the sending host uses;
 *
 *  for character strings, there are various character encodings
 *  (various ISO 646 sets, ISO 8859/x, various other national
 *  standards, various DOS and Windows encodings, various Mac
 *  encodings, UTF-8, UTF-16, other extensions to ASCII, EBCDIC,
 *  etc.);
 *
 *  for absolute times, there's UNIX time_t, UNIX time_t followed
 *  by 32-bit microseconds, UNIX time_t followed by 32-bit
 *  nanoseconds, DOS date/time, Windows FILETIME, NTP time, etc..
 *
 * We might also, in the future, want to allow a field specifier to
 * indicate the encoding of the field, or at least its default
 * encoding, as most fields in most protocols always use the
 * same encoding (although that's not true of all fields, so we
 * still need to be able to specify that at run time).
 *
 * So, for now, we define ENC_BIG_ENDIAN and ENC_LITTLE_ENDIAN as
 * bit flags, to be combined, in the future, with other information
 * to specify the encoding in the last argument to
 * proto_tree_add_item(), and possibly to specify in a field
 * definition (e.g., ORed in with the type value).
 *
 * Currently, proto_tree_add_item() treats its last argument as a
 * Boolean - if it's zero, the field is big-endian, and if it's non-zero,
 * the field is little-endian - and other code in epan/proto.c does
 * the same.  We therefore define ENC_BIG_ENDIAN as 0x00000000 and
 * ENC_LITTLE_ENDIAN as 0x80000000 - we're using the high-order bit
 * so that we could put a field type and/or a value such as a character
 * encoding in the lower bits.
 */
#define ENC_BIG_ENDIAN      0x00000000
#define ENC_LITTLE_ENDIAN   0x80000000
 
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
    #define ENC_HOST_ENDIAN      ENC_LITTLE_ENDIAN
    #define ENC_ANTI_HOST_ENDIAN ENC_BIG_ENDIAN
#else
    #define ENC_HOST_ENDIAN      ENC_BIG_ENDIAN
    #define ENC_ANTI_HOST_ENDIAN ENC_LITTLE_ENDIAN
#endif
 
/*
 * For protocols (FT_PROTOCOL), aggregate items with subtrees (FT_NONE),
 * opaque byte-array fields (FT_BYTES), and other fields where there
 * is no choice of encoding (either because it's "just a bucket
 * of bytes" or because the encoding is completely fixed), we
 * have ENC_NA (for "Not Applicable").
 */
#define ENC_NA          0x00000000
 
/*
 * Encoding for character strings - and for character-encoded values
 * for non-string types.
 *
 * Historically, the only place the representation mattered for strings
 * was with FT_UINT_STRINGs, where we had false for the string length
 * being big-endian and true for it being little-endian.
 *
 * We now have encoding values for the character encoding.  The encoding
 * values are encoded in all but the top bit (which is the byte-order
 * bit, required for FT_UINT_STRING and for UCS-2 and UTF-16 strings)
 * and the bottom bit (which we ignore for now so that programs that
 * pass true for the encoding just do ASCII).
 *
 * For ENC_ASCII, we map ASCII characters with the high bit set to the UTF-8
 * REPLACEMENT CHARACTER, and do the same for ENC_UTF_8 with invalid UTF-8
 * sequences. We should also map 0x00 to that as well - null-terminated and
 * null-padded strings never have NULs in them, but counted strings might.
 * Either that, or strings should be counted, not null-terminated. Note
 * that conversion of ASCII and UTF-8 can change the length of the string,
 * as with any other encoding, due to REPLACEMENT CHARACTERs.
 *
 * For display, perhaps we should also map control characters to the
 * Unicode glyphs showing the name of the control character in small
 * caps, diagonally.  (Unfortunately, those only exist for C0, not C1.)
 *
 * *DO NOT* add anything to this set that is not a character encoding!
 */
#define ENC_CHARENCODING_MASK             0x0000FFFE  /* mask out byte-order bits and other bits used with string encodings */
#define ENC_ASCII                         0x00000000
#define ENC_ISO_646_IRV                   ENC_ASCII   /* ISO 646 International Reference Version = ASCII */
#define ENC_UTF_8                         0x00000002
#define ENC_UTF_16                        0x00000004
#define ENC_UCS_2                         0x00000006
#define ENC_UCS_4                         0x00000008
#define ENC_ISO_8859_1                    0x0000000A
#define ENC_ISO_8859_2                    0x0000000C
#define ENC_ISO_8859_3                    0x0000000E
#define ENC_ISO_8859_4                    0x00000010
#define ENC_ISO_8859_5                    0x00000012
#define ENC_ISO_8859_6                    0x00000014
#define ENC_ISO_8859_7                    0x00000016
#define ENC_ISO_8859_8                    0x00000018
#define ENC_ISO_8859_9                    0x0000001A
#define ENC_ISO_8859_10                   0x0000001C
#define ENC_ISO_8859_11                   0x0000001E
/* #define ENC_ISO_8859_12                  0x00000020 ISO 8859-12 was abandoned */
#define ENC_ISO_8859_13                   0x00000022
#define ENC_ISO_8859_14                   0x00000024
#define ENC_ISO_8859_15                   0x00000026
#define ENC_ISO_8859_16                   0x00000028
#define ENC_WINDOWS_1250                  0x0000002A
#define ENC_3GPP_TS_23_038_7BITS_PACKED   0x0000002C
#define ENC_3GPP_TS_23_038_7BITS          ENC_3GPP_TS_23_038_7BITS_PACKED
#define ENC_EBCDIC                        0x0000002E
#define ENC_MAC_ROMAN                     0x00000030
#define ENC_CP437                         0x00000032
#define ENC_ASCII_7BITS                   0x00000034
#define ENC_T61                           0x00000036
#define ENC_EBCDIC_CP037                  0x00000038
#define ENC_WINDOWS_1252                  0x0000003A
#define ENC_WINDOWS_1251                  0x0000003C
#define ENC_CP855                         0x0000003E
#define ENC_CP866                         0x00000040
#define ENC_ISO_646_BASIC                 0x00000042
#define ENC_BCD_DIGITS_0_9                0x00000044 /* Packed BCD, digits 0-9 */
#define ENC_KEYPAD_ABC_TBCD               0x00000046 /* Keypad-with-a/b/c "telephony BCD" = 0-9, *, #, a, b, c */
#define ENC_KEYPAD_BC_TBCD                0x00000048 /* Keypad-with-B/C "telephony BCD" = 0-9, B, C, *, # */
#define ENC_3GPP_TS_23_038_7BITS_UNPACKED 0x0000004C
#define ENC_ETSI_TS_102_221_ANNEX_A       0x0000004E /* ETSI TS 102 221 Annex A */
#define ENC_GB18030                       0x00000050
#define ENC_EUC_KR                        0x00000052
#define ENC_APN_STR                       0x00000054 /* The encoding the APN/DNN field follows 3GPP TS 23.003 [2] clause 9.1.*/
#define ENC_DECT_STANDARD_8BITS           0x00000056 /* DECT standard character set as defined in ETSI EN 300 175-5 Annex D */
#define ENC_DECT_STANDARD_4BITS_TBCD      0x00000058 /* DECT standard 4bits character set as defined in ETSI EN 300 175-5 Annex D (BCD with 0xb = SPACE)*/
#define ENC_EBCDIC_CP500                  0x00000060
/*
 * TODO:
 *
 * packet-bacapp.c refers to two currently unsupported character sets (where
 * we just use ASCII currently):
 *
 *  "IBM MS DBCS" - At the very least could be any IBM/MS Double Byte
 *      Character Set for CJK (4 major ones), but also could just be any non
 *      Unicode and non ISO-8859-1 code page. This would be supported via the
 *      various code pages.
 *  JIS C 6226 / JIS X 0206 - Does this refer to ISO-2022-JP, SHIFT-JIS, or
 *      EUC-JP, which are all encoding schemes that support the JIS X 0206
 *      character set?
 *
 * As those are added, change code such as the code in packet-bacapp.c
 * to use them.
 *
 * There's also some other code (e.g., packet-smpp.c) that just ignores
 * strings if it determines that they are in an unsupported encoding, such
 * as various encodings of Japanese mentioned above, for example.
 *
 */
 
/*
 * This is a modifier for FT_UINT_STRING and FT_UINT_BYTES values;
 * it indicates that the length field should be interpreted as per
 * sections 2.5.2.11 Octet String through 2.5.2.14 Long Character
 * String of the ZigBee Cluster Library Specification, where if all
 * bits are set in the length field, the string has an invalid value,
 * and the number of octets in the value is 0.
 */
#define ENC_ZIGBEE               0x40000000
 
/*
 * This is a modifier for ENC_UTF_16, ENC_UCS_2, and ENC_UCS_4
 * indicating that if the first two (or four, for UCS-4) octets
 * are a big-endian or little-endian BOM, use that to determine
 * the serialization order and ignore the ENC_LITTLE_ENDIAN or
 * ENC_BIG_ENDIAN flag. This can't collide with ENC_ZIGBEE because
 * it could be used simultaneously.
 */
#define ENC_BOM                  0x20000000
 
/*
 * For cases where either native type or string encodings could both be
 * valid arguments, we need something to distinguish which one is being
 * passed as the argument, because ENC_BIG_ENDIAN and ENC_ASCII are both
 * 0x00000000. So we use ENC_STR_NUM or ENC_STR_HEX bit-or'ed with
 * ENC_ASCII and its ilk.
 *
 * XXX - ENC_STR_NUM is not yet supported by any code in Wireshark,
 * and these are only used for byte arrays.  Presumably they could
 * also be used for integral values in the future.
 */
/* this is for strings as numbers "12345" */
#define ENC_STR_NUM     0x01000000
/* this is for strings as hex "1a2b3c" */
#define ENC_STR_HEX     0x02000000
/* a convenience macro for either of the above */
#define ENC_STRING      0x03000000
/* Kept around for compatibility for Lua scripts; code should use ENC_CHARENCODING_MASK */
#define ENC_STR_MASK    0x0000FFFE
 
/*
 * For cases where the number is allowed to have a leading '+'/'-'
 * this can't collide with ENC_SEP_* because they can be used simultaneously
 *
 * XXX - this is not used anywhere in Wireshark's code, dating back to
 * at least Wireshark 2.6 and continuing to the current version.
 * Perhaps the intent was to use it in the future, but 1) I'm not sure
 * why it would be combined with ENC_SEP_, as byte arrays have no sign
 * but integral values do, and 2) if we were to support string encodings
 * for integral types, presumably whether it's signed (FT_INTn) or
 * unsigned (FT_UINTn) would suffice to indicate whether the value
 * can be signed or not.
 */
#define ENC_NUM_PREF    0x00200000
 
/*
 * Encodings for byte arrays.
 *
 * For cases where the byte array is encoded as a string composed of
 * pairs of hex digits, possibly with a separator character between
 * the pairs.  That's specified by the encoding having ENC_STR_HEX,
 * plus one of these values, set.
 *
 * See hex_str_to_bytes_encoding() in epan/strutil.h for details.
 */
#define ENC_SEP_NONE    0x00010000
#define ENC_SEP_COLON   0x00020000
#define ENC_SEP_DASH    0x00040000
#define ENC_SEP_DOT     0x00080000
#define ENC_SEP_SPACE   0x00100000
/* a convenience macro for the above */
#define ENC_SEP_MASK    0x001F0000
 
/* Encodings for BCD strings
 * Depending if the BCD string has even or odd number of digits
 * we may need to strip of the last digit/High nibble
 */
#define ENC_BCD_ODD_NUM_DIG     0x00010000
#define ENC_BCD_SKIP_FIRST      0x00020000
 
/*
 * Encodings for time values.
 *
 * Historically FT_TIMEs were only timespecs; the only question was whether
 * they were stored in big- or little-endian format.
 *
 * For backwards compatibility, we interpret an encoding of 1 as meaning
 * "little-endian timespec", so that passing true is interpreted as that.
 *
 * We now support:
 *
 *  ENC_TIME_SECS_NSECS - 8, 12, or 16 bytes.  For 8 bytes, the first 4
 *  bytes are seconds and the next 4 bytes are nanoseconds; for 12 bytes,
 *  the first 8 bytes are seconds and the next 4 bytes are nanoseconds;
 *  for 16 bytes, the first 8 bytes are seconds and the next 8 bytes are
 *  nanoseconds.  If the time is absolute, the seconds are seconds since
 *  the UN*X epoch (1970-01-01 00:00:00 UTC).  (I.e., a UN*X struct
 *  timespec with a 4-byte or 8-byte time_t or a structure with an
 *  8-byte time_t and an 8-byte nanoseconds field.)
 *
 *  ENC_TIME_NTP - 8 bytes; the first 4 bytes are seconds since the NTP
 *  epoch (1900-01-01 00:00:00 GMT) and the next 4 bytes are 1/2^32's of
 *  a second since that second.  (I.e., a 64-bit count of 1/2^32's of a
 *  second since the NTP epoch, with the upper 32 bits first and the
 *  lower 32 bits second, even when little-endian.)  A value of 0 is a
 *  special case representing unknown or unsynchronized time.  Per the
 *  suggestion in RFC 4330, if bit 0 is not set then the time is assumed
 *  to be in NTP Era 1, beginning on 2036-02-07 06:28:16 UTC.  (I.e., the
 *  time displayed will be between 1968-01-20 03:14:08 UTC and
 *  2104-02-26 09:42:24 UTC.)  The 16 byte NTP date format and the 4 byte
 *  NTP short relative time format are not supported.
 *  Encodings that store only the seconds since the NTP epoch without
 *  fractional seconds should use ENC_TIME_SECS_NTP, described below.
 *
 *  ENC_TIME_TOD - 8 bytes, as a count of microseconds since the System/3x0
 *  and z/Architecture epoch (1900-01-01 00:00:00 GMT).
 *
 *  ENC_TIME_RTPS - 8 bytes; the first 4 bytes are seconds since the UN*X
 *  epoch and the next 4 bytes are 1/2^32's of a second since that
 *  second.  (I.e., it's the offspring of a mating between UN*X time and
 *  NTP time).  It's used by the Object Management Group's Real-Time
 *  Publish-Subscribe Wire Protocol for the Data Distribution Service.
 *
 *  ENC_TIME_SECS_USECS - 8 bytes; the first 4 bytes are seconds and the
 *  next 4 bytes are microseconds.  If the time is absolute, the seconds
 *  are seconds since the UN*X epoch.  (I.e., a UN*X struct timeval with
 *  a 4-byte time_t.)
 *
 *  ENC_TIME_SECS - 4 to 8 bytes, representing a value in seconds.
 *  If the time is absolute, it's seconds since the UN*X epoch.
 *
 *  ENC_TIME_MSECS - 6 to 8 bytes, representing a value in milliseconds.
 *  If the time is absolute, it's milliseconds since the UN*X epoch.
 *
 *  ENC_TIME_USECS - 8 bytes, representing a value in microseconds.
 *  If the time is absolute, it's microseconds since the UN*X epoch.
 *
 *  ENC_TIME_NSECS - 8 bytes, representing a value in nanoseconds.
 *  If the time is absolute, it's nanoseconds since the UN*X epoch.
 *
 *  ENC_TIME_SECS_NTP - 4 bytes, representing a count of seconds since
 *  the NTP epoch.  As with ENC_TIME_NTP, times are assumed to be in
 *  the upper half of NTP Era 0 or the lower half of NTP Era 1.
 *
 *  ENC_TIME_RFC_3971 - 8 bytes, representing a count of 1/64ths of a
 *  second since the UN*X epoch; see section 5.3.1 "Timestamp Option"
 *  in RFC 3971.
 *
 *  ENC_TIME_MSEC_NTP - 6-8 bytes, representing a count of milliseconds since
 *  the NTP epoch.  Similar to ENC_TIME_NTP, times before the midpoint of
 *  NTP Era 0 (1968-01-20) are assumed to represent the corresponding
 *  time in NTP Era 1 instead.
 *
 *  ENC_TIME_MIP6 - 8 bytes; the first 48 bits are seconds since the UN*X epoch
 *  and the remaining 16 bits indicate the number of 1/65536's of a second
 *  since that second.
 *
 *  ENC_TIME_MP4_FILE_SECS - 4-8 bytes, representing a count of seconds since
 *  January 1, 1904, 00:00:00 UTC.
 *
 *  ENC_TIME_ZBEE_ZCL - 4-8 bytes, representing a count of seconds  since
 *  January 1, 2000, 00:00:00  UTC.
 */
#define ENC_TIME_SECS_NSECS          0x00000000
#define ENC_TIME_TIMESPEC            0x00000000 /* for backwards source compatibility */
#define ENC_TIME_NTP                 0x00000002
#define ENC_TIME_TOD                 0x00000004
#define ENC_TIME_RTPS                0x00000008
#define ENC_TIME_NTP_BASE_ZERO       0x00000008 /* for backwards source compatibility */
#define ENC_TIME_SECS_USECS          0x00000010
#define ENC_TIME_TIMEVAL             0x00000010 /* for backwards source compatibility */
#define ENC_TIME_SECS                0x00000012
#define ENC_TIME_MSECS               0x00000014
#define ENC_TIME_SECS_NTP            0x00000018
#define ENC_TIME_RFC_3971            0x00000020
#define ENC_TIME_MSEC_NTP            0x00000022
#define ENC_TIME_MIP6                0x00000024
#define ENC_TIME_MP4_FILE_SECS       0x00000026
#define ENC_TIME_CLASSIC_MAC_OS_SECS 0x00000026 /* for backwards source compatibility */
#define ENC_TIME_NSECS               0x00000028
#define ENC_TIME_USECS               0x00000030
#define ENC_TIME_ZBEE_ZCL            0x00000032
 
/*
 * For cases where a string encoding contains a timestamp, use one
 * of these (but only one). These values can collide with the ENC_SEP_
 * values used when a string encoding contains a byte array, because
 * you can't do both at the same time.  They must not, however,
 * overlap with the character encoding values.
 */
#define ENC_ISO_8601_DATE             0x00010000
#define ENC_ISO_8601_TIME             0x00020000
#define ENC_ISO_8601_DATE_TIME        0x00030000
#define ENC_IMF_DATE_TIME             0x00040000 /* Internet Message Format - RFCs 822, 1123, 2822, 5322 */
#define ENC_RFC_822                   0x00040000 /* backwards compatibility */
#define ENC_RFC_1123                  0x00040000 /* backwards source compatibility - not binary */
#define ENC_ISO_8601_DATE_TIME_BASIC  0x00100000
/* a convenience macro for the above - for internal use only */
#define ENC_STR_TIME_MASK             0x001F0000
 
/*
 * Encodings for variable-length integral types.
 */
 
/* Use varint format as described in Protobuf protocol
 * https://developers.google.cn/protocol-buffers/docs/encoding
 */
#define ENC_VARINT_PROTOBUF      0x00000002
/*
 * Decodes a variable-length integer used in QUIC protocol
 * See https://tools.ietf.org/html/draft-ietf-quic-transport-08#section-8.1
 */
#define ENC_VARINT_QUIC          0x00000004
 /*
 * Use "zig-zag" varint format as described in Protobuf protocol
 * See https://developers.google.com/protocol-buffers/docs/encoding?csw=1#types
 */
#define ENC_VARINT_ZIGZAG        0x00000008
/*
 * Decodes a variable-length integer used in DTN protocols
 * See https://www.rfc-editor.org/rfc/rfc6256.html
 */
#define ENC_VARINT_SDNV          0x00000010
 
#define ENC_VARINT_MASK          (ENC_VARINT_PROTOBUF|ENC_VARINT_QUIC|ENC_VARINT_ZIGZAG|ENC_VARINT_SDNV)
 
/* Values for header_field_info.display */
 
/* For integral types, the display format is a BASE_* field_display_e value
 * possibly ORed with BASE_*_STRING */
 
#define FIELD_DISPLAY_E_MASK 0xFF
 
typedef enum {
    BASE_NONE    = 0,   
/* Integral and float types */
    BASE_DEC,           
    BASE_HEX,           
    BASE_OCT,           
    BASE_DEC_HEX,       
    BASE_HEX_DEC,       
    BASE_CUSTOM,        
    BASE_EXP,           
/* Byte separators */
    SEP_DOT,            
    SEP_DASH,           
    SEP_COLON,          
    SEP_SPACE,          
/* Address types */
    BASE_NETMASK,       
/* Port types */
    BASE_PT_UDP,        
    BASE_PT_TCP,        
    BASE_PT_DCCP,       
    BASE_PT_SCTP,       
/* OUI types */
    BASE_OUI,           
/* Time types */
    ABSOLUTE_TIME_LOCAL,        
    ABSOLUTE_TIME_UTC,          
    ABSOLUTE_TIME_DOY_UTC,      
    ABSOLUTE_TIME_NTP_UTC,      
    ABSOLUTE_TIME_UNIX,         
/* String types */
    BASE_STR_WSP,       
} field_display_e;
typedef enum {…};
 
#define FIELD_DISPLAY(d) ((d) & FIELD_DISPLAY_E_MASK)
 
#define FIELD_DISPLAY_IS_ABSOLUTE_TIME(d) \
        (FIELD_DISPLAY(d) >= ABSOLUTE_TIME_LOCAL && FIELD_DISPLAY(d) <= ABSOLUTE_TIME_UNIX)
 
/* Following constants have to be ORed with a field_display_e when dissector
 * want to use specials value-string MACROs for a header_field_info */
#define BASE_RANGE_STRING         0x00000100  
#define BASE_EXT_STRING           0x00000200
#define BASE_VAL64_STRING         0x00000400
 
#define BASE_ALLOW_ZERO           0x00000800  
#define BASE_UNIT_STRING          0x00001000  
#define BASE_NO_DISPLAY_VALUE     0x00002000  
#define BASE_PROTOCOL_INFO        0x00004000  
#define BASE_SPECIAL_VALS         0x00008000  
#define BASE_SHOW_ASCII_PRINTABLE 0x00010000 
#define BASE_SHOW_UTF_8_PRINTABLE 0x00020000 
#define IS_BASE_DUAL(b) ((b)==BASE_DEC_HEX||(b)==BASE_HEX_DEC)
 
#define IS_BASE_PORT(b) (((b)==BASE_PT_UDP||(b)==BASE_PT_TCP||(b)==BASE_PT_DCCP||(b)==BASE_PT_SCTP))
 
typedef enum {
    HF_REF_TYPE_NONE,       
    HF_REF_TYPE_INDIRECT,   
    HF_REF_TYPE_DIRECT,     
    HF_REF_TYPE_PRINT       
} hf_ref_type;
typedef enum {…};
 
typedef struct _header_field_info header_field_info;
 
struct _header_field_info {
    /* ---------- set by dissector --------- */
    const char        *name;              
    const char        *abbrev;            
    enum ftenum        type;              
    int                display;           
    const void        *strings;           
    uint64_t           bitmask;           
    const char        *blurb;             
    /* ------- set by proto routines (prefilled by HFILL macro, see below) ------ */
    int                id;                
    int                parent;            
    hf_ref_type        ref_type;          
    int                same_name_prev_id; 
    header_field_info *same_name_next;    
};
struct _header_field_info {…};
 
#define HFILL -1, 0, HF_REF_TYPE_NONE, -1, NULL
 
#define HFILL_INIT(hf)   \
    (hf).hfinfo.id                = -1;   \
    (hf).hfinfo.parent            = 0;   \
    (hf).hfinfo.ref_type          = HF_REF_TYPE_NONE;   \
    (hf).hfinfo.same_name_prev_id = -1;   \
    (hf).hfinfo.same_name_next    = NULL;
 
typedef struct hf_register_info {
    int               *p_id;   
    header_field_info  hfinfo; 
} hf_register_info;
typedef struct hf_register_info {…};
 
typedef struct _item_label_t {
    char representation[ITEM_LABEL_LENGTH];
    size_t value_pos;  
    size_t value_len;  
} item_label_t;
typedef struct _item_label_t {…};
 
typedef struct field_info {
    const header_field_info *hfinfo;      
    int                  start;           
    int                  length;          
    int                  appendix_start;  
    int                  appendix_length; 
    int                  tree_type;       
    uint32_t             flags;           
    item_label_t        *rep;             
    tvbuff_t            *ds_tvb;          
    fvalue_t            *value;
    int                 total_layer_num;        
    int                 proto_layer_num;        
} field_info;
typedef struct field_info {…};
 
 
/*
 * This structure describes one segment of a split-bits item
 * crumb_bit_offset is the bit offset in the input tvb of the first (most significant) bit of this crumb
 * crumb_bit_length is the number of contiguous bits of this crumb.
 * The first element of an array of bits_specs describes the most significant crumb of the output value.
 * The second element of an array of bits_specs describes the next-most significant crumb of the output value, etc.
 * The array is terminated by a sentinel entry with crumb_bit_length of 0.
*/
typedef struct
{
    unsigned  crumb_bit_offset;
    uint8_t crumb_bit_length;
} crumb_spec_t;
typedef struct {…};
 
/*
 * Flag fields.  Do not assign values greater than 0x000FFFFF unless you
 * shuffle the expert information upward; see below.
 */
 
#define FI_HIDDEN               0x00000001
#define FI_GENERATED            0x00000002
#define FI_URL                  0x00000004
 
#define FI_LITTLE_ENDIAN        0x00000008
#define FI_BIG_ENDIAN           0x00000010
#define FI_BITS_OFFSET(n)       (((n) & 63) << 5)
/* if 0, it means that field takes fi->length * 8 */
#define FI_BITS_SIZE(n)         (((n) & 63) << 12)
#define FI_VARINT               0x00040000
 
#define FI_GET_FLAG(fi, flag)   ((fi) ? ((fi)->flags & (flag)) : 0)
#define FI_SET_FLAG(fi, flag) \
    do { \
      if (fi) \
        (fi)->flags = (fi)->flags | (flag); \
    } while(0)
#define FI_SET_FLAG(fi, flag) \ …
#define FI_RESET_FLAG(fi, flag) \
    do { \
      if (fi) \
        (fi)->flags = (fi)->flags & ~(flag); \
    } while(0)
#define FI_RESET_FLAG(fi, flag) \ …
 
#define FI_GET_BITS_OFFSET(fi) (FI_GET_FLAG(fi, FI_BITS_OFFSET(63)) >> 5)
#define FI_GET_BITS_SIZE(fi)   (FI_GET_FLAG(fi, FI_BITS_SIZE(63)) >> 12)
 
typedef struct {
    GHashTable          *interesting_hfids;
    bool                 visible;
    bool                 fake_protocols;
    unsigned             count;
    struct _packet_info *pinfo;
    tvbuff_t            *idle_count_ds_tvb;
    int                  max_start;
    unsigned             start_idle_count;
} tree_data_t;
typedef struct  {…};
 
typedef struct _proto_node {
    struct _proto_node *first_child;
    struct _proto_node *last_child;
    struct _proto_node *next;
    struct _proto_node *parent;
    const header_field_info *hfinfo;
    field_info         *finfo;
    tree_data_t        *tree_data;
} proto_node;
typedef struct _proto_node {…};
 
typedef proto_node proto_tree;
typedef proto_node proto_item;
 
/*
 * Expert information.
 * This is in the flags field; we allocate this from the top down,
 * so as not to collide with FI_ flags, which are allocated from
 * the bottom up.
 */
 
/* expert severities */
#define PI_SEVERITY_MASK        0x00F00000  
#define PI_COMMENT              0x00100000
#define PI_CHAT                 0x00200000
#define PI_NOTE                 0x00400000
#define PI_WARN                 0x00600000
#define PI_ERROR                0x00800000
 
/* expert "event groups" */
#define PI_GROUP_MASK           0xFF000000  
#define PI_CHECKSUM             0x01000000
#define PI_SEQUENCE             0x02000000
#define PI_RESPONSE_CODE        0x03000000
#define PI_REQUEST_CODE         0x04000000
#define PI_UNDECODED            0x05000000
#define PI_REASSEMBLE           0x06000000
#define PI_MALFORMED            0x07000000
#define PI_DEBUG                0x08000000
#define PI_PROTOCOL             0x09000000
#define PI_SECURITY             0x0a000000
#define PI_COMMENTS_GROUP       0x0b000000
#define PI_DECRYPTION           0x0c000000
#define PI_ASSUMPTION           0x0d000000
#define PI_DEPRECATED           0x0e000000
#define PI_RECEIVE              0x0f000000
#define PI_INTERFACE            0x10000000
#define PI_DISSECTOR_BUG        0x11000000
 
/*
 * add more, see WSDG: 9.3. How to add an expert item:
 *    https://www.wireshark.org/docs/wsdg_html/#ChDissectExpertInfo
 */
 
#define PNODE_FINFO(proto_node)  ((proto_node)->finfo)
 
#define PITEM_FINFO(proto_item)  PNODE_FINFO(proto_item)
 
#define PTREE_FINFO(proto_tree)  PNODE_FINFO(proto_tree)
 
#define PNODE_HFINFO(proto_node)  ((proto_node)->hfinfo)
 
#define PITEM_HFINFO(proto_item)  PNODE_HFINFO(proto_item)
 
#define PTREE_HFINFO(proto_tree)  PNODE_HFINFO(proto_tree)
 
#define PTREE_DATA(proto_tree)   ((proto_tree)->tree_data)
 
#define PNODE_POOL(proto_node)   ((proto_node)->tree_data->pinfo->pool)
 
static inline bool proto_item_is_hidden(const proto_item *ti) {
    if (ti && PITEM_FINFO(ti)) {
        return FI_GET_FLAG(PITEM_FINFO(ti), FI_HIDDEN);
    }
    /* XXX - Is a NULL item hidden? */
    return true;
}
#define PROTO_ITEM_IS_HIDDEN(ti) proto_item_is_hidden((ti))
 
static inline void proto_item_set_hidden(proto_item *ti) {
    if (ti) {
        FI_SET_FLAG(PITEM_FINFO(ti), FI_HIDDEN);
    }
}
#define PROTO_ITEM_SET_HIDDEN(ti) proto_item_set_hidden((ti))
 
static inline void proto_item_set_visible(proto_item *ti) {
    if (ti) {
        FI_RESET_FLAG(PITEM_FINFO(ti), FI_HIDDEN);
    }
}
#define PROTO_ITEM_SET_VISIBLE(ti) proto_item_set_visible((ti))
 
static inline bool proto_item_is_generated(const proto_item *ti)
{
    if (ti) {
        return FI_GET_FLAG(PITEM_FINFO(ti), FI_GENERATED);
    }
    return false;
}
#define PROTO_ITEM_IS_GENERATED(ti) proto_item_is_generated((ti))
 
static inline void proto_item_set_generated(proto_item *ti) {
    if (ti) {
        FI_SET_FLAG(PITEM_FINFO(ti), FI_GENERATED);
    }
}
#define PROTO_ITEM_SET_GENERATED(ti) proto_item_set_generated((ti))
 
static inline bool proto_item_is_url(const proto_item *ti)
{
    if (ti) {
        return FI_GET_FLAG(PITEM_FINFO(ti), FI_URL);
    }
    return false;
}
#define PROTO_ITEM_IS_URL(ti) proto_item_is_url((ti))
 
static inline void proto_item_set_url(proto_item *ti) {
    if (ti) {
        FI_SET_FLAG(PITEM_FINFO(ti), FI_URL);
    }
}
#define PROTO_ITEM_SET_URL(ti) proto_item_set_url((ti))
 
typedef void (*proto_tree_foreach_func)(proto_node *, void *);
typedef bool (*proto_tree_traverse_func)(proto_node *, void *);
 
WS_DLL_PUBLIC void proto_tree_children_foreach(proto_tree *tree,
    proto_tree_foreach_func func, void *data);
 
typedef struct {
    void (*register_protoinfo)(void);   /* routine to call to register protocol information */
    void (*register_handoff)(void);     /* routine to call to register dissector handoff */
} proto_plugin;
typedef struct  {…};
 
WS_DLL_PUBLIC void proto_register_plugin(const proto_plugin *plugin);
 
void proto_init(GSList *register_all_plugin_protocols_list,
    GSList *register_all_plugin_handoffs_list, register_cb cb, void *client_data);
 
extern void proto_cleanup(void);
 
WS_DLL_PUBLIC bool proto_field_is_referenced(proto_tree *tree, int proto_id);
 
WS_DLL_PUBLIC proto_tree* proto_item_add_subtree(proto_item *pi, const int idx) G_GNUC_WARN_UNUSED_RESULT;
 
WS_DLL_PUBLIC proto_tree* proto_item_get_subtree(proto_item *pi);
 
WS_DLL_PUBLIC proto_item* proto_item_get_parent(const proto_item *pi);
 
WS_DLL_PUBLIC proto_item* proto_item_get_parent_nth(proto_item *pi, int gen);
 
WS_DLL_PUBLIC void proto_item_set_text(proto_item *pi, const char *format, ...)
    G_GNUC_PRINTF(2,3);
 
WS_DLL_PUBLIC void proto_item_append_text(proto_item *pi, const char *format, ...)
    G_GNUC_PRINTF(2,3);
 
WS_DLL_PUBLIC void proto_item_prepend_text(proto_item *pi, const char *format, ...)
    G_GNUC_PRINTF(2,3);
 
WS_DLL_PUBLIC void proto_item_set_len(proto_item *pi, const int length);
 
WS_DLL_PUBLIC void proto_item_set_end(proto_item *pi, tvbuff_t *tvb, int end);
 
WS_DLL_PUBLIC int proto_item_get_len(const proto_item *pi);
 
WS_DLL_PUBLIC void proto_item_set_bits_offset_len(proto_item *ti, int bits_offset, int bits_len);
 
WS_DLL_PUBLIC char *proto_item_get_display_repr(wmem_allocator_t *scope, proto_item *pi);
 
extern proto_tree* proto_tree_create_root(struct _packet_info *pinfo);
 
void proto_tree_reset(proto_tree *tree);
 
WS_DLL_PUBLIC void proto_tree_free(proto_tree *tree);
 
WS_DLL_PUBLIC bool
proto_tree_set_visible(proto_tree *tree, bool visible);
 
extern void
proto_tree_set_fake_protocols(proto_tree *tree, bool fake_protocols);
 
extern void
proto_tree_prime_with_hfid(proto_tree *tree, const int hfid);
 
extern void
proto_tree_prime_with_hfid_print(proto_tree *tree, const int hfid);
 
WS_DLL_PUBLIC proto_item* proto_tree_get_parent(proto_tree *tree);
 
WS_DLL_PUBLIC proto_tree *proto_tree_get_parent_tree(proto_tree *tree);
 
WS_DLL_PUBLIC proto_tree* proto_tree_get_root(proto_tree *tree);
 
WS_DLL_PUBLIC void proto_tree_move_item(proto_tree *tree, proto_item *fixed_item, proto_item *item_to_move);
 
 
WS_DLL_PUBLIC void proto_tree_set_appendix(proto_tree *tree, tvbuff_t *tvb, int start, const int length);
 
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_new(proto_tree *tree, header_field_info *hfinfo, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_new_ret_length(proto_tree *tree, header_field_info *hfinfo, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding, int *lenretval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_length(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding, int *lenretval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_int(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding, int32_t *retval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_int64(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding, int64_t *retval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_uint(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding, uint32_t *retval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_uint64(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding, uint64_t *retval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_varint(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding, uint64_t *retval, int *lenretval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_boolean(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding, bool *retval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_ipv4(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding, ws_in4_addr *retval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_ipv6(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding, ws_in6_addr *retval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_ether(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding, uint8_t *retval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_float(proto_tree *tree, int hfindex, tvbuff_t *tvb,
                                const int start, int length,
                                const unsigned encoding, float *retval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_double(proto_tree *tree, int hfindex, tvbuff_t *tvb,
                                const int start, int length,
                                const unsigned encoding, double *retval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_string_and_length(proto_tree *tree, int hfindex,
    tvbuff_t *tvb, const int start, int length, const unsigned encoding,
    wmem_allocator_t *scope, const uint8_t **retval, int *lenretval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_string(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding,
    wmem_allocator_t *scope, const uint8_t **retval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_display_string_and_length(proto_tree *tree, int hfindex,
    tvbuff_t *tvb,
    const int start, int length, const unsigned encoding,
    wmem_allocator_t *scope, char **retval, int *lenretval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_display_string(proto_tree *tree, int hfindex,
    tvbuff_t *tvb,
    const int start, int length, const unsigned encoding,
    wmem_allocator_t *scope, char **retval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_item_ret_time_string(proto_tree *tree, int hfindex,
    tvbuff_t *tvb,
    const int start, int length, const unsigned encoding,
    wmem_allocator_t *scope, char **retval);
 
proto_item *
proto_tree_add_text_internal(proto_tree *tree, tvbuff_t *tvb, int start, int length, const char *format,
    ...) G_GNUC_PRINTF(5,6);
 
proto_item *
proto_tree_add_text_valist_internal(proto_tree *tree, tvbuff_t *tvb, int start,
    int length, const char *format, va_list ap) G_GNUC_PRINTF(5, 0);
 
WS_DLL_PUBLIC proto_tree *
proto_tree_add_subtree(proto_tree *tree, tvbuff_t *tvb, int start, int length, int idx,
    proto_item **tree_item, const char *text);
 
WS_DLL_PUBLIC proto_tree *
proto_tree_add_subtree_format(proto_tree *tree, tvbuff_t *tvb, int start, int length, int idx,
    proto_item **tree_item, const char *format, ...) G_GNUC_PRINTF(7,8);
 
proto_item *
proto_tree_add_format_text(proto_tree *tree, tvbuff_t *tvb, int start, int length);
 
proto_item *
proto_tree_add_format_wsp_text(proto_tree *tree, tvbuff_t *tvb, int start, int length);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_none_format(proto_tree *tree, const int hfindex, tvbuff_t *tvb, const int start,
    int length, const char *format, ...) G_GNUC_PRINTF(6,7);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_protocol_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const char *format, ...) G_GNUC_PRINTF(6,7);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_bytes(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const uint8_t* start_ptr);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_bytes_with_length(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const uint8_t *start_ptr, int ptr_length);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_bytes_item(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding,
    GByteArray *retval, int *endoff, int *err);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_bytes_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, const uint8_t* start_ptr, const char *format,
    ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_bytes_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const uint8_t* start_ptr, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_time(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const nstime_t* value_ptr);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_time_item(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    const int start, int length, const unsigned encoding,
    nstime_t *retval, int *endoff, int *err);
 
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_time_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, nstime_t* value_ptr, const char *format, ...)
    G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_time_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, nstime_t* value_ptr, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_ipxnet(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, uint32_t value);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_ipxnet_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, uint32_t value, const char *format, ...)
    G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_ipxnet_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, uint32_t value, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_ipv4(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, ws_in4_addr value);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_ipv4_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, ws_in4_addr value, const char *format, ...)
    G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_ipv4_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, ws_in4_addr value, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_ipv6(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const ws_in6_addr *value_ptr);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_ipv6_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, const ws_in6_addr *value_ptr, const char *format,
    ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_ipv6_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const ws_in6_addr *value_ptr, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_ether(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const uint8_t* value);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_ether_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, const uint8_t* value, const char *format, ...)
    G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_ether_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const uint8_t* value, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_guid(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const e_guid_t *value_ptr);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_guid_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, const e_guid_t *value_ptr, const char *format,
    ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_guid_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const e_guid_t *value_ptr, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_oid(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const uint8_t* value_ptr);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_oid_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, const uint8_t* value_ptr, const char *format,
    ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_oid_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const uint8_t* value_ptr, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_string(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const char* value);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_string_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, const char* value, const char *format, ...)
    G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_string_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const char* value, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_boolean(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, uint64_t value);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_boolean_format_value(proto_tree *tree, int hfindex,
    tvbuff_t *tvb, int start, int length, uint64_t value,
    const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_boolean_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, uint64_t value, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_float(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, float value);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_float_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, float value, const char *format, ...)
    G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_float_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, float value, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_double(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, double value);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_double_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, double value, const char *format, ...)
    G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_double_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, double value, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_uint(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, uint32_t value);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_uint_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, uint32_t value, const char *format, ...)
    G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_uint_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, uint32_t value, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_uint64(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, uint64_t value);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_uint64_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, uint64_t value, const char *format, ...)
    G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_uint64_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, uint64_t value, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_int(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, int32_t value);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_int_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, int32_t value, const char *format, ...)
    G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_int_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, int32_t value, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_int64(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, int64_t value);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_int64_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, int64_t value, const char *format, ...)
    G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_int64_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, int64_t value, const char *format, ...) G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_eui64(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const uint64_t value);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_eui64_format_value(proto_tree *tree, int hfindex, tvbuff_t *tvb,
    int start, int length, const uint64_t value, const char *format, ...)
    G_GNUC_PRINTF(7,8);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_eui64_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, int start,
    int length, const uint64_t value, const char *format, ...) G_GNUC_PRINTF(7,8);
 
typedef struct _mac_hf_list_t {
    int *hf_addr;               // FT_ETHER, BASE_NONE
    int *hf_addr_resolved;      // FT_STRING, BASE_NONE
    int *hf_oui;                // FT_UINT24, BASE_OUI
    int *hf_oui_resolved;       // FT_STRING, BASE_NONE
    int *hf_lg;                 // FT_BOOLEAN, 24 bits, mask 0x020000
    int *hf_ig;                 // FT_BOOLEAN, 24 bits, mask 0x010000
} mac_hf_list_t;
typedef struct _mac_hf_list_t {…};
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_mac48_detail(const mac_hf_list_t *list_specific,
    const mac_hf_list_t *list_generic,
    int idx, tvbuff_t *tvb, proto_tree *tree, int offset);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_debug_text(proto_tree *tree, const char *format,
    ...) G_GNUC_PRINTF(2,3);
 
WS_DLL_PUBLIC void
proto_item_fill_label(const field_info *finfo, char *label_str, size_t *value_offset);
 
WS_DLL_PUBLIC int
proto_item_fill_display_label(const field_info *fi, char *display_label_str, const int label_str_size);
 
WS_DLL_PUBLIC int
proto_register_protocol(const char *name, const char *short_name, const char *filter_name);
 
WS_DLL_PUBLIC int
proto_register_protocol_in_name_only(const char *name, const char *short_name, const char *filter_name,
    int parent_proto, enum ftenum field_type);
 
bool
proto_deregister_protocol(const char *short_name);
 
WS_DLL_PUBLIC void
proto_register_alias(const int proto_id, const char *alias_name);
 
typedef void (*prefix_initializer_t)(const char* match);
 
WS_DLL_PUBLIC void
proto_register_prefix(const char *prefix,  prefix_initializer_t initializer);
 
WS_DLL_PUBLIC void proto_initialize_all_prefixes(void);
 
WS_DLL_PUBLIC void
proto_register_field_array(const int parent, hf_register_info *hf, const int num_records);
 
WS_DLL_PUBLIC void
proto_deregister_field (const int parent, int hf_id);
 
WS_DLL_PUBLIC void
proto_add_deregistered_data (void *data);
 
WS_DLL_PUBLIC void
proto_deregister_all_fields_with_prefix(const int parent, const gchar *prefix);
 
void
proto_add_deregistered_slice (size_t block_size, void *mem_block);
 
WS_DLL_PUBLIC void
proto_free_field_strings (ftenum_t field_type, unsigned int field_display, const void *field_strings);
 
WS_DLL_PUBLIC void
proto_free_deregistered_fields (void);
 
WS_DLL_PUBLIC void
proto_register_subtree_array(int * const *indices, const int num_indices);
 
WS_DLL_PUBLIC const char* proto_registrar_get_name(const int n);
 
WS_DLL_PUBLIC const char* proto_registrar_get_abbrev(const int n);
 
WS_DLL_PUBLIC header_field_info* proto_registrar_get_nth(unsigned hfindex);
 
WS_DLL_PUBLIC header_field_info* proto_registrar_get_byname(const char *field_name);
 
WS_DLL_PUBLIC header_field_info* proto_registrar_get_byalias(const char *alias_name);
 
WS_DLL_PUBLIC int proto_registrar_get_id_byname(const char *field_name);
 
WS_DLL_PUBLIC enum ftenum proto_registrar_get_ftype(const int n);
 
WS_DLL_PUBLIC int proto_registrar_get_parent(const int n);
 
WS_DLL_PUBLIC bool proto_registrar_is_protocol(const int n);
 
extern int proto_registrar_get_length(const int n);
 
 
WS_DLL_PUBLIC int proto_get_first_protocol(void **cookie);
WS_DLL_PUBLIC int proto_get_data_protocol(void *cookie);
WS_DLL_PUBLIC int proto_get_next_protocol(void **cookie);
WS_DLL_PUBLIC header_field_info *proto_get_first_protocol_field(const int proto_id, void **cookie);
WS_DLL_PUBLIC header_field_info *proto_get_next_protocol_field(const int proto_id, void **cookie);
 
WS_DLL_PUBLIC bool proto_name_already_registered(const char *name);
 
WS_DLL_PUBLIC int proto_get_id_by_filter_name(const char* filter_name);
 
WS_DLL_PUBLIC int proto_get_id_by_short_name(const char* short_name);
 
WS_DLL_PUBLIC bool proto_can_toggle_protocol(const int proto_id);
 
WS_DLL_PUBLIC protocol_t *find_protocol_by_id(const int proto_id);
 
WS_DLL_PUBLIC const char *proto_get_protocol_name(const int proto_id);
 
WS_DLL_PUBLIC int proto_get_id(const protocol_t *protocol);
 
WS_DLL_PUBLIC const char *proto_get_protocol_short_name(const protocol_t *protocol);
 
WS_DLL_PUBLIC const char *proto_get_protocol_long_name(const protocol_t *protocol);
 
WS_DLL_PUBLIC bool proto_is_protocol_enabled(const protocol_t *protocol);
 
WS_DLL_PUBLIC bool proto_is_protocol_enabled_by_default(const protocol_t *protocol);
 
WS_DLL_PUBLIC bool proto_is_pino(const protocol_t *protocol);
 
WS_DLL_PUBLIC const char *proto_get_protocol_filter_name(const int proto_id);
 
extern void proto_add_heuristic_dissector(protocol_t *protocol, const char *short_name);
 
WS_DLL_PUBLIC void proto_heuristic_dissector_foreach(const protocol_t *protocol, GFunc func,
    void *user_data);
 
WS_DLL_PUBLIC void proto_get_frame_protocols(const wmem_list_t *layers,
      bool *is_ip, bool *is_tcp, bool *is_udp, bool *is_sctp,
      bool *is_tls, bool *is_rtp, bool *is_lte_rlc);
 
WS_DLL_PUBLIC bool proto_is_frame_protocol(const wmem_list_t *layers, const char* proto_name);
 
WS_DLL_PUBLIC char * proto_list_layers(const packet_info *pinfo);
 
WS_DLL_PUBLIC uint8_t proto_get_layer_num(const packet_info *pinfo, const int proto_id);
 
WS_DLL_PUBLIC void proto_disable_by_default(const int proto_id);
 
WS_DLL_PUBLIC void proto_set_decoding(const int proto_id, const bool enabled);
 
WS_DLL_PUBLIC void proto_disable_all(void);
 
WS_DLL_PUBLIC void proto_reenable_all(void);
 
WS_DLL_PUBLIC void proto_set_cant_toggle(const int proto_id);
 
extern bool proto_check_for_protocol_or_field(const proto_tree* tree, const int id);
 
WS_DLL_PUBLIC GPtrArray* proto_get_finfo_ptr_array(const proto_tree *tree, const int hfindex);
 
WS_DLL_PUBLIC bool proto_tracking_interesting_fields(const proto_tree *tree);
 
WS_DLL_PUBLIC GPtrArray* proto_find_finfo(proto_tree *tree, const int hfindex);
 
WS_DLL_PUBLIC GPtrArray* proto_find_first_finfo(proto_tree *tree, const int hfindex);
 
WS_DLL_PUBLIC GPtrArray* proto_all_finfos(proto_tree *tree);
 
WS_DLL_PUBLIC void proto_registrar_dump_protocols(void);
 
WS_DLL_PUBLIC void proto_registrar_dump_values(void);
 
WS_DLL_PUBLIC void proto_registrar_dump_elastic(const char* filter);
 
WS_DLL_PUBLIC bool proto_registrar_dump_fieldcount(void);
 
WS_DLL_PUBLIC void proto_registrar_dump_fields(void);
 
WS_DLL_PUBLIC bool proto_registrar_dump_field_completions(const char *prefix);
 
WS_DLL_PUBLIC void proto_registrar_dump_ftypes(void);
 
WS_DLL_PUBLIC const char* proto_field_display_to_string(int field_display);
 
WS_DLL_PUBLIC int num_tree_types;
 
WS_DLL_PUBLIC bool tree_expanded(int tree_type);
 
WS_DLL_PUBLIC void tree_expanded_set(int tree_type, bool value);
 
WS_DLL_PUBLIC int
hfinfo_bitshift(const header_field_info *hfinfo);
 
struct epan_dissect;
 
WS_DLL_PUBLIC bool
proto_can_match_selected(const field_info *finfo, struct epan_dissect *edt);
 
WS_DLL_PUBLIC char*
proto_construct_match_selected_string(const field_info *finfo, struct epan_dissect *edt);
 
WS_DLL_PUBLIC field_info*
proto_find_field_from_offset(proto_tree *tree, unsigned offset, tvbuff_t *tvb);
 
WS_DLL_PUBLIC char*
proto_find_undecoded_data(proto_tree *tree, unsigned length);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_bitmask(proto_tree *tree, tvbuff_t *tvb, const unsigned offset,
        const int hf_hdr, const int ett, int * const *fields, const unsigned encoding);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_bitmask_ret_uint64(proto_tree *tree, tvbuff_t *tvb, const unsigned offset,
        const int hf_hdr, const int ett, int * const *fields,
        const unsigned encoding, uint64_t *retval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_bitmask_with_flags(proto_tree *tree, tvbuff_t *tvb, const unsigned offset,
        const int hf_hdr, const int ett, int * const *fields, const unsigned encoding, const int flags);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_bitmask_with_flags_ret_uint64(proto_tree *tree, tvbuff_t *tvb, const unsigned offset,
        const int hf_hdr, const int ett, int * const *fields,
        const unsigned encoding, const int flags, uint64_t *retval);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_bitmask_value(proto_tree *tree, tvbuff_t *tvb, const unsigned offset,
        const int hf_hdr, const int ett, int * const *fields, const uint64_t value);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_bitmask_value_with_flags(proto_tree *tree, tvbuff_t *tvb, const unsigned offset,
        const int hf_hdr, const int ett, int * const *fields, const uint64_t value, const int flags);
 
WS_DLL_PUBLIC void
proto_tree_add_bitmask_list(proto_tree *tree, tvbuff_t *tvb, const unsigned offset,
                                const int len, int * const *fields, const unsigned encoding);
 
WS_DLL_PUBLIC  void
proto_tree_add_bitmask_list_ret_uint64(proto_tree *tree, tvbuff_t *tvb, const unsigned offset,
                    const int len, int * const *fields, const unsigned encoding, uint64_t *retval);
 
WS_DLL_PUBLIC void
proto_tree_add_bitmask_list_value(proto_tree *tree, tvbuff_t *tvb, const unsigned offset,
                                const int len, int * const *fields, const uint64_t value);
 
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_bitmask_len(proto_tree *tree, tvbuff_t *tvb, const unsigned offset, const unsigned len,
        const int hf_hdr, const int ett, int * const *fields, struct expert_field* exp, const unsigned encoding);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_bitmask_text(proto_tree *tree, tvbuff_t *tvb, const unsigned offset, const unsigned len,
        const char *name, const char *fallback,
        const int ett, int * const *fields, const unsigned encoding, const int flags);
 
#define BMT_NO_FLAGS    0x00    
#define BMT_NO_APPEND   0x01    
#define BMT_NO_INT      0x02    
#define BMT_NO_FALSE    0x04    
#define BMT_NO_TFS      0x08    
WS_DLL_PUBLIC proto_item *
proto_tree_add_bits_item(proto_tree *tree, const int hf_index, tvbuff_t *tvb, const unsigned bit_offset,
    const int no_of_bits, const unsigned encoding);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_split_bits_item_ret_val(proto_tree *tree, const int hf_index, tvbuff_t *tvb,
    const unsigned bit_offset, const crumb_spec_t *crumb_spec, uint64_t *return_value);
 
void
proto_tree_add_split_bits_crumb(proto_tree *tree, const int hf_index, tvbuff_t *tvb,
    const unsigned bit_offset, const crumb_spec_t *crumb_spec, uint16_t crumb_index);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_bits_ret_val(proto_tree *tree, const int hf_index, tvbuff_t *tvb,
    const unsigned bit_offset, const int no_of_bits, uint64_t *return_value, const unsigned encoding);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_uint_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t *tvb,
    const unsigned bit_offset, const int no_of_bits, uint32_t value, const unsigned encoding,
    const char *format, ...)
    G_GNUC_PRINTF(8,9);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_uint64_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t *tvb,
    const unsigned bit_offset, const int no_of_bits, uint64_t value, const unsigned encoding,
    const char *format, ...)
    G_GNUC_PRINTF(8,9);
 
proto_item *
proto_tree_add_boolean_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t *tvb,
    const unsigned bit_offset, const int no_of_bits, uint64_t value, const unsigned encoding,
    const char *format, ...)
    G_GNUC_PRINTF(8,9);
 
proto_item *
proto_tree_add_int_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t *tvb,
    const unsigned bit_offset, const int no_of_bits, int32_t value, const unsigned encoding,
    const char *format, ...)
    G_GNUC_PRINTF(8,9);
 
proto_item *
proto_tree_add_int64_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t *tvb,
    const unsigned bit_offset, const int no_of_bits, int64_t value, const unsigned encoding,
    const char *format, ...)
    G_GNUC_PRINTF(8,9);
 
proto_item *
proto_tree_add_float_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t *tvb,
    const unsigned bit_offset, const int no_of_bits, float value, const unsigned encoding,
    const char *format, ...)
    G_GNUC_PRINTF(8,9);
 
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_ts_23_038_7bits_packed_item(proto_tree *tree, const int hfindex, tvbuff_t *tvb,
    const unsigned bit_offset, const int no_of_chars);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_ascii_7bits_item(proto_tree *tree, const int hfindex, tvbuff_t *tvb,
    const unsigned bit_offset, const int no_of_chars);
 
WS_DLL_PUBLIC proto_item *
proto_tree_add_checksum(proto_tree *tree, tvbuff_t *tvb, const unsigned offset,
        const int hf_checksum, const int hf_checksum_status, struct expert_field* bad_checksum_expert,
        packet_info *pinfo, uint32_t computed_checksum, const unsigned encoding, const unsigned flags);
 
WS_DLL_PUBLIC proto_item*
proto_tree_add_checksum_bytes(proto_tree *tree, tvbuff_t *tvb, const unsigned offset,
        const int hf_checksum, const int hf_checksum_status, struct expert_field* bad_checksum_expert,
        packet_info *pinfo, const uint8_t *computed_checksum, size_t checksum_len, const unsigned flags);
 
typedef enum
{
    PROTO_CHECKSUM_E_BAD = 0,
    PROTO_CHECKSUM_E_GOOD,
    PROTO_CHECKSUM_E_UNVERIFIED,
    PROTO_CHECKSUM_E_NOT_PRESENT,
    PROTO_CHECKSUM_E_ILLEGAL
} proto_checksum_enum_e;
 
#define PROTO_CHECKSUM_NO_FLAGS     0x00    
#define PROTO_CHECKSUM_VERIFY       0x01    
#define PROTO_CHECKSUM_GENERATED    0x02    
#define PROTO_CHECKSUM_IN_CKSUM     0x04    
#define PROTO_CHECKSUM_ZERO         0x08    
#define PROTO_CHECKSUM_NOT_PRESENT  0x10    
WS_DLL_PUBLIC const value_string proto_checksum_vals[];
 
WS_DLL_PUBLIC unsigned char
proto_check_field_name(const char *field_name);
 
WS_DLL_PUBLIC unsigned char
proto_check_field_name_lower(const char *field_name);
 
 
const char *
proto_custom_set(proto_tree* tree, GSList *field_id,
                             int occurrence,
                             bool display_details,
                             char *result,
                             char *expr, const int size );
 
char *
proto_custom_get_filter(struct epan_dissect *edt, GSList *field_id, int occurrence);
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif /* proto.h */
 
/*
 * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 *
 * Local variables:
 * c-basic-offset: 4
 * tab-width: 8
 * indent-tabs-mode: nil
 * End:
 *
 * vi: set shiftwidth=4 tabstop=8 expandtab:
 * :indentSize=4:tabSize=8:noTabs=true:
 */