Revert SVN #32360 until Windows compilation errors corrected.
svn path=/trunk/; revision=32361
This commit is contained in:
parent
049f9eac85
commit
d32b4c0758
|
@ -422,10 +422,10 @@ static int fgetline(char **buf, int *size, FILE *fp)
|
|||
* Local function definitions
|
||||
*/
|
||||
static subnet_entry_t subnet_lookup(const guint32 addr);
|
||||
static void subnet_entry_set(const guint32 subnet_addr, const guint32 mask_length, const gchar* name);
|
||||
static void subnet_entry_set(guint32 subnet_addr, guint32 mask_length, const gchar* name);
|
||||
|
||||
|
||||
static void add_service_name(hashport_t **proto_table, const guint port, const char *service_name)
|
||||
static void add_service_name(hashport_t **proto_table, guint port, const char *service_name)
|
||||
{
|
||||
int hash_idx;
|
||||
hashport_t *tp;
|
||||
|
@ -525,7 +525,7 @@ static void parse_service_line (char *line)
|
|||
|
||||
|
||||
static void
|
||||
add_serv_port_cb(const guint32 port)
|
||||
add_serv_port_cb(guint32 port)
|
||||
{
|
||||
if ( port ) {
|
||||
add_service_name(cb_port_table, port, cb_service);
|
||||
|
@ -574,7 +574,7 @@ static void initialize_services(void)
|
|||
|
||||
|
||||
|
||||
static gchar *serv_name_lookup(const guint port, const port_type proto)
|
||||
static gchar *serv_name_lookup(guint port, port_type proto)
|
||||
{
|
||||
int hash_idx;
|
||||
hashport_t *tp;
|
||||
|
@ -650,7 +650,7 @@ static gchar *serv_name_lookup(const guint port, const port_type proto)
|
|||
/* Fill in an IP4 structure with info from subnets file or just with the
|
||||
* string form of the address.
|
||||
*/
|
||||
static void fill_dummy_ip4(const guint addr, hashipv4_t* volatile tp)
|
||||
static void fill_dummy_ip4(guint addr, hashipv4_t* volatile tp)
|
||||
{
|
||||
subnet_entry_t subnet_entry;
|
||||
|
||||
|
@ -728,7 +728,7 @@ c_ares_ghba_cb(void *arg, int status, int timeouts _U_, struct hostent *he) {
|
|||
#endif /* HAVE_C_ARES */
|
||||
|
||||
/* --------------- */
|
||||
static hashipv4_t *new_ipv4(const guint addr)
|
||||
static hashipv4_t *new_ipv4(guint addr)
|
||||
{
|
||||
hashipv4_t *tp = g_malloc(sizeof(hashipv4_t));
|
||||
tp->addr = addr;
|
||||
|
@ -739,7 +739,7 @@ static hashipv4_t *new_ipv4(const guint addr)
|
|||
return tp;
|
||||
}
|
||||
|
||||
static hashipv4_t *host_lookup(const guint addr, const gboolean resolve, gboolean *found)
|
||||
static hashipv4_t *host_lookup(guint addr, gboolean resolve, gboolean *found)
|
||||
{
|
||||
int hash_idx;
|
||||
hashipv4_t * volatile tp;
|
||||
|
@ -817,7 +817,7 @@ static hashipv4_t *host_lookup(const guint addr, const gboolean resolve, gboolea
|
|||
|
||||
} /* host_name_lookup */
|
||||
|
||||
static gchar *host_name_lookup(const guint addr, gboolean *found)
|
||||
static gchar *host_name_lookup(guint addr, gboolean *found)
|
||||
{
|
||||
hashipv4_t *tp;
|
||||
tp = host_lookup(addr, TRUE, found);
|
||||
|
@ -838,7 +838,7 @@ static hashipv6_t *new_ipv6(const struct e_in6_addr *addr)
|
|||
}
|
||||
|
||||
/* ------------------------------------ */
|
||||
static hashipv6_t *host_lookup6(const struct e_in6_addr *addr, const gboolean resolve, gboolean *found)
|
||||
static hashipv6_t *host_lookup6(const struct e_in6_addr *addr, gboolean resolve, gboolean *found)
|
||||
{
|
||||
int hash_idx;
|
||||
hashipv6_t * volatile tp;
|
||||
|
@ -1016,7 +1016,7 @@ static const gchar *se_solve_address_to_name(const address *addr)
|
|||
*/
|
||||
static gboolean
|
||||
parse_ether_address(const char *cp, ether_t *eth, unsigned int *mask,
|
||||
const gboolean manuf_file)
|
||||
gboolean manuf_file)
|
||||
{
|
||||
int i;
|
||||
unsigned long num;
|
||||
|
@ -1112,7 +1112,7 @@ parse_ether_address(const char *cp, ether_t *eth, unsigned int *mask,
|
|||
}
|
||||
|
||||
static int parse_ether_line(char *line, ether_t *eth, unsigned int *mask,
|
||||
const gboolean manuf_file)
|
||||
gboolean manuf_file)
|
||||
{
|
||||
/*
|
||||
* See the ethers(4) or ethers(5) man page for ethers file format
|
||||
|
@ -1159,7 +1159,7 @@ static void end_ethent(void)
|
|||
}
|
||||
}
|
||||
|
||||
static ether_t *get_ethent(unsigned int *mask, const gboolean manuf_file)
|
||||
static ether_t *get_ethent(unsigned int *mask, gboolean manuf_file)
|
||||
{
|
||||
|
||||
static ether_t eth;
|
||||
|
@ -1267,7 +1267,7 @@ static int hash_eth_wka(const guint8 *addr, unsigned int mask)
|
|||
(HASHETHSIZE - 1);
|
||||
}
|
||||
|
||||
static void add_manuf_name(const guint8 *addr, unsigned int mask, gchar *name)
|
||||
static void add_manuf_name(guint8 *addr, unsigned int mask, gchar *name)
|
||||
{
|
||||
int hash_idx;
|
||||
hashmanuf_t *tp;
|
||||
|
@ -1377,7 +1377,7 @@ static hashmanuf_t *manuf_name_lookup(const guint8 *addr)
|
|||
|
||||
} /* manuf_name_lookup */
|
||||
|
||||
static hashether_t *wka_name_lookup(const guint8 *addr, const unsigned int mask)
|
||||
static hashether_t *wka_name_lookup(const guint8 *addr, unsigned int mask)
|
||||
{
|
||||
int hash_idx;
|
||||
hashether_t *(*wka_tp)[HASHETHSIZE];
|
||||
|
@ -1501,7 +1501,7 @@ static hashether_t *add_eth_name(const guint8 *addr, const gchar *name)
|
|||
} /* add_eth_name */
|
||||
|
||||
/* XXXX */
|
||||
static hashether_t *eth_name_lookup(const guint8 *addr, const gboolean resolve)
|
||||
static hashether_t *eth_name_lookup(const guint8 *addr, gboolean resolve)
|
||||
{
|
||||
int hash_idx;
|
||||
hashmanuf_t *manufp;
|
||||
|
@ -2130,7 +2130,7 @@ static subnet_entry_t subnet_lookup(const guint32 addr)
|
|||
* The definition is taken by masking the address passed in with the mask of the
|
||||
* given length.
|
||||
*/
|
||||
static void subnet_entry_set(guint32 subnet_addr, const guint32 mask_length, const gchar* name)
|
||||
static void subnet_entry_set(guint32 subnet_addr, guint32 mask_length, const gchar* name)
|
||||
{
|
||||
subnet_length_entry_t* entry;
|
||||
hashipv4_t * tp;
|
||||
|
@ -2167,7 +2167,7 @@ static void subnet_entry_set(guint32 subnet_addr, const guint32 mask_length, con
|
|||
have_subnet_entry = TRUE;
|
||||
}
|
||||
|
||||
static guint32 get_subnet_mask(const guint32 mask_length) {
|
||||
static guint32 get_subnet_mask(guint32 mask_length) {
|
||||
|
||||
static guint32 masks[SUBNETLENGTHSIZE];
|
||||
static gboolean initialised = FALSE;
|
||||
|
@ -2509,7 +2509,7 @@ host_name_lookup_cleanup(void) {
|
|||
|
||||
#endif /* HAVE_C_ARES */
|
||||
|
||||
extern const gchar *get_hostname(const guint addr)
|
||||
extern const gchar *get_hostname(guint addr)
|
||||
{
|
||||
gboolean found;
|
||||
gboolean resolve = g_resolv_flags & RESOLV_NETWORK;
|
||||
|
@ -2523,7 +2523,7 @@ extern const gchar *get_hostname(const guint addr)
|
|||
|
||||
/* -------------------------- */
|
||||
|
||||
extern const gchar *get_hostname6(const struct e_in6_addr *addr)
|
||||
extern const gchar *get_hostname6(struct e_in6_addr *addr)
|
||||
{
|
||||
gboolean found;
|
||||
gboolean resolve = g_resolv_flags & RESOLV_NETWORK;
|
||||
|
@ -2535,7 +2535,7 @@ extern const gchar *get_hostname6(const struct e_in6_addr *addr)
|
|||
}
|
||||
|
||||
/* -------------------------- */
|
||||
extern void add_ipv4_name(const guint addr, const gchar *name)
|
||||
extern void add_ipv4_name(guint addr, const gchar *name)
|
||||
{
|
||||
int hash_idx;
|
||||
hashipv4_t *tp;
|
||||
|
@ -2571,7 +2571,7 @@ extern void add_ipv4_name(const guint addr, const gchar *name)
|
|||
} /* add_ipv4_name */
|
||||
|
||||
/* -------------------------- */
|
||||
extern void add_ipv6_name(const struct e_in6_addr *addrp, const gchar *name)
|
||||
extern void add_ipv6_name(struct e_in6_addr *addrp, const gchar *name)
|
||||
{
|
||||
int hash_idx;
|
||||
hashipv6_t *tp;
|
||||
|
@ -2706,7 +2706,7 @@ const gchar *se_get_addr_name(const address *addr)
|
|||
return se_address_to_str(addr);
|
||||
}
|
||||
|
||||
void get_addr_name_buf(const address *addr, gchar *buf, gsize size)
|
||||
void get_addr_name_buf(address *addr, gchar *buf, gsize size)
|
||||
{
|
||||
const gchar *result = get_addr_name(addr);
|
||||
|
||||
|
@ -2805,7 +2805,7 @@ extern guint8 *get_ether_addr(const gchar *name)
|
|||
|
||||
} /* get_ether_addr */
|
||||
|
||||
extern void add_ether_byip(const guint ip, const guint8 *eth)
|
||||
extern void add_ether_byip(guint ip, const guint8 *eth)
|
||||
{
|
||||
|
||||
gchar *host;
|
||||
|
|
|
@ -114,7 +114,7 @@ const gchar *se_get_addr_name(const address *addr);
|
|||
/* the result which is always NUL ('\0') terminated. The buffer should be large enough to */
|
||||
/* contain size characters including the terminator */
|
||||
|
||||
void get_addr_name_buf(const address *addr, gchar *buf, gsize size);
|
||||
void get_addr_name_buf(address *addr, gchar *buf, gsize size);
|
||||
|
||||
|
||||
/*
|
||||
|
@ -142,7 +142,7 @@ extern const gchar *get_hostname(guint addr);
|
|||
|
||||
/* get_hostname6 returns the host name, or numeric addr if not found */
|
||||
struct e_in6_addr;
|
||||
extern const gchar* get_hostname6(const struct e_in6_addr *ad);
|
||||
extern const gchar* get_hostname6(struct e_in6_addr *ad);
|
||||
|
||||
/* get_ether_name returns the logical name if found in ethers files else
|
||||
"<vendor>_%02x:%02x:%02x" if the vendor code is known else
|
||||
|
@ -174,7 +174,7 @@ guint32 get_ipxnet_addr(const gchar *name, gboolean *known);
|
|||
extern void add_ipv4_name(guint addr, const gchar *name);
|
||||
|
||||
/* adds a hostname/IPv6 in the hash table */
|
||||
extern void add_ipv6_name(const struct e_in6_addr *addr, const gchar *name);
|
||||
extern void add_ipv6_name(struct e_in6_addr *addr, const gchar *name);
|
||||
|
||||
/* add ethernet address / name corresponding to IP address */
|
||||
extern void add_ether_byip(guint ip, const guint8 *eth);
|
||||
|
|
|
@ -48,7 +48,7 @@
|
|||
/* Allocate all the data structures for constructing column data, given
|
||||
the number of columns. */
|
||||
void
|
||||
col_setup(column_info *cinfo, const gint num_cols)
|
||||
col_setup(column_info *cinfo, gint num_cols)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
@ -101,7 +101,7 @@ col_get_writable(column_info *cinfo)
|
|||
}
|
||||
|
||||
void
|
||||
col_set_writable(column_info *cinfo, const gboolean writable)
|
||||
col_set_writable(column_info *cinfo, gboolean writable)
|
||||
{
|
||||
if (cinfo)
|
||||
cinfo->writable = writable;
|
||||
|
@ -115,14 +115,14 @@ col_set_writable(column_info *cinfo, const gboolean writable)
|
|||
((cinfo)->col_first[el] >= 0))
|
||||
|
||||
gint
|
||||
check_col(column_info *cinfo, const gint el)
|
||||
check_col(column_info *cinfo, gint el)
|
||||
{
|
||||
return CHECK_COL(cinfo, el);
|
||||
}
|
||||
|
||||
/* Sets the fence for a column to be at the end of the column. */
|
||||
void
|
||||
col_set_fence(column_info *cinfo, const gint el)
|
||||
col_set_fence(column_info *cinfo, gint el)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
@ -143,7 +143,7 @@ col_set_fence(column_info *cinfo, const gint el)
|
|||
later append to it, as the later append will cause a string
|
||||
copy to be done. */
|
||||
void
|
||||
col_clear(column_info *cinfo, const gint el)
|
||||
col_clear(column_info *cinfo, gint el)
|
||||
{
|
||||
int i;
|
||||
int fence;
|
||||
|
@ -254,7 +254,7 @@ col_custom_prime_edt(epan_dissect_t *edt, column_info *cinfo)
|
|||
}
|
||||
|
||||
static void
|
||||
col_do_append_sep_va_fstr(column_info *cinfo, const gint el, const gchar *separator,
|
||||
col_do_append_sep_va_fstr(column_info *cinfo, gint el, const gchar *separator,
|
||||
const gchar *format, va_list ap)
|
||||
{
|
||||
int i;
|
||||
|
@ -294,7 +294,7 @@ col_do_append_sep_va_fstr(column_info *cinfo, const gint el, const gchar *separa
|
|||
|
||||
/* Appends a vararg list to a packet info string. */
|
||||
void
|
||||
col_append_fstr(column_info *cinfo, const gint el, const gchar *format, ...)
|
||||
col_append_fstr(column_info *cinfo, gint el, const gchar *format, ...)
|
||||
{
|
||||
va_list ap;
|
||||
|
||||
|
@ -309,7 +309,7 @@ col_append_fstr(column_info *cinfo, const gint el, const gchar *format, ...)
|
|||
/* Appends a vararg list to a packet info string.
|
||||
* Prefixes it with the given separator if the column is not empty. */
|
||||
void
|
||||
col_append_sep_fstr(column_info *cinfo, const gint el, const gchar *separator,
|
||||
col_append_sep_fstr(column_info *cinfo, gint el, const gchar *separator,
|
||||
const gchar *format, ...)
|
||||
{
|
||||
va_list ap;
|
||||
|
@ -330,7 +330,7 @@ col_append_sep_fstr(column_info *cinfo, const gint el, const gchar *separator,
|
|||
#define COL_BUF_MAX_LEN (((COL_MAX_INFO_LEN) > (COL_MAX_LEN)) ? \
|
||||
(COL_MAX_INFO_LEN) : (COL_MAX_LEN))
|
||||
void
|
||||
col_prepend_fstr(column_info *cinfo, const gint el, const gchar *format, ...)
|
||||
col_prepend_fstr(column_info *cinfo, gint el, const gchar *format, ...)
|
||||
{
|
||||
va_list ap;
|
||||
int i;
|
||||
|
@ -371,7 +371,7 @@ col_prepend_fstr(column_info *cinfo, const gint el, const gchar *format, ...)
|
|||
va_end(ap);
|
||||
}
|
||||
void
|
||||
col_prepend_fence_fstr(column_info *cinfo, const gint el, const gchar *format, ...)
|
||||
col_prepend_fence_fstr(column_info *cinfo, gint el, const gchar *format, ...)
|
||||
{
|
||||
va_list ap;
|
||||
int i;
|
||||
|
@ -418,7 +418,7 @@ col_prepend_fence_fstr(column_info *cinfo, const gint el, const gchar *format, .
|
|||
/* Use this if "str" points to something that won't stay around (and
|
||||
must thus be copied). */
|
||||
void
|
||||
col_add_str(column_info *cinfo, const gint el, const gchar* str)
|
||||
col_add_str(column_info *cinfo, gint el, const gchar* str)
|
||||
{
|
||||
int i;
|
||||
int fence;
|
||||
|
@ -455,7 +455,7 @@ col_add_str(column_info *cinfo, const gint el, const gchar* str)
|
|||
/* Use this if "str" points to something that will stay around (and thus
|
||||
needn't be copied). */
|
||||
void
|
||||
col_set_str(column_info *cinfo, const gint el, const gchar* str)
|
||||
col_set_str(column_info *cinfo, gint el, const gchar* str)
|
||||
{
|
||||
int i;
|
||||
int fence;
|
||||
|
@ -499,7 +499,7 @@ col_set_str(column_info *cinfo, const gint el, const gchar* str)
|
|||
|
||||
/* Adds a vararg list to a packet info string. */
|
||||
void
|
||||
col_add_fstr(column_info *cinfo, const gint el, const gchar *format, ...) {
|
||||
col_add_fstr(column_info *cinfo, gint el, const gchar *format, ...) {
|
||||
va_list ap;
|
||||
int i;
|
||||
int fence;
|
||||
|
@ -536,7 +536,7 @@ col_add_fstr(column_info *cinfo, const gint el, const gchar *format, ...) {
|
|||
}
|
||||
|
||||
static void
|
||||
col_do_append_str(column_info *cinfo, const gint el, const gchar* separator,
|
||||
col_do_append_str(column_info *cinfo, gint el, const gchar* separator,
|
||||
const gchar* str)
|
||||
{
|
||||
int i;
|
||||
|
@ -570,7 +570,7 @@ col_do_append_str(column_info *cinfo, const gint el, const gchar* separator,
|
|||
}
|
||||
|
||||
void
|
||||
col_append_str(column_info *cinfo, const gint el, const gchar* str)
|
||||
col_append_str(column_info *cinfo, gint el, const gchar* str)
|
||||
{
|
||||
if (!CHECK_COL(cinfo, el))
|
||||
return;
|
||||
|
@ -579,7 +579,7 @@ col_append_str(column_info *cinfo, const gint el, const gchar* str)
|
|||
}
|
||||
|
||||
void
|
||||
col_append_sep_str(column_info *cinfo, const gint el, const gchar* separator,
|
||||
col_append_sep_str(column_info *cinfo, gint el, const gchar* separator,
|
||||
const gchar* str)
|
||||
{
|
||||
if (!CHECK_COL(cinfo, el))
|
||||
|
@ -593,7 +593,7 @@ col_append_sep_str(column_info *cinfo, const gint el, const gchar* separator,
|
|||
|
||||
/* --------------------------------- */
|
||||
gboolean
|
||||
col_has_time_fmt(column_info *cinfo, const gint col)
|
||||
col_has_time_fmt(column_info *cinfo, gint col)
|
||||
{
|
||||
return ((cinfo->fmt_matx[col][COL_CLS_TIME]) ||
|
||||
(cinfo->fmt_matx[col][COL_ABS_TIME]) ||
|
||||
|
@ -604,7 +604,7 @@ col_has_time_fmt(column_info *cinfo, const gint col)
|
|||
}
|
||||
|
||||
static gint
|
||||
set_abs_date_time(const frame_data *fd, gchar *buf)
|
||||
set_abs_date_time(frame_data *fd, gchar *buf)
|
||||
{
|
||||
struct tm *tmp;
|
||||
time_t then;
|
||||
|
@ -688,7 +688,7 @@ set_abs_date_time(const frame_data *fd, gchar *buf)
|
|||
}
|
||||
|
||||
static void
|
||||
col_set_abs_date_time(const frame_data *fd, column_info *cinfo, const int col)
|
||||
col_set_abs_date_time(frame_data *fd, column_info *cinfo, int col)
|
||||
{
|
||||
if (set_abs_date_time(fd, cinfo->col_buf[col])) {
|
||||
cinfo->col_expr.col_expr[col] = "frame.time";
|
||||
|
@ -698,7 +698,7 @@ col_set_abs_date_time(const frame_data *fd, column_info *cinfo, const int col)
|
|||
}
|
||||
|
||||
static gint
|
||||
set_rel_time(const frame_data *fd, gchar *buf)
|
||||
set_rel_time(frame_data *fd, gchar *buf)
|
||||
{
|
||||
switch(timestamp_get_precision()) {
|
||||
case(TS_PREC_FIXED_SEC):
|
||||
|
@ -738,7 +738,7 @@ set_rel_time(const frame_data *fd, gchar *buf)
|
|||
}
|
||||
|
||||
static void
|
||||
col_set_rel_time(const frame_data *fd, column_info *cinfo, const int col)
|
||||
col_set_rel_time(frame_data *fd, column_info *cinfo, int col)
|
||||
{
|
||||
if (set_rel_time(fd, cinfo->col_buf[col])) {
|
||||
cinfo->col_expr.col_expr[col] = "frame.time_relative";
|
||||
|
@ -748,7 +748,7 @@ col_set_rel_time(const frame_data *fd, column_info *cinfo, const int col)
|
|||
}
|
||||
|
||||
static gint
|
||||
set_delta_time(const frame_data *fd, gchar *buf)
|
||||
set_delta_time(frame_data *fd, gchar *buf)
|
||||
{
|
||||
switch(timestamp_get_precision()) {
|
||||
case(TS_PREC_FIXED_SEC):
|
||||
|
@ -788,7 +788,7 @@ set_delta_time(const frame_data *fd, gchar *buf)
|
|||
}
|
||||
|
||||
static void
|
||||
col_set_delta_time(const frame_data *fd, column_info *cinfo, const int col)
|
||||
col_set_delta_time(frame_data *fd, column_info *cinfo, int col)
|
||||
{
|
||||
if (set_delta_time(fd, cinfo->col_buf[col])) {
|
||||
cinfo->col_expr.col_expr[col] = "frame.time_delta";
|
||||
|
@ -798,7 +798,7 @@ col_set_delta_time(const frame_data *fd, column_info *cinfo, const int col)
|
|||
}
|
||||
|
||||
static gint
|
||||
set_delta_time_dis(const frame_data *fd, gchar *buf)
|
||||
set_delta_time_dis(frame_data *fd, gchar *buf)
|
||||
{
|
||||
switch(timestamp_get_precision()) {
|
||||
case(TS_PREC_FIXED_SEC):
|
||||
|
@ -838,7 +838,7 @@ set_delta_time_dis(const frame_data *fd, gchar *buf)
|
|||
}
|
||||
|
||||
static void
|
||||
col_set_delta_time_dis(const frame_data *fd, column_info *cinfo, const int col)
|
||||
col_set_delta_time_dis(frame_data *fd, column_info *cinfo, int col)
|
||||
{
|
||||
if (set_delta_time_dis(fd, cinfo->col_buf[col])) {
|
||||
cinfo->col_expr.col_expr[col] = "frame.time_delta_displayed";
|
||||
|
@ -848,7 +848,7 @@ col_set_delta_time_dis(const frame_data *fd, column_info *cinfo, const int col)
|
|||
}
|
||||
|
||||
static gint
|
||||
set_abs_time(const frame_data *fd, gchar *buf)
|
||||
set_abs_time(frame_data *fd, gchar *buf)
|
||||
{
|
||||
struct tm *tmp;
|
||||
time_t then;
|
||||
|
@ -915,7 +915,7 @@ set_abs_time(const frame_data *fd, gchar *buf)
|
|||
}
|
||||
|
||||
static void
|
||||
col_set_abs_time(const frame_data *fd, column_info *cinfo, const int col)
|
||||
col_set_abs_time(frame_data *fd, column_info *cinfo, int col)
|
||||
{
|
||||
if (set_abs_time(fd, cinfo->col_buf[col])) {
|
||||
cinfo->col_expr.col_expr[col] = "frame.time";
|
||||
|
@ -925,7 +925,7 @@ col_set_abs_time(const frame_data *fd, column_info *cinfo, const int col)
|
|||
}
|
||||
|
||||
static gint
|
||||
set_epoch_time(const frame_data *fd, gchar *buf)
|
||||
set_epoch_time(frame_data *fd, gchar *buf)
|
||||
{
|
||||
switch(timestamp_get_precision()) {
|
||||
case(TS_PREC_FIXED_SEC):
|
||||
|
@ -965,7 +965,7 @@ set_epoch_time(const frame_data *fd, gchar *buf)
|
|||
}
|
||||
|
||||
static void
|
||||
col_set_epoch_time(const frame_data *fd, column_info *cinfo, const int col)
|
||||
col_set_epoch_time(frame_data *fd, column_info *cinfo, int col)
|
||||
{
|
||||
if (set_epoch_time(fd, cinfo->col_buf[col])) {
|
||||
cinfo->col_expr.col_expr[col] = "frame.time_delta";
|
||||
|
@ -1021,7 +1021,7 @@ set_cls_time(frame_data *fd, gchar *buf)
|
|||
#endif
|
||||
|
||||
static void
|
||||
col_set_cls_time(const frame_data *fd, column_info *cinfo, const gint col)
|
||||
col_set_cls_time(frame_data *fd, column_info *cinfo, gint col)
|
||||
{
|
||||
switch (timestamp_get_type()) {
|
||||
case TS_ABSOLUTE:
|
||||
|
@ -1063,7 +1063,7 @@ col_set_cls_time(const frame_data *fd, column_info *cinfo, const gint col)
|
|||
requiring us to stuff the text into the widget from outside, we
|
||||
might be able to clean this up. */
|
||||
void
|
||||
col_set_fmt_time(const frame_data *fd, column_info *cinfo, const gint fmt, const gint col)
|
||||
col_set_fmt_time(frame_data *fd, column_info *cinfo, gint fmt, gint col)
|
||||
{
|
||||
COL_CHECK_REF_TIME(fd, cinfo->col_buf[col]);
|
||||
|
||||
|
@ -1100,7 +1100,7 @@ col_set_fmt_time(const frame_data *fd, column_info *cinfo, const gint fmt, const
|
|||
|
||||
/* --------------------------- */
|
||||
void
|
||||
col_set_time(column_info *cinfo, const gint el, const nstime_t *ts, char *fieldname)
|
||||
col_set_time(column_info *cinfo, gint el, nstime_t *ts, char *fieldname)
|
||||
{
|
||||
int col;
|
||||
|
||||
|
@ -1155,7 +1155,7 @@ col_set_time(column_info *cinfo, const gint el, const nstime_t *ts, char *fieldn
|
|||
}
|
||||
|
||||
static void
|
||||
col_set_addr(packet_info *pinfo, const int col, const address *addr, const gboolean is_src, const gboolean fill_col_exprs)
|
||||
col_set_addr(packet_info *pinfo, int col, address *addr, gboolean is_src, gboolean fill_col_exprs)
|
||||
{
|
||||
if (addr->type == AT_NONE) {
|
||||
pinfo->cinfo->col_data[col] = "";
|
||||
|
@ -1230,7 +1230,7 @@ col_set_addr(packet_info *pinfo, const int col, const address *addr, const gbool
|
|||
|
||||
/* ------------------------ */
|
||||
static void
|
||||
col_set_port(packet_info *pinfo, const int col, const gboolean is_res, const gboolean is_src, const gboolean fill_col_exprs _U_)
|
||||
col_set_port(packet_info *pinfo, int col, gboolean is_res, gboolean is_src, gboolean fill_col_exprs _U_)
|
||||
{
|
||||
guint32 port;
|
||||
|
||||
|
@ -1319,7 +1319,7 @@ col_set_port(packet_info *pinfo, const int col, const gboolean is_res, const gbo
|
|||
}
|
||||
|
||||
gboolean
|
||||
col_based_on_frame_data(column_info *cinfo, const gint col)
|
||||
col_based_on_frame_data(column_info *cinfo, gint col)
|
||||
{
|
||||
g_assert(cinfo);
|
||||
g_assert(col < cinfo->num_cols);
|
||||
|
@ -1343,7 +1343,7 @@ col_based_on_frame_data(column_info *cinfo, const gint col)
|
|||
}
|
||||
|
||||
void
|
||||
col_fill_in_frame_data(const frame_data *fd, column_info *cinfo, const gint col, const gboolean fill_col_exprs)
|
||||
col_fill_in_frame_data(frame_data *fd, column_info *cinfo, gint col, gboolean fill_col_exprs)
|
||||
{
|
||||
switch (cinfo->col_fmt[col]) {
|
||||
|
||||
|
@ -1409,7 +1409,7 @@ col_fill_in_frame_data(const frame_data *fd, column_info *cinfo, const gint col,
|
|||
}
|
||||
|
||||
void
|
||||
col_fill_in(packet_info *pinfo, const gboolean fill_col_exprs, const gboolean fill_fd_colums)
|
||||
col_fill_in(packet_info *pinfo, gboolean fill_col_exprs, gboolean fill_fd_colums)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
|
|
@ -51,7 +51,7 @@ extern "C" {
|
|||
*
|
||||
* Internal, don't use this in dissectors!
|
||||
*/
|
||||
extern void col_setup(column_info *cinfo, const gint num_cols);
|
||||
extern void col_setup(column_info *cinfo, gint num_cols);
|
||||
|
||||
/** Initialize the data structures for constructing column data.
|
||||
*
|
||||
|
@ -63,19 +63,19 @@ extern void col_init(column_info *cinfo);
|
|||
*
|
||||
* Internal, don't use this in dissectors!
|
||||
*/
|
||||
extern void col_set_fmt_time(const frame_data *fd, column_info *cinfo, const gint fmt, const gint col);
|
||||
extern void col_set_fmt_time(frame_data *fd, column_info *cinfo, gint fmt, gint col);
|
||||
|
||||
/** Fill in all columns of the given packet which are based on values from frame_data.
|
||||
*
|
||||
* Internal, don't use this in dissectors!
|
||||
*/
|
||||
extern void col_fill_in_frame_data(const frame_data *fd, column_info *cinfo, const gint col, gboolean const fill_col_exprs);
|
||||
extern void col_fill_in_frame_data(frame_data *fd, column_info *cinfo, gint col, gboolean fill_col_exprs);
|
||||
|
||||
/** Fill in all columns of the given packet.
|
||||
*
|
||||
* Internal, don't use this in dissectors!
|
||||
*/
|
||||
extern void col_fill_in(packet_info *pinfo, const gboolean fill_col_exprs, const gboolean fill_fd_colums);
|
||||
extern void col_fill_in(packet_info *pinfo, gboolean fill_col_exprs, gboolean fill_fd_colums);
|
||||
|
||||
/* Utility routines used by packet*.c */
|
||||
|
||||
|
@ -91,14 +91,14 @@ extern gboolean col_get_writable(column_info *cinfo);
|
|||
* @param cinfo the current packet row
|
||||
* @param writable TRUE if it's writable, FALSE if not
|
||||
*/
|
||||
extern void col_set_writable(column_info *cinfo, const gboolean writable);
|
||||
extern void col_set_writable(column_info *cinfo, gboolean writable);
|
||||
|
||||
/** Check if the given column be filled with data.
|
||||
*
|
||||
* @param cinfo the current packet row
|
||||
* @param col the column to use, e.g. COL_INFO
|
||||
*/
|
||||
extern gint check_col(column_info *cinfo, const gint col);
|
||||
extern gint check_col(column_info *cinfo, gint col);
|
||||
|
||||
/** Sets a fence for the current column content,
|
||||
* so this content won't be affected by further col_... function calls.
|
||||
|
@ -109,14 +109,14 @@ extern gint check_col(column_info *cinfo, const gint col);
|
|||
* @param cinfo the current packet row
|
||||
* @param col the column to use, e.g. COL_INFO
|
||||
*/
|
||||
extern void col_set_fence(column_info *cinfo, const gint col);
|
||||
extern void col_set_fence(column_info *cinfo, gint col);
|
||||
|
||||
/** Clears the text of a column element.
|
||||
*
|
||||
* @param cinfo the current packet row
|
||||
* @param col the column to use, e.g. COL_INFO
|
||||
*/
|
||||
extern void col_clear(column_info *cinfo, const gint col);
|
||||
extern void col_clear(column_info *cinfo, gint col);
|
||||
|
||||
/** Set (replace) the text of a column element, the text won't be copied.
|
||||
*
|
||||
|
@ -126,7 +126,7 @@ extern void col_clear(column_info *cinfo, const gint col);
|
|||
* @param col the column to use, e.g. COL_INFO
|
||||
* @param str the string to set
|
||||
*/
|
||||
extern void col_set_str(column_info *cinfo, const gint col, const gchar * str);
|
||||
extern void col_set_str(column_info *cinfo, gint col, const gchar * str);
|
||||
|
||||
/** Add (replace) the text of a column element, the text will be copied.
|
||||
*
|
||||
|
@ -134,7 +134,7 @@ extern void col_set_str(column_info *cinfo, const gint col, const gchar * str);
|
|||
* @param col the column to use, e.g. COL_INFO
|
||||
* @param str the string to add
|
||||
*/
|
||||
extern void col_add_str(column_info *cinfo, const gint col, const gchar *str);
|
||||
extern void col_add_str(column_info *cinfo, gint col, const gchar *str);
|
||||
|
||||
/** Add (replace) the text of a column element, the text will be formatted and copied.
|
||||
*
|
||||
|
@ -145,7 +145,7 @@ extern void col_add_str(column_info *cinfo, const gint col, const gchar *str);
|
|||
* @param format the format string
|
||||
* @param ... the variable number of parameters
|
||||
*/
|
||||
extern void col_add_fstr(column_info *cinfo, const gint col, const gchar *format, ...)
|
||||
extern void col_add_fstr(column_info *cinfo, gint col, const gchar *format, ...)
|
||||
G_GNUC_PRINTF(3, 4);
|
||||
|
||||
/* For internal Wireshark use only. Not to be called from dissectors. */
|
||||
|
@ -156,8 +156,8 @@ void col_custom_prime_edt(epan_dissect_t *edt, column_info *cinfo);
|
|||
|
||||
/* For internal Wireshark use only. Not to be called from dissectors. */
|
||||
gboolean have_custom_cols(column_info *cinfo);
|
||||
gboolean col_has_time_fmt(column_info *cinfo, const gint col);
|
||||
gboolean col_based_on_frame_data(column_info *cinfo, const gint col);
|
||||
gboolean col_has_time_fmt(column_info *cinfo, gint col);
|
||||
gboolean col_based_on_frame_data(column_info *cinfo, gint col);
|
||||
|
||||
/** Append the given text to a column element, the text will be copied.
|
||||
*
|
||||
|
@ -165,7 +165,7 @@ gboolean col_based_on_frame_data(column_info *cinfo, const gint col);
|
|||
* @param col the column to use, e.g. COL_INFO
|
||||
* @param str the string to append
|
||||
*/
|
||||
extern void col_append_str(column_info *cinfo, const gint col, const gchar *str);
|
||||
extern void col_append_str(column_info *cinfo, gint col, const gchar *str);
|
||||
|
||||
/** Append the given text to a column element, the text will be formatted and copied.
|
||||
*
|
||||
|
@ -176,7 +176,7 @@ extern void col_append_str(column_info *cinfo, const gint col, const gchar *str)
|
|||
* @param format the format string
|
||||
* @param ... the variable number of parameters
|
||||
*/
|
||||
extern void col_append_fstr(column_info *cinfo, const gint col, const gchar *format, ...)
|
||||
extern void col_append_fstr(column_info *cinfo, gint col, const gchar *format, ...)
|
||||
G_GNUC_PRINTF(3, 4);
|
||||
|
||||
/** Prepend the given text to a column element, the text will be formatted and copied.
|
||||
|
@ -186,7 +186,7 @@ extern void col_append_fstr(column_info *cinfo, const gint col, const gchar *for
|
|||
* @param format the format string
|
||||
* @param ... the variable number of parameters
|
||||
*/
|
||||
extern void col_prepend_fstr(column_info *cinfo, const gint col, const gchar *format, ...)
|
||||
extern void col_prepend_fstr(column_info *cinfo, gint col, const gchar *format, ...)
|
||||
G_GNUC_PRINTF(3, 4);
|
||||
|
||||
/**Prepend the given text to a column element, the text will be formatted and copied.
|
||||
|
@ -197,7 +197,7 @@ extern void col_prepend_fstr(column_info *cinfo, const gint col, const gchar *fo
|
|||
* there is already a fence created. This function will create a fence in case
|
||||
* it does not yet exist.
|
||||
*/
|
||||
extern void col_prepend_fence_fstr(column_info *cinfo, const gint col, const gchar *format, ...)
|
||||
extern void col_prepend_fence_fstr(column_info *cinfo, gint col, const gchar *format, ...)
|
||||
G_GNUC_PRINTF(3, 4);
|
||||
|
||||
/** Append the given text (prepended by a separator) to a column element.
|
||||
|
@ -209,7 +209,7 @@ extern void col_prepend_fence_fstr(column_info *cinfo, const gint col, const gch
|
|||
* @param sep the separator string or NULL for default: ", "
|
||||
* @param str the string to append
|
||||
*/
|
||||
extern void col_append_sep_str(column_info *cinfo, const gint col, const gchar *sep,
|
||||
extern void col_append_sep_str(column_info *cinfo, gint col, const gchar *sep,
|
||||
const gchar *str);
|
||||
|
||||
/** Append the given text (prepended by a separator) to a column element.
|
||||
|
@ -222,7 +222,7 @@ extern void col_append_sep_str(column_info *cinfo, const gint col, const gchar *
|
|||
* @param format the format string
|
||||
* @param ... the variable number of parameters
|
||||
*/
|
||||
extern void col_append_sep_fstr(column_info *cinfo, const gint col, const gchar *sep,
|
||||
extern void col_append_sep_fstr(column_info *cinfo, gint col, const gchar *sep,
|
||||
const gchar *format, ...)
|
||||
G_GNUC_PRINTF(4, 5);
|
||||
|
||||
|
@ -237,8 +237,8 @@ extern void col_append_sep_fstr(column_info *cinfo, const gint col, const gchar
|
|||
* @param fieldname the fieldname to use for creating a filter (when
|
||||
* applying/preparing/copying as filter)
|
||||
*/
|
||||
extern void col_set_time(column_info *cinfo, const int col,
|
||||
const nstime_t *ts, char *fieldname);
|
||||
extern void col_set_time(column_info *cinfo, int col,
|
||||
nstime_t *ts, char *fieldname);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
@ -179,7 +179,7 @@ static const gchar *dlist[NUM_COL_FMTS] = {
|
|||
};
|
||||
|
||||
const gchar *
|
||||
col_format_desc(const gint fmt) {
|
||||
col_format_desc(gint fmt) {
|
||||
g_assert((fmt >= 0) && (fmt < NUM_COL_FMTS));
|
||||
return(dlist[fmt]);
|
||||
}
|
||||
|
@ -187,7 +187,7 @@ col_format_desc(const gint fmt) {
|
|||
/* Marks each array element true if it can be substituted for the given
|
||||
column format */
|
||||
void
|
||||
get_column_format_matches(gboolean *fmt_list, const gint format) {
|
||||
get_column_format_matches(gboolean *fmt_list, gint format) {
|
||||
|
||||
/* Get the obvious: the format itself */
|
||||
if ((format >= 0) && (format < NUM_COL_FMTS))
|
||||
|
@ -311,7 +311,7 @@ get_column_format_matches(gboolean *fmt_list, const gint format) {
|
|||
/* Returns a string representing the longest possible value for
|
||||
a timestamp column type. */
|
||||
static const char *
|
||||
get_timestamp_column_longest_string(const gint type, const gint precision)
|
||||
get_timestamp_column_longest_string(gint type, gint precision)
|
||||
{
|
||||
|
||||
switch(type) {
|
||||
|
@ -452,7 +452,7 @@ get_timestamp_column_longest_string(const gint type, const gint precision)
|
|||
/* Returns the longer string of the column title or the hard-coded width of
|
||||
* its contents for building the packet list layout. */
|
||||
const gchar *
|
||||
get_column_width_string(const gint format, const gint col)
|
||||
get_column_width_string(gint format, gint col)
|
||||
{
|
||||
if(strlen(get_column_longest_string(format)) >
|
||||
strlen(get_column_title(col)))
|
||||
|
@ -474,7 +474,7 @@ get_column_width_string(const gint format, const gint col)
|
|||
is somewhat arbitrary in any case. We should probably clean
|
||||
that up eventually, though. */
|
||||
const char *
|
||||
get_column_longest_string(const gint format)
|
||||
get_column_longest_string(gint format)
|
||||
{
|
||||
switch (format) {
|
||||
case COL_NUMBER:
|
||||
|
@ -610,13 +610,13 @@ get_column_longest_string(const gint format)
|
|||
/* Returns the longest possible width, in characters, for a particular
|
||||
column type. */
|
||||
gint
|
||||
get_column_char_width(const gint format)
|
||||
get_column_char_width(gint format)
|
||||
{
|
||||
return (gint)strlen(get_column_longest_string(format));
|
||||
}
|
||||
|
||||
gint
|
||||
get_column_format(const gint col)
|
||||
get_column_format(gint col)
|
||||
{
|
||||
GList *clp = g_list_nth(prefs.col_list, col);
|
||||
fmt_data *cfmt;
|
||||
|
@ -630,7 +630,7 @@ get_column_format(const gint col)
|
|||
}
|
||||
|
||||
gint
|
||||
get_column_format_from_str(const gchar *str)
|
||||
get_column_format_from_str(gchar *str)
|
||||
{
|
||||
gint i;
|
||||
|
||||
|
@ -642,7 +642,7 @@ get_column_format_from_str(const gchar *str)
|
|||
}
|
||||
|
||||
gchar *
|
||||
get_column_title(const gint col)
|
||||
get_column_title(gint col)
|
||||
{
|
||||
GList *clp = g_list_nth(prefs.col_list, col);
|
||||
fmt_data *cfmt;
|
||||
|
@ -656,7 +656,7 @@ get_column_title(const gint col)
|
|||
}
|
||||
|
||||
const gchar *
|
||||
get_column_custom_field(const gint col)
|
||||
get_column_custom_field(gint col)
|
||||
{
|
||||
GList *clp = g_list_nth(prefs.col_list, col);
|
||||
fmt_data *cfmt;
|
||||
|
@ -670,7 +670,7 @@ get_column_custom_field(const gint col)
|
|||
}
|
||||
|
||||
void
|
||||
build_column_format_array(column_info *cinfo, const gint num_cols, const gboolean reset_fences)
|
||||
build_column_format_array(column_info *cinfo, gint num_cols, gboolean reset_fences)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
|
|
@ -35,19 +35,19 @@ typedef struct _fmt_data {
|
|||
gchar *custom_field;
|
||||
} fmt_data;
|
||||
|
||||
const gchar *col_format_to_string(const gint);
|
||||
const gchar *col_format_desc(const gint);
|
||||
gint get_column_format(const gint);
|
||||
void get_column_format_matches(gboolean *, const gint);
|
||||
gint get_column_format_from_str(const gchar *);
|
||||
gchar *get_column_title(const gint);
|
||||
const gchar *get_column_custom_field(const gint);
|
||||
const gchar *get_column_width_string(const gint, const gint);
|
||||
const char *get_column_longest_string(const gint);
|
||||
gint get_column_char_width(const gint format);
|
||||
const gchar *col_format_to_string(gint);
|
||||
const gchar *col_format_desc(gint);
|
||||
gint get_column_format(gint);
|
||||
void get_column_format_matches(gboolean *, gint);
|
||||
gint get_column_format_from_str(gchar *);
|
||||
gchar *get_column_title(gint);
|
||||
const gchar *get_column_custom_field(gint);
|
||||
const gchar *get_column_width_string(gint, gint);
|
||||
const char *get_column_longest_string(gint);
|
||||
gint get_column_char_width(gint format);
|
||||
|
||||
void
|
||||
build_column_format_array(column_info *cinfo, const gint num_cols, const gboolean reset_fences);
|
||||
build_column_format_array(column_info *cinfo, gint num_cols, gboolean reset_fences);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
@ -97,7 +97,7 @@ typedef struct _conv_proto_data {
|
|||
* options bits are set (NO_ADDR2 and NO_PORT2).
|
||||
*/
|
||||
static conversation_t *
|
||||
conversation_create_from_template(conversation_t *conversation, const address *addr2, const guint32 port2)
|
||||
conversation_create_from_template(conversation_t *conversation, address *addr2, guint32 port2)
|
||||
{
|
||||
/*
|
||||
* Add a new conversation and keep the conversation template only if the
|
||||
|
@ -474,8 +474,8 @@ conversation_init(void)
|
|||
* when searching for this conversation.
|
||||
*/
|
||||
conversation_t *
|
||||
conversation_new(const guint32 setup_frame, const address *addr1, const address *addr2, const port_type ptype,
|
||||
const guint32 port1, const guint32 port2, const guint options)
|
||||
conversation_new(guint32 setup_frame, address *addr1, address *addr2, port_type ptype,
|
||||
guint32 port1, guint32 port2, guint options)
|
||||
{
|
||||
/*
|
||||
DISSECTOR_ASSERT(!(options | CONVERSATION_TEMPLATE) || ((options | (NO_ADDR2 | NO_PORT2 | NO_PORT2_FORCE))) &&
|
||||
|
@ -555,7 +555,7 @@ conversation_new(const guint32 setup_frame, const address *addr1, const address
|
|||
* update the options and port values, insert the updated key.
|
||||
*/
|
||||
void
|
||||
conversation_set_port2(conversation_t *conv, const guint32 port)
|
||||
conversation_set_port2(conversation_t *conv, guint32 port)
|
||||
{
|
||||
DISSECTOR_ASSERT(!(conv->options & CONVERSATION_TEMPLATE) &&
|
||||
"Use the conversation_create_from_template function when the CONVERSATION_TEMPLATE bit is set in the options mask");
|
||||
|
@ -589,7 +589,7 @@ conversation_set_port2(conversation_t *conv, const guint32 port)
|
|||
* table, update the options and port values, insert the updated key.
|
||||
*/
|
||||
void
|
||||
conversation_set_addr2(conversation_t *conv, const address *addr)
|
||||
conversation_set_addr2(conversation_t *conv, address *addr)
|
||||
{
|
||||
DISSECTOR_ASSERT(!(conv->options & CONVERSATION_TEMPLATE) &&
|
||||
"Use the conversation_create_from_template function when the CONVERSATION_TEMPLATE bit is set in the options mask");
|
||||
|
@ -623,8 +623,8 @@ conversation_set_addr2(conversation_t *conv, const address *addr)
|
|||
* {addr1, port1, addr2, port2} and set up before frame_num.
|
||||
*/
|
||||
static conversation_t *
|
||||
conversation_lookup_hashtable(GHashTable *hashtable, const guint32 frame_num, const address *addr1, const address *addr2,
|
||||
const port_type ptype, const guint32 port1, const guint32 port2)
|
||||
conversation_lookup_hashtable(GHashTable *hashtable, guint32 frame_num, address *addr1, address *addr2,
|
||||
port_type ptype, guint32 port1, guint32 port2)
|
||||
{
|
||||
conversation_t* conversation;
|
||||
conversation_t* match;
|
||||
|
@ -693,8 +693,8 @@ conversation_lookup_hashtable(GHashTable *hashtable, const guint32 frame_num, co
|
|||
* otherwise, we found no matching conversation, and return NULL.
|
||||
*/
|
||||
conversation_t *
|
||||
find_conversation(const guint32 frame_num, const address *addr_a, const address *addr_b, const port_type ptype,
|
||||
const guint32 port_a, const guint32 port_b, const guint options)
|
||||
find_conversation(guint32 frame_num, address *addr_a, address *addr_b, port_type ptype,
|
||||
guint32 port_a, guint32 port_b, guint options)
|
||||
{
|
||||
conversation_t *conversation;
|
||||
|
||||
|
@ -1014,7 +1014,7 @@ p_compare(gconstpointer a, gconstpointer b)
|
|||
}
|
||||
|
||||
void
|
||||
conversation_add_proto_data(conversation_t *conv, const int proto, void *proto_data)
|
||||
conversation_add_proto_data(conversation_t *conv, int proto, void *proto_data)
|
||||
{
|
||||
conv_proto_data *p1 = se_alloc(sizeof(conv_proto_data));
|
||||
|
||||
|
@ -1028,7 +1028,7 @@ conversation_add_proto_data(conversation_t *conv, const int proto, void *proto_d
|
|||
}
|
||||
|
||||
void *
|
||||
conversation_get_proto_data(const conversation_t *conv, const int proto)
|
||||
conversation_get_proto_data(conversation_t *conv, int proto)
|
||||
{
|
||||
conv_proto_data temp, *p1;
|
||||
GSList *item;
|
||||
|
@ -1048,7 +1048,7 @@ conversation_get_proto_data(const conversation_t *conv, const int proto)
|
|||
}
|
||||
|
||||
void
|
||||
conversation_delete_proto_data(conversation_t *conv, const int proto)
|
||||
conversation_delete_proto_data(conversation_t *conv, int proto)
|
||||
{
|
||||
conv_proto_data temp;
|
||||
GSList *item;
|
||||
|
@ -1066,7 +1066,7 @@ conversation_delete_proto_data(conversation_t *conv, const int proto)
|
|||
}
|
||||
|
||||
void
|
||||
conversation_set_dissector(conversation_t *conversation, const dissector_handle_t handle)
|
||||
conversation_set_dissector(conversation_t *conversation, dissector_handle_t handle)
|
||||
{
|
||||
conversation->dissector_handle = handle;
|
||||
}
|
||||
|
@ -1082,8 +1082,8 @@ conversation_set_dissector(conversation_t *conversation, const dissector_handle_
|
|||
* this function returns FALSE.
|
||||
*/
|
||||
gboolean
|
||||
try_conversation_dissector(const address *addr_a, const address *addr_b, const port_type ptype,
|
||||
const guint32 port_a, const guint32 port_b, tvbuff_t *tvb, packet_info *pinfo,
|
||||
try_conversation_dissector(address *addr_a, address *addr_b, port_type ptype,
|
||||
guint32 port_a, guint32 port_b, tvbuff_t *tvb, packet_info *pinfo,
|
||||
proto_tree *tree)
|
||||
{
|
||||
conversation_t *conversation;
|
||||
|
|
|
@ -80,28 +80,28 @@ typedef struct conversation {
|
|||
extern void conversation_cleanup(void);
|
||||
extern void conversation_init(void);
|
||||
|
||||
extern conversation_t *conversation_new(const guint32 setup_frame, const address *addr1, const address *addr2,
|
||||
const port_type ptype, const guint32 port1, const guint32 port2, const guint options);
|
||||
extern conversation_t *conversation_new(guint32 setup_frame, address *addr1, address *addr2,
|
||||
port_type ptype, guint32 port1, guint32 port2, guint options);
|
||||
|
||||
extern conversation_t *find_conversation(const guint32 frame_num, const address *addr_a, const address *addr_b,
|
||||
const port_type ptype, const guint32 port_a, const guint32 port_b, const guint options);
|
||||
extern conversation_t *find_conversation(guint32 frame_num, address *addr_a, address *addr_b,
|
||||
port_type ptype, guint32 port_a, guint32 port_b, guint options);
|
||||
|
||||
extern void conversation_add_proto_data(conversation_t *conv, const int proto,
|
||||
extern void conversation_add_proto_data(conversation_t *conv, int proto,
|
||||
void *proto_data);
|
||||
extern void *conversation_get_proto_data(const conversation_t *conv, const int proto);
|
||||
extern void conversation_delete_proto_data(conversation_t *conv, const int proto);
|
||||
extern void *conversation_get_proto_data(conversation_t *conv, int proto);
|
||||
extern void conversation_delete_proto_data(conversation_t *conv, int proto);
|
||||
|
||||
extern void conversation_set_dissector(conversation_t *conversation,
|
||||
const dissector_handle_t handle);
|
||||
dissector_handle_t handle);
|
||||
extern gboolean
|
||||
try_conversation_dissector(const address *addr_a, const address *addr_b, const port_type ptype,
|
||||
const guint32 port_a, const guint32 port_b, tvbuff_t *tvb, packet_info *pinfo,
|
||||
try_conversation_dissector(address *addr_a, address *addr_b, port_type ptype,
|
||||
guint32 port_a, guint32 port_b, tvbuff_t *tvb, packet_info *pinfo,
|
||||
proto_tree *tree);
|
||||
|
||||
/* These routines are used to set undefined values for a conversation */
|
||||
|
||||
extern void conversation_set_port2(conversation_t *conv, const guint32 port);
|
||||
extern void conversation_set_addr2(conversation_t *conv, const address *addr);
|
||||
extern void conversation_set_port2(conversation_t *conv, guint32 port);
|
||||
extern void conversation_set_addr2(conversation_t *conv, address *addr);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
@ -3163,7 +3163,7 @@ dissect_dcerpc_cn_stub (tvbuff_t *tvb, int offset, packet_info *pinfo,
|
|||
then exit
|
||||
*/
|
||||
if(pinfo->fd->flags.visited){
|
||||
fd_head=fragment_get_reassembled(frame, dcerpc_co_reassemble_table);
|
||||
fd_head=fragment_get_reassembled(pinfo, frame, dcerpc_co_reassemble_table);
|
||||
goto end_cn_stub;
|
||||
}
|
||||
|
||||
|
|
|
@ -2621,7 +2621,7 @@ static int rounded4(int n)
|
|||
|
||||
/* We assume the order to be consistent, until proven wrong. */
|
||||
|
||||
static gboolean consistentWithOrder(int length, tvbuff_t *tvb, int offset, guint16 (*v16)(tvbuff_t *, const gint))
|
||||
static gboolean consistentWithOrder(int length, tvbuff_t *tvb, int offset, guint16 (*v16)(tvbuff_t *, gint))
|
||||
{
|
||||
switch(tvb_get_guint8(tvb, offset)) {
|
||||
case X_CreateWindow:
|
||||
|
@ -2837,7 +2837,7 @@ static gboolean consistentWithOrder(int length, tvbuff_t *tvb, int offset, guint
|
|||
|
||||
/* -1 means doesn't match, +1 means match, 0 means don't know */
|
||||
|
||||
static int x_endian_match(tvbuff_t *tvb, guint16 (*v16)(tvbuff_t *, const gint))
|
||||
static int x_endian_match(tvbuff_t *tvb, guint16 (*v16)(tvbuff_t *, gint))
|
||||
{
|
||||
int offset, nextoffset;
|
||||
int atLeastOne = 0;
|
||||
|
|
10
epan/epan.c
10
epan/epan.c
|
@ -150,7 +150,7 @@ epan_circuit_cleanup(void)
|
|||
}
|
||||
|
||||
epan_dissect_t*
|
||||
epan_dissect_init(epan_dissect_t *edt, const gboolean create_proto_tree, const gboolean proto_tree_visible)
|
||||
epan_dissect_init(epan_dissect_t *edt, gboolean create_proto_tree, gboolean proto_tree_visible)
|
||||
{
|
||||
g_assert(edt);
|
||||
|
||||
|
@ -166,7 +166,7 @@ epan_dissect_init(epan_dissect_t *edt, const gboolean create_proto_tree, const g
|
|||
}
|
||||
|
||||
epan_dissect_t*
|
||||
epan_dissect_new(const gboolean create_proto_tree, const gboolean proto_tree_visible)
|
||||
epan_dissect_new(gboolean create_proto_tree, gboolean proto_tree_visible)
|
||||
{
|
||||
epan_dissect_t *edt;
|
||||
|
||||
|
@ -176,7 +176,7 @@ epan_dissect_new(const gboolean create_proto_tree, const gboolean proto_tree_vis
|
|||
}
|
||||
|
||||
void
|
||||
epan_dissect_fake_protocols(epan_dissect_t *edt, const gboolean fake_protocols)
|
||||
epan_dissect_fake_protocols(epan_dissect_t *edt, gboolean fake_protocols)
|
||||
{
|
||||
if (edt)
|
||||
proto_tree_set_fake_protocols(edt->tree, fake_protocols);
|
||||
|
@ -227,13 +227,13 @@ epan_dissect_prime_dfilter(epan_dissect_t *edt, const dfilter_t* dfcode)
|
|||
const gchar *
|
||||
epan_custom_set(epan_dissect_t *edt, int field_id,
|
||||
gchar *result,
|
||||
gchar *expr, const int size )
|
||||
gchar *expr, int size )
|
||||
{
|
||||
return proto_custom_set(edt->tree, field_id, result, expr, size);
|
||||
}
|
||||
|
||||
void
|
||||
epan_dissect_fill_in_columns(epan_dissect_t *edt, const gboolean fill_col_exprs, const gboolean fill_fd_colums)
|
||||
epan_dissect_fill_in_columns(epan_dissect_t *edt, gboolean fill_col_exprs, gboolean fill_fd_colums)
|
||||
{
|
||||
col_custom_set_edt(edt, edt->pi.cinfo);
|
||||
col_fill_in(&edt->pi, fill_col_exprs, fill_fd_colums);
|
||||
|
|
10
epan/epan.h
10
epan/epan.h
|
@ -89,16 +89,16 @@ epan_get_version(void);
|
|||
|
||||
/* initialize an existing single packet dissection */
|
||||
epan_dissect_t*
|
||||
epan_dissect_init(epan_dissect_t *edt, const gboolean create_proto_tree, const gboolean proto_tree_visible);
|
||||
epan_dissect_init(epan_dissect_t *edt, gboolean create_proto_tree, gboolean proto_tree_visible);
|
||||
|
||||
/* get a new single packet dissection */
|
||||
/* should be freed using epan_dissect_free() after packet dissection completed */
|
||||
epan_dissect_t*
|
||||
epan_dissect_new(const gboolean create_proto_tree, const gboolean proto_tree_visible);
|
||||
epan_dissect_new(gboolean create_proto_tree, gboolean proto_tree_visible);
|
||||
|
||||
/* Indicate whether we should fake protocols or not */
|
||||
void
|
||||
epan_dissect_fake_protocols(epan_dissect_t *edt, const gboolean fake_protocols);
|
||||
epan_dissect_fake_protocols(epan_dissect_t *edt, gboolean fake_protocols);
|
||||
|
||||
/* run a single packet dissection */
|
||||
void
|
||||
|
@ -111,7 +111,7 @@ epan_dissect_prime_dfilter(epan_dissect_t *edt, const dfilter_t *dfcode);
|
|||
|
||||
/* fill the dissect run output into the packet list columns */
|
||||
void
|
||||
epan_dissect_fill_in_columns(epan_dissect_t *edt, const gboolean fill_col_exprs, const gboolean fill_fd_colums);
|
||||
epan_dissect_fill_in_columns(epan_dissect_t *edt, gboolean fill_col_exprs, gboolean fill_fd_colums);
|
||||
|
||||
/* releases resources attached to the packet dissection. DOES NOT free the actual pointer */
|
||||
void
|
||||
|
@ -124,6 +124,6 @@ epan_dissect_free(epan_dissect_t* edt);
|
|||
/* Sets custom column */
|
||||
const gchar *
|
||||
epan_custom_set(epan_dissect_t *edt, int id,
|
||||
gchar *result, gchar *expr, const int size );
|
||||
gchar *result, gchar *expr, int size );
|
||||
|
||||
#endif /* EPAN_H */
|
||||
|
|
|
@ -187,7 +187,7 @@ const value_string ipproto_val[] = {
|
|||
{ 0, NULL },
|
||||
};
|
||||
|
||||
const char *ipprotostr(const int proto) {
|
||||
const char *ipprotostr(int proto) {
|
||||
const char *s;
|
||||
|
||||
if ((s = match_strval(proto, ipproto_val)) != NULL)
|
||||
|
|
|
@ -191,6 +191,6 @@
|
|||
#define IP_PROTO_NCS_HEARTBEAT 224 /* Novell NCS Heartbeat - http://support.novell.com/cgi-bin/search/searchtid.cgi?/10071158.htm */
|
||||
|
||||
extern const value_string ipproto_val[];
|
||||
extern const char *ipprotostr(const int proto);
|
||||
extern const char *ipprotostr(int proto);
|
||||
|
||||
#endif /* ipproto.h */
|
||||
|
|
|
@ -53,19 +53,19 @@ ipv4_addr_free(ipv4_addr *ipv4)
|
|||
}
|
||||
|
||||
void
|
||||
ipv4_addr_set_host_order_addr(ipv4_addr *ipv4, const guint32 new_addr)
|
||||
ipv4_addr_set_host_order_addr(ipv4_addr *ipv4, guint32 new_addr)
|
||||
{
|
||||
ipv4->addr = new_addr;
|
||||
}
|
||||
|
||||
void
|
||||
ipv4_addr_set_net_order_addr(ipv4_addr *ipv4, const guint32 new_addr)
|
||||
ipv4_addr_set_net_order_addr(ipv4_addr *ipv4, guint32 new_addr)
|
||||
{
|
||||
ipv4->addr = g_ntohl(new_addr);
|
||||
}
|
||||
|
||||
void
|
||||
ipv4_addr_set_netmask_bits(ipv4_addr *ipv4, const guint new_nmask_bits)
|
||||
ipv4_addr_set_netmask_bits(ipv4_addr *ipv4, guint new_nmask_bits)
|
||||
{
|
||||
static guint32 bitmasks[33] = {
|
||||
0x00000000,
|
||||
|
|
|
@ -42,9 +42,9 @@ ipv4_addr* ipv4_addr_new(void);
|
|||
/* Frees an ipv4 struct */
|
||||
void ipv4_addr_free(ipv4_addr *ipv4);
|
||||
|
||||
void ipv4_addr_set_host_order_addr(ipv4_addr *ipv4, const guint32 new_addr);
|
||||
void ipv4_addr_set_net_order_addr(ipv4_addr *ipv4, const guint32 new_addr);
|
||||
void ipv4_addr_set_netmask_bits(ipv4_addr *ipv4, const guint new_nmask_bits);
|
||||
void ipv4_addr_set_host_order_addr(ipv4_addr *ipv4, guint32 new_addr);
|
||||
void ipv4_addr_set_net_order_addr(ipv4_addr *ipv4, guint32 new_addr);
|
||||
void ipv4_addr_set_netmask_bits(ipv4_addr *ipv4, guint new_nmask_bits);
|
||||
|
||||
guint32 ipv4_get_net_order_addr(ipv4_addr *ipv4);
|
||||
guint32 ipv4_get_host_order_addr(ipv4_addr *ipv4);
|
||||
|
|
|
@ -81,7 +81,7 @@ packet_cleanup(void)
|
|||
* of the tvbuff to reflect the specified length.
|
||||
*/
|
||||
void
|
||||
set_actual_length(tvbuff_t *tvb, const guint specified_len)
|
||||
set_actual_length(tvbuff_t *tvb, guint specified_len)
|
||||
{
|
||||
if (specified_len < tvb_reported_length(tvb)) {
|
||||
/* Adjust the length of this tvbuff to include only the specified
|
||||
|
@ -668,7 +668,7 @@ find_dissector_table(const char *name)
|
|||
|
||||
/* Find an entry in a uint dissector table. */
|
||||
static dtbl_entry_t *
|
||||
find_uint_dtbl_entry(dissector_table_t sub_dissectors, const guint32 pattern)
|
||||
find_uint_dtbl_entry(dissector_table_t sub_dissectors, guint32 pattern)
|
||||
{
|
||||
switch (sub_dissectors->type) {
|
||||
|
||||
|
@ -718,7 +718,7 @@ dissector_add_sanity_check(const char *name, guint32 pattern, dissector_handle_t
|
|||
|
||||
/* Add an entry to a uint dissector table. */
|
||||
void
|
||||
dissector_add(const char *name, const guint32 pattern, dissector_handle_t handle)
|
||||
dissector_add(const char *name, guint32 pattern, dissector_handle_t handle)
|
||||
{
|
||||
dissector_table_t sub_dissectors;
|
||||
dtbl_entry_t *dtbl_entry;
|
||||
|
@ -774,7 +774,7 @@ dissector_add(const char *name, const guint32 pattern, dissector_handle_t handle
|
|||
/* If temporary dissectors are deleted, then the original dissector must */
|
||||
/* be available. */
|
||||
void
|
||||
dissector_delete(const char *name, const guint32 pattern,
|
||||
dissector_delete(const char *name, guint32 pattern,
|
||||
dissector_handle_t handle _U_)
|
||||
{
|
||||
dissector_table_t sub_dissectors = find_dissector_table( name);
|
||||
|
@ -805,7 +805,7 @@ dissector_delete(const char *name, const guint32 pattern,
|
|||
/* Change the entry for a dissector in a uint dissector table
|
||||
with a particular pattern to use a new dissector handle. */
|
||||
void
|
||||
dissector_change(const char *name, const guint32 pattern, dissector_handle_t handle)
|
||||
dissector_change(const char *name, guint32 pattern, dissector_handle_t handle)
|
||||
{
|
||||
dissector_table_t sub_dissectors = find_dissector_table( name);
|
||||
dtbl_entry_t *dtbl_entry;
|
||||
|
@ -841,7 +841,7 @@ dissector_change(const char *name, const guint32 pattern, dissector_handle_t han
|
|||
|
||||
/* Reset an entry in a uint dissector table to its initial value. */
|
||||
void
|
||||
dissector_reset(const char *name, const guint32 pattern)
|
||||
dissector_reset(const char *name, guint32 pattern)
|
||||
{
|
||||
dissector_table_t sub_dissectors = find_dissector_table( name);
|
||||
dtbl_entry_t *dtbl_entry;
|
||||
|
@ -874,8 +874,8 @@ dissector_reset(const char *name, const guint32 pattern)
|
|||
otherwise return FALSE. */
|
||||
|
||||
gboolean
|
||||
dissector_try_port_new(dissector_table_t sub_dissectors, const guint32 port,
|
||||
tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, const gboolean add_proto_name)
|
||||
dissector_try_port_new(dissector_table_t sub_dissectors, guint32 port,
|
||||
tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean add_proto_name)
|
||||
{
|
||||
dtbl_entry_t *dtbl_entry;
|
||||
struct dissector_handle *handle;
|
||||
|
@ -926,7 +926,7 @@ dissector_try_port_new(dissector_table_t sub_dissectors, const guint32 port,
|
|||
}
|
||||
|
||||
gboolean
|
||||
dissector_try_port(dissector_table_t sub_dissectors, const guint32 port,
|
||||
dissector_try_port(dissector_table_t sub_dissectors, guint32 port,
|
||||
tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
|
||||
{
|
||||
|
||||
|
@ -1414,7 +1414,7 @@ typedef struct dissector_foreach_table_info {
|
|||
* Called for each entry in the table of all dissector tables.
|
||||
*/
|
||||
static void
|
||||
dissector_all_tables_foreach_table_func (gpointer key, const gpointer value, const gpointer user_data)
|
||||
dissector_all_tables_foreach_table_func (gpointer key, gpointer value, gpointer user_data)
|
||||
{
|
||||
dissector_table_t table;
|
||||
dissector_foreach_table_info_t *info;
|
||||
|
@ -1440,8 +1440,8 @@ dissector_all_tables_foreach_table (DATFunc_table func,
|
|||
}
|
||||
|
||||
dissector_table_t
|
||||
register_dissector_table(const char *name, const char *ui_name, const ftenum_t type,
|
||||
const int base)
|
||||
register_dissector_table(const char *name, const char *ui_name, ftenum_t type,
|
||||
int base)
|
||||
{
|
||||
dissector_table_t sub_dissectors;
|
||||
|
||||
|
@ -1530,7 +1530,7 @@ find_heur_dissector_list(const char *name)
|
|||
}
|
||||
|
||||
void
|
||||
heur_dissector_add(const char *name, heur_dissector_t dissector, const int proto)
|
||||
heur_dissector_add(const char *name, heur_dissector_t dissector, int proto)
|
||||
{
|
||||
heur_dissector_list_t *sub_dissectors = find_heur_dissector_list(name);
|
||||
heur_dtbl_entry_t *dtbl_entry;
|
||||
|
@ -1555,7 +1555,7 @@ static int find_matching_heur_dissector( gconstpointer a, gconstpointer b) {
|
|||
(dtbl_entry_a->protocol == dtbl_entry_b->protocol) ? 0 : 1;
|
||||
}
|
||||
|
||||
void heur_dissector_delete(const char *name, heur_dissector_t dissector, const int proto) {
|
||||
void heur_dissector_delete(const char *name, heur_dissector_t dissector, int proto) {
|
||||
heur_dissector_list_t *sub_dissectors = find_heur_dissector_list(name);
|
||||
heur_dtbl_entry_t dtbl_entry;
|
||||
GSList* found_entry;
|
||||
|
@ -1693,7 +1693,7 @@ static GHashTable *registered_dissectors = NULL;
|
|||
/* Get the short name of the protocol for a dissector handle, if it has
|
||||
a protocol. */
|
||||
const char *
|
||||
dissector_handle_get_short_name(const dissector_handle_t handle)
|
||||
dissector_handle_get_short_name(dissector_handle_t handle)
|
||||
{
|
||||
if (handle->protocol == NULL) {
|
||||
/*
|
||||
|
@ -1710,7 +1710,7 @@ dissector_handle_get_short_name(const dissector_handle_t handle)
|
|||
/* Get the index of the protocol for a dissector handle, if it has
|
||||
a protocol. */
|
||||
int
|
||||
dissector_handle_get_protocol_index(const dissector_handle_t handle)
|
||||
dissector_handle_get_protocol_index(dissector_handle_t handle)
|
||||
{
|
||||
if (handle->protocol == NULL) {
|
||||
/*
|
||||
|
@ -1734,7 +1734,7 @@ find_dissector(const char *name)
|
|||
|
||||
/* Create an anonymous handle for a dissector. */
|
||||
dissector_handle_t
|
||||
create_dissector_handle(dissector_t dissector, const int proto)
|
||||
create_dissector_handle(dissector_t dissector, int proto)
|
||||
{
|
||||
struct dissector_handle *handle;
|
||||
|
||||
|
@ -1748,7 +1748,7 @@ create_dissector_handle(dissector_t dissector, const int proto)
|
|||
}
|
||||
|
||||
dissector_handle_t
|
||||
new_create_dissector_handle(new_dissector_t dissector, const int proto)
|
||||
new_create_dissector_handle(new_dissector_t dissector, int proto)
|
||||
{
|
||||
struct dissector_handle *handle;
|
||||
|
||||
|
@ -1763,7 +1763,7 @@ new_create_dissector_handle(new_dissector_t dissector, const int proto)
|
|||
|
||||
/* Register a dissector by name. */
|
||||
void
|
||||
register_dissector(const char *name, dissector_t dissector, const int proto)
|
||||
register_dissector(const char *name, dissector_t dissector, int proto)
|
||||
{
|
||||
struct dissector_handle *handle;
|
||||
|
||||
|
@ -1787,7 +1787,7 @@ register_dissector(const char *name, dissector_t dissector, const int proto)
|
|||
}
|
||||
|
||||
void
|
||||
new_register_dissector(const char *name, new_dissector_t dissector, const int proto)
|
||||
new_register_dissector(const char *name, new_dissector_t dissector, int proto)
|
||||
{
|
||||
struct dissector_handle *handle;
|
||||
|
||||
|
@ -1861,7 +1861,7 @@ call_dissector(dissector_handle_t handle, tvbuff_t *tvb,
|
|||
|
||||
static void
|
||||
dissector_dump_decodes_display(const gchar *table_name,
|
||||
ftenum_t selector_type _U_, const gpointer key, const gpointer value,
|
||||
ftenum_t selector_type _U_, gpointer key, gpointer value,
|
||||
gpointer user_data _U_)
|
||||
{
|
||||
guint32 selector = (guint32)(unsigned long) key;
|
||||
|
|
|
@ -150,7 +150,7 @@ extern void dissector_all_tables_foreach_table (DATFunc_table func,
|
|||
|
||||
/* a protocol uses the function to register a sub-dissector table */
|
||||
extern dissector_table_t register_dissector_table(const char *name,
|
||||
const char *ui_name, const ftenum_t type, const int base);
|
||||
const char *ui_name, ftenum_t type, int base);
|
||||
|
||||
/* Find a dissector table by table name. */
|
||||
extern dissector_table_t find_dissector_table(const char *name);
|
||||
|
@ -187,13 +187,13 @@ extern void dissector_reset(const char *name, guint32 pattern);
|
|||
call the dissector with the arguments supplied, and return TRUE,
|
||||
otherwise return FALSE. */
|
||||
extern gboolean dissector_try_port(dissector_table_t sub_dissectors,
|
||||
const guint32 port, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree);
|
||||
guint32 port, 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 TRUE,
|
||||
otherwise return FALSE. */
|
||||
extern gboolean dissector_try_port_new(dissector_table_t sub_dissectors,
|
||||
const guint32 port, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, const gboolean add_proto_name);
|
||||
guint32 port, tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean add_proto_name);
|
||||
|
||||
/* Look for a given value in a given uint dissector table and, if found,
|
||||
return the dissector handle for that value. */
|
||||
|
@ -268,7 +268,7 @@ extern gboolean dissector_try_heuristic(heur_dissector_list_t sub_dissectors,
|
|||
* @param proto the protocol id of the sub-dissector
|
||||
*/
|
||||
extern void heur_dissector_add(const char *name, heur_dissector_t dissector,
|
||||
const int proto);
|
||||
int proto);
|
||||
|
||||
/** Remove a sub-dissector from a heuristic dissector list.
|
||||
* Call this in the prefs_reinit function of the sub-dissector.
|
||||
|
@ -277,7 +277,7 @@ extern void heur_dissector_add(const char *name, heur_dissector_t dissector,
|
|||
* @param dissector the sub-dissector to be unregistered
|
||||
* @param proto the protocol id of the sub-dissector
|
||||
*/
|
||||
extern void heur_dissector_delete(const char *name, heur_dissector_t dissector, const int proto);
|
||||
extern void heur_dissector_delete(const char *name, heur_dissector_t dissector, int proto);
|
||||
|
||||
/* Register a dissector. */
|
||||
extern void register_dissector(const char *name, dissector_t dissector,
|
||||
|
@ -286,19 +286,19 @@ extern void new_register_dissector(const char *name, new_dissector_t dissector,
|
|||
int proto);
|
||||
|
||||
/* Get the short name of the protocol for a dissector handle. */
|
||||
extern const char *dissector_handle_get_short_name(const dissector_handle_t handle);
|
||||
extern const char *dissector_handle_get_short_name(dissector_handle_t handle);
|
||||
|
||||
/* Get the index of the protocol for a dissector handle. */
|
||||
extern int dissector_handle_get_protocol_index(const dissector_handle_t handle);
|
||||
extern int dissector_handle_get_protocol_index(dissector_handle_t handle);
|
||||
|
||||
/* Find a dissector by name. */
|
||||
extern dissector_handle_t find_dissector(const char *name);
|
||||
|
||||
/* Create an anonymous handle for a dissector. */
|
||||
extern dissector_handle_t create_dissector_handle(dissector_t dissector,
|
||||
const int proto);
|
||||
int proto);
|
||||
extern dissector_handle_t new_create_dissector_handle(new_dissector_t dissector,
|
||||
const int proto);
|
||||
int proto);
|
||||
|
||||
/* Call a dissector through a handle and if no dissector was found
|
||||
* pass if over to the "data" dissector instead.
|
||||
|
@ -339,7 +339,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.
|
||||
*/
|
||||
extern void set_actual_length(tvbuff_t *tvb, const guint specified_len);
|
||||
extern void set_actual_length(tvbuff_t *tvb, guint specified_len);
|
||||
|
||||
/* Allow protocols to register "init" routines, which are called before
|
||||
we make a pass through a capture file and dissect all its packets
|
||||
|
|
154
epan/proto.c
154
epan/proto.c
|
@ -74,7 +74,7 @@ struct ptvcursor {
|
|||
|
||||
/* Candidates for assembler */
|
||||
static int
|
||||
wrs_count_bitshift(const guint32 bitmask)
|
||||
wrs_count_bitshift(guint32 bitmask)
|
||||
{
|
||||
int bitshift = 0;
|
||||
|
||||
|
@ -144,20 +144,20 @@ static void fill_label_bitfield(field_info *fi, gchar *label_str);
|
|||
static void fill_label_int(field_info *fi, gchar *label_str);
|
||||
static void fill_label_int64(field_info *fi, gchar *label_str);
|
||||
|
||||
static const char* hfinfo_uint_vals_format(const header_field_info *hfinfo);
|
||||
static const char* hfinfo_uint_format(const header_field_info *hfinfo);
|
||||
static const char* hfinfo_uint_value_format(const header_field_info *hfinfo);
|
||||
static const char* hfinfo_uint64_format(const header_field_info *hfinfo);
|
||||
static const char* hfinfo_int_vals_format(const header_field_info *hfinfo);
|
||||
static const char* hfinfo_int_format(const header_field_info *hfinfo);
|
||||
static const char* hfinfo_int_value_format(const header_field_info *hfinfo);
|
||||
static const char* hfinfo_int64_format(const header_field_info *hfinfo);
|
||||
static const char* hfinfo_uint_vals_format(header_field_info *hfinfo);
|
||||
static const char* hfinfo_uint_format(header_field_info *hfinfo);
|
||||
static const char* hfinfo_uint_value_format(header_field_info *hfinfo);
|
||||
static const char* hfinfo_uint64_format(header_field_info *hfinfo);
|
||||
static const char* hfinfo_int_vals_format(header_field_info *hfinfo);
|
||||
static const char* hfinfo_int_format(header_field_info *hfinfo);
|
||||
static const char* hfinfo_int_value_format(header_field_info *hfinfo);
|
||||
static const char* hfinfo_int64_format(header_field_info *hfinfo);
|
||||
|
||||
static proto_item*
|
||||
proto_tree_add_node(proto_tree *tree, field_info *fi);
|
||||
|
||||
static header_field_info *
|
||||
get_hfi_and_length(int hfindex, tvbuff_t *tvb, const gint start, gint *length,
|
||||
get_hfi_and_length(int hfindex, tvbuff_t *tvb, gint start, gint *length,
|
||||
gint *item_length);
|
||||
|
||||
static field_info *
|
||||
|
@ -1471,8 +1471,8 @@ ptvcursor_add(ptvcursor_t *ptvc, int hfindex, gint length,
|
|||
/* Add an item to a proto_tree, using the text label registered to that item;
|
||||
the item is extracted from the tvbuff handed to it. */
|
||||
proto_item *
|
||||
proto_tree_add_item(proto_tree *tree, const int hfindex, tvbuff_t *tvb,
|
||||
const gint start, gint length, const gboolean little_endian)
|
||||
proto_tree_add_item(proto_tree *tree, int hfindex, tvbuff_t *tvb,
|
||||
gint start, gint length, gboolean little_endian)
|
||||
{
|
||||
field_info *new_fi;
|
||||
header_field_info *hfinfo;
|
||||
|
@ -1490,7 +1490,7 @@ proto_tree_add_item(proto_tree *tree, const int hfindex, tvbuff_t *tvb,
|
|||
|
||||
/* Add a FT_NONE to a proto_tree */
|
||||
proto_item *
|
||||
proto_tree_add_none_format(proto_tree *tree, const int hfindex, tvbuff_t *tvb, const gint start,
|
||||
proto_tree_add_none_format(proto_tree *tree, int hfindex, tvbuff_t *tvb, gint start,
|
||||
gint length, const char *format, ...)
|
||||
{
|
||||
proto_item *pi;
|
||||
|
@ -3150,7 +3150,7 @@ get_hfi_and_length(int hfindex, tvbuff_t *tvb, gint start, gint *length,
|
|||
|
||||
static field_info *
|
||||
new_field_info(proto_tree *tree, header_field_info *hfinfo, tvbuff_t *tvb,
|
||||
const gint start, const gint item_length)
|
||||
gint start, gint item_length)
|
||||
{
|
||||
field_info *fi;
|
||||
|
||||
|
@ -3177,7 +3177,7 @@ new_field_info(proto_tree *tree, header_field_info *hfinfo, tvbuff_t *tvb,
|
|||
}
|
||||
|
||||
static field_info *
|
||||
alloc_field_info(proto_tree *tree, int hfindex, tvbuff_t *tvb, const gint start,
|
||||
alloc_field_info(proto_tree *tree, int hfindex, tvbuff_t *tvb, gint start,
|
||||
gint *length)
|
||||
{
|
||||
header_field_info *hfinfo;
|
||||
|
@ -3282,9 +3282,9 @@ proto_tree_set_representation(proto_item *pi, const char *format, va_list ap)
|
|||
|
||||
/* -------------------------- */
|
||||
const gchar *
|
||||
proto_custom_set(proto_tree* tree, const int field_id,
|
||||
proto_custom_set(proto_tree* tree, int field_id,
|
||||
gchar *result,
|
||||
gchar *expr, const int size )
|
||||
gchar *expr, int size )
|
||||
{
|
||||
guint32 u_integer;
|
||||
gint32 integer;
|
||||
|
@ -3526,7 +3526,7 @@ proto_item_append_text(proto_item *pi, const char *format, ...)
|
|||
}
|
||||
|
||||
void
|
||||
proto_item_set_len(proto_item *pi, const gint length)
|
||||
proto_item_set_len(proto_item *pi, gint length)
|
||||
{
|
||||
field_info *fi;
|
||||
|
||||
|
@ -3569,7 +3569,7 @@ proto_item_set_end(proto_item *pi, tvbuff_t *tvb, gint end)
|
|||
}
|
||||
|
||||
int
|
||||
proto_item_get_len(const proto_item *pi)
|
||||
proto_item_get_len(proto_item *pi)
|
||||
{
|
||||
field_info *fi = PITEM_FINFO(pi);
|
||||
return fi ? fi->length : -1;
|
||||
|
@ -3583,7 +3583,7 @@ proto_item_get_len(const proto_item *pi)
|
|||
}
|
||||
|
||||
gboolean
|
||||
proto_item_set_expert_flags(proto_item *pi, const int group, const guint severity)
|
||||
proto_item_set_expert_flags(proto_item *pi, int group, guint severity)
|
||||
{
|
||||
if(pi == NULL || PITEM_FINFO(pi) == NULL)
|
||||
return FALSE;
|
||||
|
@ -3632,7 +3632,7 @@ proto_tree_create_root(void)
|
|||
/* "prime" a proto_tree with a single hfid that a dfilter
|
||||
* is interested in. */
|
||||
void
|
||||
proto_tree_prime_hfid(proto_tree *tree _U_, const gint hfid)
|
||||
proto_tree_prime_hfid(proto_tree *tree _U_, gint hfid)
|
||||
{
|
||||
header_field_info *hfinfo;
|
||||
|
||||
|
@ -3658,7 +3658,7 @@ proto_tree_prime_hfid(proto_tree *tree _U_, const gint hfid)
|
|||
}
|
||||
|
||||
proto_tree*
|
||||
proto_item_add_subtree(proto_item *pi, const gint idx) {
|
||||
proto_item_add_subtree(proto_item *pi, gint idx) {
|
||||
field_info *fi;
|
||||
|
||||
if (!pi)
|
||||
|
@ -3676,7 +3676,7 @@ proto_item_add_subtree(proto_item *pi, const gint idx) {
|
|||
}
|
||||
|
||||
proto_tree*
|
||||
proto_item_get_subtree(const proto_item *pi) {
|
||||
proto_item_get_subtree(proto_item *pi) {
|
||||
field_info *fi;
|
||||
|
||||
if (!pi)
|
||||
|
@ -3688,7 +3688,7 @@ proto_item_get_subtree(const proto_item *pi) {
|
|||
}
|
||||
|
||||
proto_item*
|
||||
proto_item_get_parent(const proto_item *ti) {
|
||||
proto_item_get_parent(proto_item *ti) {
|
||||
if (!ti)
|
||||
return (NULL);
|
||||
return ti->parent;
|
||||
|
@ -3708,7 +3708,7 @@ proto_item_get_parent_nth(proto_item *ti, int gen) {
|
|||
|
||||
|
||||
proto_item*
|
||||
proto_tree_get_parent(const proto_tree *tree) {
|
||||
proto_tree_get_parent(proto_tree *tree) {
|
||||
if (!tree)
|
||||
return (NULL);
|
||||
return (proto_item*) tree;
|
||||
|
@ -3771,7 +3771,7 @@ proto_tree_move_item(proto_tree *tree, proto_item *fixed_item, proto_item *item_
|
|||
}
|
||||
|
||||
void
|
||||
proto_tree_set_appendix(proto_tree *tree, tvbuff_t *tvb, gint start, const gint length)
|
||||
proto_tree_set_appendix(proto_tree *tree, tvbuff_t *tvb, gint start, gint length)
|
||||
{
|
||||
field_info *fi;
|
||||
|
||||
|
@ -3890,7 +3890,7 @@ proto_register_protocol(const char *name, const char *short_name, const char *fi
|
|||
}
|
||||
|
||||
void
|
||||
proto_mark_private(const int proto_id)
|
||||
proto_mark_private(int proto_id)
|
||||
{
|
||||
protocol_t *protocol = find_protocol_by_id(proto_id);
|
||||
if (protocol)
|
||||
|
@ -3898,7 +3898,7 @@ proto_mark_private(const int proto_id)
|
|||
}
|
||||
|
||||
gboolean
|
||||
proto_is_private(const int proto_id)
|
||||
proto_is_private(int proto_id)
|
||||
{
|
||||
protocol_t *protocol = find_protocol_by_id(proto_id);
|
||||
if (protocol)
|
||||
|
@ -3941,7 +3941,7 @@ proto_get_next_protocol(void **cookie)
|
|||
}
|
||||
|
||||
header_field_info *
|
||||
proto_get_first_protocol_field(const int proto_id, void **cookie)
|
||||
proto_get_first_protocol_field(int proto_id, void **cookie)
|
||||
{
|
||||
protocol_t *protocol = find_protocol_by_id(proto_id);
|
||||
hf_register_info *ptr;
|
||||
|
@ -3970,7 +3970,7 @@ proto_get_next_protocol_field(void **cookie)
|
|||
}
|
||||
|
||||
protocol_t *
|
||||
find_protocol_by_id(const int proto_id)
|
||||
find_protocol_by_id(int proto_id)
|
||||
{
|
||||
header_field_info *hfinfo;
|
||||
|
||||
|
@ -3992,7 +3992,7 @@ static gint compare_filter_name(gconstpointer proto_arg,
|
|||
}
|
||||
|
||||
int
|
||||
proto_get_id(const protocol_t *protocol)
|
||||
proto_get_id(protocol_t *protocol)
|
||||
{
|
||||
return protocol->proto_id;
|
||||
}
|
||||
|
@ -4012,7 +4012,7 @@ int proto_get_id_by_filter_name(const gchar* filter_name)
|
|||
}
|
||||
|
||||
const char *
|
||||
proto_get_protocol_name(const int proto_id)
|
||||
proto_get_protocol_name(int proto_id)
|
||||
{
|
||||
protocol_t *protocol;
|
||||
|
||||
|
@ -4021,7 +4021,7 @@ proto_get_protocol_name(const int proto_id)
|
|||
}
|
||||
|
||||
const char *
|
||||
proto_get_protocol_short_name(const protocol_t *protocol)
|
||||
proto_get_protocol_short_name(protocol_t *protocol)
|
||||
{
|
||||
if (protocol == NULL)
|
||||
return "(none)";
|
||||
|
@ -4029,7 +4029,7 @@ proto_get_protocol_short_name(const protocol_t *protocol)
|
|||
}
|
||||
|
||||
const char *
|
||||
proto_get_protocol_long_name(const protocol_t *protocol)
|
||||
proto_get_protocol_long_name(protocol_t *protocol)
|
||||
{
|
||||
if (protocol == NULL)
|
||||
return "(none)";
|
||||
|
@ -4037,7 +4037,7 @@ proto_get_protocol_long_name(const protocol_t *protocol)
|
|||
}
|
||||
|
||||
const char *
|
||||
proto_get_protocol_filter_name(const int proto_id)
|
||||
proto_get_protocol_filter_name(int proto_id)
|
||||
{
|
||||
protocol_t *protocol;
|
||||
|
||||
|
@ -4048,13 +4048,13 @@ proto_get_protocol_filter_name(const int proto_id)
|
|||
}
|
||||
|
||||
gboolean
|
||||
proto_is_protocol_enabled(const protocol_t *protocol)
|
||||
proto_is_protocol_enabled(protocol_t *protocol)
|
||||
{
|
||||
return protocol->is_enabled;
|
||||
}
|
||||
|
||||
gboolean
|
||||
proto_can_toggle_protocol(const int proto_id)
|
||||
proto_can_toggle_protocol(int proto_id)
|
||||
{
|
||||
protocol_t *protocol;
|
||||
|
||||
|
@ -4063,7 +4063,7 @@ proto_can_toggle_protocol(const int proto_id)
|
|||
}
|
||||
|
||||
void
|
||||
proto_set_decoding(const int proto_id, const gboolean enabled)
|
||||
proto_set_decoding(int proto_id, gboolean enabled)
|
||||
{
|
||||
protocol_t *protocol;
|
||||
|
||||
|
@ -4090,7 +4090,7 @@ proto_enable_all(void)
|
|||
}
|
||||
|
||||
void
|
||||
proto_set_cant_toggle(const int proto_id)
|
||||
proto_set_cant_toggle(int proto_id)
|
||||
{
|
||||
protocol_t *protocol;
|
||||
|
||||
|
@ -4101,7 +4101,7 @@ proto_set_cant_toggle(const int proto_id)
|
|||
/* for use with static arrays only, since we don't allocate our own copies
|
||||
of the header_field_info struct contained within the hf_register_info struct */
|
||||
void
|
||||
proto_register_field_array(const int parent, hf_register_info *hf, const int num_records)
|
||||
proto_register_field_array(int parent, hf_register_info *hf, int num_records)
|
||||
{
|
||||
int field_id, i;
|
||||
hf_register_info *ptr = hf;
|
||||
|
@ -4244,7 +4244,7 @@ static void tmp_fld_check_assert(header_field_info *hfinfo) {
|
|||
}
|
||||
|
||||
static int
|
||||
proto_register_field_init(header_field_info *hfinfo, const int parent)
|
||||
proto_register_field_init(header_field_info *hfinfo, int parent)
|
||||
{
|
||||
|
||||
tmp_fld_check_assert(hfinfo);
|
||||
|
@ -4324,7 +4324,7 @@ proto_register_field_init(header_field_info *hfinfo, const int parent)
|
|||
}
|
||||
|
||||
void
|
||||
proto_register_subtree_array(gint *const *indices, const int num_indices)
|
||||
proto_register_subtree_array(gint *const *indices, int num_indices)
|
||||
{
|
||||
int i;
|
||||
gint *const *ptr = indices;
|
||||
|
@ -4786,7 +4786,7 @@ fill_label_int64(field_info *fi, gchar *label_str)
|
|||
}
|
||||
|
||||
int
|
||||
hfinfo_bitwidth(const header_field_info *hfinfo)
|
||||
hfinfo_bitwidth(header_field_info *hfinfo)
|
||||
{
|
||||
int bitwidth = 0;
|
||||
|
||||
|
@ -4822,7 +4822,7 @@ hfinfo_bitwidth(const header_field_info *hfinfo)
|
|||
}
|
||||
|
||||
static const char*
|
||||
hfinfo_uint_vals_format(const header_field_info *hfinfo)
|
||||
hfinfo_uint_vals_format(header_field_info *hfinfo)
|
||||
{
|
||||
const char *format = NULL;
|
||||
|
||||
|
@ -4866,7 +4866,7 @@ hfinfo_uint_vals_format(const header_field_info *hfinfo)
|
|||
}
|
||||
|
||||
static const char*
|
||||
hfinfo_uint_format(const header_field_info *hfinfo)
|
||||
hfinfo_uint_format(header_field_info *hfinfo)
|
||||
{
|
||||
const char *format = NULL;
|
||||
|
||||
|
@ -4950,7 +4950,7 @@ hfinfo_uint_format(const header_field_info *hfinfo)
|
|||
}
|
||||
|
||||
static const char*
|
||||
hfinfo_uint_value_format(const header_field_info *hfinfo)
|
||||
hfinfo_uint_value_format(header_field_info *hfinfo)
|
||||
{
|
||||
const char *format = NULL;
|
||||
|
||||
|
@ -5034,7 +5034,7 @@ hfinfo_uint_value_format(const header_field_info *hfinfo)
|
|||
}
|
||||
|
||||
static const char*
|
||||
hfinfo_int_vals_format(const header_field_info *hfinfo)
|
||||
hfinfo_int_vals_format(header_field_info *hfinfo)
|
||||
{
|
||||
const char *format = NULL;
|
||||
|
||||
|
@ -5078,7 +5078,7 @@ hfinfo_int_vals_format(const header_field_info *hfinfo)
|
|||
}
|
||||
|
||||
static const char*
|
||||
hfinfo_uint64_format(const header_field_info *hfinfo)
|
||||
hfinfo_uint64_format(header_field_info *hfinfo)
|
||||
{
|
||||
const char *format = NULL;
|
||||
|
||||
|
@ -5107,7 +5107,7 @@ hfinfo_uint64_format(const header_field_info *hfinfo)
|
|||
}
|
||||
|
||||
static const char*
|
||||
hfinfo_int_format(const header_field_info *hfinfo)
|
||||
hfinfo_int_format(header_field_info *hfinfo)
|
||||
{
|
||||
const char *format = NULL;
|
||||
|
||||
|
@ -5184,7 +5184,7 @@ hfinfo_int_format(const header_field_info *hfinfo)
|
|||
}
|
||||
|
||||
static const char*
|
||||
hfinfo_int_value_format(const header_field_info *hfinfo)
|
||||
hfinfo_int_value_format(header_field_info *hfinfo)
|
||||
{
|
||||
const char *format = NULL;
|
||||
|
||||
|
@ -5261,7 +5261,7 @@ hfinfo_int_value_format(const header_field_info *hfinfo)
|
|||
}
|
||||
|
||||
static const char*
|
||||
hfinfo_int64_format(const header_field_info *hfinfo)
|
||||
hfinfo_int64_format(header_field_info *hfinfo)
|
||||
{
|
||||
const char *format = NULL;
|
||||
|
||||
|
@ -5296,7 +5296,7 @@ proto_registrar_n(void)
|
|||
}
|
||||
|
||||
const char*
|
||||
proto_registrar_get_name(const int n)
|
||||
proto_registrar_get_name(int n)
|
||||
{
|
||||
header_field_info *hfinfo;
|
||||
|
||||
|
@ -5305,7 +5305,7 @@ proto_registrar_get_name(const int n)
|
|||
}
|
||||
|
||||
const char*
|
||||
proto_registrar_get_abbrev(const int n)
|
||||
proto_registrar_get_abbrev(int n)
|
||||
{
|
||||
header_field_info *hfinfo;
|
||||
|
||||
|
@ -5314,7 +5314,7 @@ proto_registrar_get_abbrev(const int n)
|
|||
}
|
||||
|
||||
int
|
||||
proto_registrar_get_ftype(const int n)
|
||||
proto_registrar_get_ftype(int n)
|
||||
{
|
||||
header_field_info *hfinfo;
|
||||
|
||||
|
@ -5323,7 +5323,7 @@ proto_registrar_get_ftype(const int n)
|
|||
}
|
||||
|
||||
int
|
||||
proto_registrar_get_parent(const int n)
|
||||
proto_registrar_get_parent(int n)
|
||||
{
|
||||
header_field_info *hfinfo;
|
||||
|
||||
|
@ -5332,7 +5332,7 @@ proto_registrar_get_parent(const int n)
|
|||
}
|
||||
|
||||
gboolean
|
||||
proto_registrar_is_protocol(const int n)
|
||||
proto_registrar_is_protocol(int n)
|
||||
{
|
||||
header_field_info *hfinfo;
|
||||
|
||||
|
@ -5345,7 +5345,7 @@ proto_registrar_is_protocol(const int n)
|
|||
* 0 means undeterminable at time of registration
|
||||
* -1 means the field is not registered. */
|
||||
gint
|
||||
proto_registrar_get_length(const int n)
|
||||
proto_registrar_get_length(int n)
|
||||
{
|
||||
header_field_info *hfinfo;
|
||||
|
||||
|
@ -5356,7 +5356,7 @@ proto_registrar_get_length(const int n)
|
|||
/* Looks for a protocol or a field in a proto_tree. Returns TRUE if
|
||||
* it exists anywhere, or FALSE if it exists nowhere. */
|
||||
gboolean
|
||||
proto_check_for_protocol_or_field(const proto_tree* tree, const int id)
|
||||
proto_check_for_protocol_or_field(proto_tree* tree, int id)
|
||||
{
|
||||
GPtrArray *ptrs = proto_get_finfo_ptr_array(tree, id);
|
||||
|
||||
|
@ -5377,7 +5377,7 @@ proto_check_for_protocol_or_field(const proto_tree* tree, const int id)
|
|||
* The caller should *not* free the GPtrArray*; proto_tree_free_node()
|
||||
* handles that. */
|
||||
GPtrArray*
|
||||
proto_get_finfo_ptr_array(const proto_tree *tree, const int id)
|
||||
proto_get_finfo_ptr_array(proto_tree *tree, int id)
|
||||
{
|
||||
if (!tree)
|
||||
return NULL;
|
||||
|
@ -5390,7 +5390,7 @@ proto_get_finfo_ptr_array(const proto_tree *tree, const int id)
|
|||
}
|
||||
|
||||
gboolean
|
||||
proto_tracking_interesting_fields(const proto_tree *tree)
|
||||
proto_tracking_interesting_fields(proto_tree *tree)
|
||||
{
|
||||
if (!tree)
|
||||
return FALSE;
|
||||
|
@ -5426,7 +5426,7 @@ find_finfo(proto_node *node, gpointer data)
|
|||
* g_ptr_array_free(<array>, TRUE).
|
||||
*/
|
||||
GPtrArray*
|
||||
proto_find_finfo(proto_tree *tree, const int id)
|
||||
proto_find_finfo(proto_tree *tree, int id)
|
||||
{
|
||||
ffdata_t ffdata;
|
||||
|
||||
|
@ -5473,7 +5473,7 @@ typedef struct {
|
|||
} offset_search_t;
|
||||
|
||||
static gboolean
|
||||
check_for_offset(proto_node *node, const gpointer data)
|
||||
check_for_offset(proto_node *node, gpointer data)
|
||||
{
|
||||
field_info *fi = PNODE_FINFO(node);
|
||||
offset_search_t *offsearch = data;
|
||||
|
@ -5728,7 +5728,7 @@ proto_registrar_dump_values(void)
|
|||
* Field 8 = bitmask: format: hex: 0x....
|
||||
*/
|
||||
void
|
||||
proto_registrar_dump_fields(const int format)
|
||||
proto_registrar_dump_fields(int format)
|
||||
{
|
||||
header_field_info *hfinfo, *parent_hfinfo;
|
||||
int i, len;
|
||||
|
@ -5848,7 +5848,7 @@ proto_registrar_dump_fields(const int format)
|
|||
}
|
||||
|
||||
static const char*
|
||||
hfinfo_numeric_format(const header_field_info *hfinfo)
|
||||
hfinfo_numeric_format(header_field_info *hfinfo)
|
||||
{
|
||||
const char *format = NULL;
|
||||
|
||||
|
@ -6188,8 +6188,8 @@ proto_construct_match_selected_string(field_info *finfo, epan_dissect_t *edt)
|
|||
* proto_tree_add_bitmask_text() functions.
|
||||
*/
|
||||
static gboolean
|
||||
proto_item_add_bitmask_tree(proto_item *item, tvbuff_t *tvb, const int offset, const int len, const gint ett,
|
||||
const int **fields, const gboolean little_endian, const int flags, gboolean first)
|
||||
proto_item_add_bitmask_tree(proto_item *item, tvbuff_t *tvb, int offset, int len, gint ett,
|
||||
const int **fields, gboolean little_endian, int flags, gboolean first)
|
||||
{
|
||||
guint32 value = 0, tmpval;
|
||||
proto_tree *tree = NULL;
|
||||
|
@ -6324,8 +6324,8 @@ proto_item_add_bitmask_tree(proto_item *item, tvbuff_t *tvb, const int offset, c
|
|||
* matched string displayed on the expansion line.
|
||||
*/
|
||||
proto_item *
|
||||
proto_tree_add_bitmask(proto_tree *parent_tree, tvbuff_t *tvb, const guint offset, const int hf_hdr,
|
||||
const gint ett, const int **fields, const gboolean little_endian)
|
||||
proto_tree_add_bitmask(proto_tree *parent_tree, tvbuff_t *tvb, guint offset, int hf_hdr,
|
||||
gint ett, const int **fields, gboolean little_endian)
|
||||
{
|
||||
proto_item *item = NULL;
|
||||
header_field_info *hf;
|
||||
|
@ -6346,9 +6346,9 @@ proto_tree_add_bitmask(proto_tree *parent_tree, tvbuff_t *tvb, const guint offse
|
|||
|
||||
/* The same as proto_tree_add_bitmask(), but using an arbitrary text as a top-level item */
|
||||
proto_item *
|
||||
proto_tree_add_bitmask_text(proto_tree *parent_tree, tvbuff_t *tvb, const guint offset, const guint len,
|
||||
proto_tree_add_bitmask_text(proto_tree *parent_tree, tvbuff_t *tvb, guint offset, guint len,
|
||||
const char *name, const char *fallback,
|
||||
const gint ett, const int **fields, const gboolean little_endian, const int flags)
|
||||
gint ett, const int **fields, gboolean little_endian, int flags)
|
||||
{
|
||||
proto_item *item = NULL;
|
||||
|
||||
|
@ -6365,7 +6365,7 @@ proto_tree_add_bitmask_text(proto_tree *parent_tree, tvbuff_t *tvb, const guint
|
|||
}
|
||||
|
||||
proto_item *
|
||||
proto_tree_add_bits_item(proto_tree *tree, const int hf_index, tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits, const gboolean little_endian)
|
||||
proto_tree_add_bits_item(proto_tree *tree, int hf_index, tvbuff_t *tvb, gint bit_offset, gint no_of_bits, gboolean little_endian)
|
||||
{
|
||||
header_field_info *hfinfo;
|
||||
|
||||
|
@ -6381,7 +6381,7 @@ proto_tree_add_bits_item(proto_tree *tree, const int hf_index, tvbuff_t *tvb, co
|
|||
*/
|
||||
|
||||
proto_item *
|
||||
proto_tree_add_bits_ret_val(proto_tree *tree, const int hf_index, tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits, guint64 *return_value, const gboolean little_endian)
|
||||
proto_tree_add_bits_ret_val(proto_tree *tree, int hf_index, tvbuff_t *tvb, gint bit_offset, gint no_of_bits, guint64 *return_value, gboolean little_endian)
|
||||
{
|
||||
const char *format = NULL;
|
||||
gint offset;
|
||||
|
@ -6497,7 +6497,7 @@ proto_tree_add_bits_ret_val(proto_tree *tree, const int hf_index, tvbuff_t *tvb,
|
|||
}
|
||||
|
||||
proto_item *
|
||||
proto_tree_add_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits, void *value_ptr, gchar *value_str)
|
||||
proto_tree_add_bits_format_value(proto_tree *tree, int hf_index, tvbuff_t *tvb, gint bit_offset, gint no_of_bits, void *value_ptr, gchar *value_str)
|
||||
{
|
||||
gint offset;
|
||||
guint length;
|
||||
|
@ -6599,7 +6599,7 @@ proto_tree_add_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t
|
|||
va_end(ap);
|
||||
|
||||
proto_item *
|
||||
proto_tree_add_uint_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits,
|
||||
proto_tree_add_uint_bits_format_value(proto_tree *tree, int hf_index, tvbuff_t *tvb, gint bit_offset, gint no_of_bits,
|
||||
guint32 value, const char *format, ...)
|
||||
{
|
||||
va_list ap;
|
||||
|
@ -6627,7 +6627,7 @@ proto_tree_add_uint_bits_format_value(proto_tree *tree, const int hf_index, tvbu
|
|||
}
|
||||
|
||||
proto_item *
|
||||
proto_tree_add_float_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits,
|
||||
proto_tree_add_float_bits_format_value(proto_tree *tree, int hf_index, tvbuff_t *tvb, gint bit_offset, gint no_of_bits,
|
||||
float value, const char *format, ...)
|
||||
{
|
||||
va_list ap;
|
||||
|
@ -6644,7 +6644,7 @@ proto_tree_add_float_bits_format_value(proto_tree *tree, const int hf_index, tvb
|
|||
}
|
||||
|
||||
proto_item *
|
||||
proto_tree_add_int_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits,
|
||||
proto_tree_add_int_bits_format_value(proto_tree *tree, int hf_index, tvbuff_t *tvb, gint bit_offset, gint no_of_bits,
|
||||
gint32 value, const char *format, ...)
|
||||
{
|
||||
va_list ap;
|
||||
|
@ -6672,7 +6672,7 @@ proto_tree_add_int_bits_format_value(proto_tree *tree, const int hf_index, tvbuf
|
|||
}
|
||||
|
||||
proto_item *
|
||||
proto_tree_add_boolean_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits,
|
||||
proto_tree_add_boolean_bits_format_value(proto_tree *tree, int hf_index, tvbuff_t *tvb, gint bit_offset, gint no_of_bits,
|
||||
guint32 value, const char *format, ...)
|
||||
{
|
||||
va_list ap;
|
||||
|
|
100
epan/proto.h
100
epan/proto.h
|
@ -413,17 +413,17 @@ extern gboolean proto_field_is_referenced(proto_tree *tree, int proto_id);
|
|||
@param ti the parent item of the new subtree
|
||||
@param idx one of the ett_ array elements registered with proto_register_subtree_array()
|
||||
@return the new subtree */
|
||||
extern proto_tree* proto_item_add_subtree(proto_item *ti, const gint idx);
|
||||
extern proto_tree* proto_item_add_subtree(proto_item *ti, gint idx);
|
||||
|
||||
/** Get an existing subtree under an item.
|
||||
@param ti the parent item of the subtree
|
||||
@return the subtree or NULL */
|
||||
extern proto_tree* proto_item_get_subtree(const proto_item *ti);
|
||||
extern proto_tree* proto_item_get_subtree(proto_item *ti);
|
||||
|
||||
/** Get the parent of a subtree item.
|
||||
@param ti the child item in the subtree
|
||||
@return parent item or NULL */
|
||||
extern proto_item* proto_item_get_parent(const proto_item *ti);
|
||||
extern proto_item* proto_item_get_parent(proto_item *ti);
|
||||
|
||||
/** Get Nth generation parent item.
|
||||
@param ti the child item in the subtree
|
||||
|
@ -448,7 +448,7 @@ extern void proto_item_append_text(proto_item *ti, const char *format, ...)
|
|||
/** Set proto_item's length inside tvb, after it has already been created.
|
||||
@param ti the item to set the length
|
||||
@param length the new length ot the item */
|
||||
extern void proto_item_set_len(proto_item *ti, const gint length);
|
||||
extern void proto_item_set_len(proto_item *ti, gint length);
|
||||
|
||||
/**
|
||||
* Sets the length of the item based on its start and on the specified
|
||||
|
@ -466,7 +466,7 @@ extern void proto_item_set_end(proto_item *ti, tvbuff_t *tvb, gint end);
|
|||
* to add a variable-length field (e.g., FT_NSTRING_UINT8).
|
||||
@param ti the item to get the length from
|
||||
@return the current length */
|
||||
extern int proto_item_get_len(const proto_item *ti);
|
||||
extern int proto_item_get_len(proto_item *ti);
|
||||
|
||||
/**
|
||||
* Sets an expert info to the proto_item.
|
||||
|
@ -475,7 +475,7 @@ extern int proto_item_get_len(const proto_item *ti);
|
|||
@param severity of this info (e.g. PI_ERROR)
|
||||
@return TRUE if value was written
|
||||
*/
|
||||
extern gboolean proto_item_set_expert_flags(proto_item *ti, const int group, const guint severity);
|
||||
extern gboolean proto_item_set_expert_flags(proto_item *ti, int group, guint severity);
|
||||
|
||||
|
||||
|
||||
|
@ -509,12 +509,12 @@ proto_tree_set_fake_protocols(proto_tree *tree, gboolean fake_protocols);
|
|||
@param hfid the interesting field id
|
||||
@todo what *does* interesting mean? */
|
||||
extern void
|
||||
proto_tree_prime_hfid(proto_tree *tree, const int hfid);
|
||||
proto_tree_prime_hfid(proto_tree *tree, int hfid);
|
||||
|
||||
/** Get a parent item of a subtree.
|
||||
@param tree the tree to get the parent from
|
||||
@return parent item */
|
||||
extern proto_item* proto_tree_get_parent(const proto_tree *tree);
|
||||
extern proto_item* proto_tree_get_parent(proto_tree *tree);
|
||||
|
||||
/** Get the root tree from any subtree.
|
||||
@param tree the tree to get the root from
|
||||
|
@ -533,7 +533,7 @@ extern void proto_tree_move_item(proto_tree *tree, proto_item *fixed_item, proto
|
|||
@param tvb the tv buffer of the current data
|
||||
@param start the start offset of the appendix
|
||||
@param length the length of the appendix */
|
||||
extern void proto_tree_set_appendix(proto_tree *tree, tvbuff_t *tvb, gint start, const gint length);
|
||||
extern void proto_tree_set_appendix(proto_tree *tree, tvbuff_t *tvb, gint start, gint length);
|
||||
|
||||
|
||||
/** Add an item to a proto_tree, using the text label registered to that item.
|
||||
|
@ -546,8 +546,8 @@ extern void proto_tree_set_appendix(proto_tree *tree, tvbuff_t *tvb, gint start,
|
|||
@param little_endian big or little endian byte representation
|
||||
@return the newly created item */
|
||||
extern proto_item *
|
||||
proto_tree_add_item(proto_tree *tree, const int hfindex, tvbuff_t *tvb,
|
||||
const gint start, gint length, const gboolean little_endian);
|
||||
proto_tree_add_item(proto_tree *tree, int hfindex, tvbuff_t *tvb,
|
||||
gint start, gint length, gboolean little_endian);
|
||||
|
||||
/** Add a text-only node to a proto_tree.
|
||||
@param tree the tree to append this item to
|
||||
|
@ -1360,13 +1360,13 @@ proto_register_protocol(const char *name, const char *short_name, const char *fi
|
|||
/** Mark protocol as private
|
||||
@param proto_id the handle of the protocol */
|
||||
extern void
|
||||
proto_mark_private(const int proto_id);
|
||||
proto_mark_private(int proto_id);
|
||||
|
||||
/** Return if protocol is private
|
||||
@param proto_id the handle of the protocol
|
||||
@return TRUE if it is a private protocol, FALSE is not. */
|
||||
extern gboolean
|
||||
proto_is_private(const int proto_id);
|
||||
proto_is_private(int proto_id);
|
||||
|
||||
/** This is the type of function can be registered to get called whenever
|
||||
a given field was not found but a its prefix is matched
|
||||
|
@ -1388,7 +1388,7 @@ extern void proto_initialize_all_prefixes(void);
|
|||
@param hf the hf_register_info array
|
||||
@param num_records the number of records in hf */
|
||||
extern void
|
||||
proto_register_field_array(const int parent, hf_register_info *hf, const int num_records);
|
||||
proto_register_field_array(int parent, hf_register_info *hf, int num_records);
|
||||
|
||||
/** Register a protocol subtree (ett) array.
|
||||
@param indices array of ett indices
|
||||
|
@ -1403,12 +1403,12 @@ extern int proto_registrar_n(void);
|
|||
/** Get name of registered header_field number n.
|
||||
@param n item # n (0-indexed)
|
||||
@return the name of this registered item */
|
||||
extern const char* proto_registrar_get_name(const int n);
|
||||
extern const char* proto_registrar_get_name(int n);
|
||||
|
||||
/** Get abbreviation of registered header_field number n.
|
||||
@param n item # n (0-indexed)
|
||||
@return the abbreviation of this registered item */
|
||||
extern const char* proto_registrar_get_abbrev(const int n);
|
||||
extern const char* proto_registrar_get_abbrev(int n);
|
||||
|
||||
/** Get the header_field information based upon a field or protocol id.
|
||||
@param hfindex item # n (0-indexed)
|
||||
|
@ -1423,22 +1423,22 @@ extern header_field_info* proto_registrar_get_byname(const char *field_name);
|
|||
/** Get enum ftenum FT_ of registered header_field number n.
|
||||
@param n item # n (0-indexed)
|
||||
@return the registered item */
|
||||
extern int proto_registrar_get_ftype(const int n);
|
||||
extern int proto_registrar_get_ftype(int n);
|
||||
|
||||
/** Get parent protocol of registered header_field number n.
|
||||
@param n item # n (0-indexed)
|
||||
@return -1 if item _is_ a protocol */
|
||||
extern int proto_registrar_get_parent(const int n);
|
||||
extern int proto_registrar_get_parent(int n);
|
||||
|
||||
/** Is item # n a protocol?
|
||||
@param n item # n (0-indexed)
|
||||
@return TRUE if it's a protocol, FALSE if it's not */
|
||||
extern gboolean proto_registrar_is_protocol(const int n);
|
||||
extern gboolean proto_registrar_is_protocol(int n);
|
||||
|
||||
/** Get length of registered field according to field type.
|
||||
@param n item # n (0-indexed)
|
||||
@return 0 means undeterminable at registration time, -1 means unknown field */
|
||||
extern gint proto_registrar_get_length(const int n);
|
||||
extern gint proto_registrar_get_length(int n);
|
||||
|
||||
|
||||
/** Routines to use to iterate over the protocols and their fields;
|
||||
|
@ -1446,7 +1446,7 @@ extern gint proto_registrar_get_length(const int n);
|
|||
* appropriate hfinfo pointer, and keep state in "*cookie". */
|
||||
extern int proto_get_first_protocol(void **cookie);
|
||||
extern int proto_get_next_protocol(void **cookie);
|
||||
extern header_field_info *proto_get_first_protocol_field(const int proto_id, void **cookle);
|
||||
extern header_field_info *proto_get_first_protocol_field(int proto_id, void **cookle);
|
||||
extern header_field_info *proto_get_next_protocol_field(void **cookle);
|
||||
|
||||
/** Given a protocol's filter_name.
|
||||
|
@ -1461,66 +1461,66 @@ extern gboolean proto_can_toggle_protocol(int proto_id);
|
|||
|
||||
/** Get the "protocol_t" structure for the given protocol's item number.
|
||||
@param proto_id protocol id (0-indexed) */
|
||||
extern protocol_t *find_protocol_by_id(const int proto_id);
|
||||
extern protocol_t *find_protocol_by_id(int proto_id);
|
||||
|
||||
/** Get the protocol's name for the given protocol's item number.
|
||||
@param proto_id protocol id (0-indexed)
|
||||
@return its name */
|
||||
extern const char *proto_get_protocol_name(const int proto_id);
|
||||
extern const char *proto_get_protocol_name(int proto_id);
|
||||
|
||||
/** Get the protocol's item number, for the given protocol's "protocol_t".
|
||||
@return its proto_id */
|
||||
extern int proto_get_id(const protocol_t *protocol);
|
||||
extern int proto_get_id(protocol_t *protocol);
|
||||
|
||||
/** Get the protocol's short name, for the given protocol's "protocol_t".
|
||||
@return its short name. */
|
||||
extern const char *proto_get_protocol_short_name(const protocol_t *protocol);
|
||||
extern const char *proto_get_protocol_short_name(protocol_t *protocol);
|
||||
|
||||
/** Get the protocol's long name, for the given protocol's "protocol_t".
|
||||
@return its long name. */
|
||||
extern const char *proto_get_protocol_long_name(const protocol_t *protocol);
|
||||
extern const char *proto_get_protocol_long_name(protocol_t *protocol);
|
||||
|
||||
/** Is protocol's decoding enabled ?
|
||||
@param protocol
|
||||
@return TRUE if decoding is enabled, FALSE if not */
|
||||
extern gboolean proto_is_protocol_enabled(const protocol_t *protocol);
|
||||
extern gboolean proto_is_protocol_enabled(protocol_t *protocol);
|
||||
|
||||
/** Get a protocol's filter name by it's item number.
|
||||
@param proto_id protocol id (0-indexed)
|
||||
@return its filter name. */
|
||||
extern const char *proto_get_protocol_filter_name(const int proto_id);
|
||||
extern const char *proto_get_protocol_filter_name(int proto_id);
|
||||
|
||||
/** Enable / Disable protocol of the given item number.
|
||||
@param proto_id protocol id (0-indexed)
|
||||
@param enabled enable / disable the protocol */
|
||||
extern void proto_set_decoding(const int proto_id, const gboolean enabled);
|
||||
extern void proto_set_decoding(int proto_id, gboolean enabled);
|
||||
|
||||
/** Enable all protocols */
|
||||
extern void proto_enable_all(void);
|
||||
|
||||
/** Disable disabling/enabling of protocol of the given item number.
|
||||
@param proto_id protocol id (0-indexed) */
|
||||
extern void proto_set_cant_toggle(const int proto_id);
|
||||
extern void proto_set_cant_toggle(int proto_id);
|
||||
|
||||
/** Checks for existence any protocol or field within a tree.
|
||||
@param tree "Protocols" are assumed to be a child of the [empty] root node.
|
||||
@param id hfindex of protocol or field
|
||||
@return TRUE = found, FALSE = not found
|
||||
@todo add explanation of id parameter */
|
||||
extern gboolean proto_check_for_protocol_or_field(const proto_tree* tree, const int id);
|
||||
extern gboolean proto_check_for_protocol_or_field(proto_tree* tree, int id);
|
||||
|
||||
/** Return GPtrArray* of field_info pointers for all hfindex that appear in
|
||||
tree. Only works with primed trees, and is fast.
|
||||
@param tree tree of interest
|
||||
@param hfindex primed hfindex
|
||||
@return GPtrArry pointer */
|
||||
extern GPtrArray* proto_get_finfo_ptr_array(const proto_tree *tree, const int hfindex);
|
||||
extern GPtrArray* proto_get_finfo_ptr_array(proto_tree *tree, int hfindex);
|
||||
|
||||
/** Return whether we're tracking any interesting fields.
|
||||
Only works with primed trees, and is fast.
|
||||
@param tree tree of interest
|
||||
@return TRUE if we're tracking interesting fields */
|
||||
extern gboolean proto_tracking_interesting_fields(const proto_tree *tree);
|
||||
extern gboolean proto_tracking_interesting_fields(proto_tree *tree);
|
||||
|
||||
/** Return GPtrArray* of field_info pointers for all hfindex that appear in
|
||||
tree. Works with any tree, primed or unprimed, and is slower than
|
||||
|
@ -1528,7 +1528,7 @@ extern gboolean proto_tracking_interesting_fields(const proto_tree *tree);
|
|||
@param tree tree of interest
|
||||
@param hfidex index of field info of interest
|
||||
@return GPtrArry pointer */
|
||||
extern GPtrArray* proto_find_finfo(proto_tree *tree, const int hfindex);
|
||||
extern GPtrArray* proto_find_finfo(proto_tree *tree, int hfindex);
|
||||
|
||||
/** Return GPtrArray* of field_info pointers containg all hfindexes that appear
|
||||
in tree.
|
||||
|
@ -1545,7 +1545,7 @@ extern void proto_registrar_dump_values(void);
|
|||
/** Dumps a glossary of the protocol and field registrations to STDOUT.
|
||||
* Format 1 is the original format. Format 2 includes the base (for integers)
|
||||
* and the blurb. */
|
||||
extern void proto_registrar_dump_fields(const int format);
|
||||
extern void proto_registrar_dump_fields(int format);
|
||||
|
||||
|
||||
|
||||
|
@ -1568,7 +1568,7 @@ WS_VAR_IMPORT int num_tree_types;
|
|||
@param hfinfo header_field
|
||||
@return the bitwidth */
|
||||
extern int
|
||||
hfinfo_bitwidth(const header_field_info *hfinfo);
|
||||
hfinfo_bitwidth(header_field_info *hfinfo);
|
||||
|
||||
|
||||
|
||||
|
@ -1616,8 +1616,8 @@ proto_find_field_from_offset(proto_tree *tree, guint offset, tvbuff_t *tvb);
|
|||
@param little_endian big or little endian byte representation
|
||||
@return the newly created item */
|
||||
extern proto_item *
|
||||
proto_tree_add_bitmask(proto_tree *tree, tvbuff_t *tvb, const guint offset,
|
||||
const int hf_hdr, const gint ett, const int **fields, const gboolean little_endian);
|
||||
proto_tree_add_bitmask(proto_tree *tree, tvbuff_t *tvb, guint offset,
|
||||
int hf_hdr, gint ett, const int **fields, gboolean little_endian);
|
||||
|
||||
/** Add a text with a subtree of bitfields.
|
||||
@param tree the tree to append this item to
|
||||
|
@ -1630,9 +1630,9 @@ proto_tree_add_bitmask(proto_tree *tree, tvbuff_t *tvb, const guint offset,
|
|||
@param little_endian big or little endian byte representation
|
||||
@return the newly created item */
|
||||
extern proto_item *
|
||||
proto_tree_add_bitmask_text(proto_tree *tree, tvbuff_t *tvb, const guint offset, const guint len,
|
||||
proto_tree_add_bitmask_text(proto_tree *tree, tvbuff_t *tvb, guint offset, guint len,
|
||||
const char *name, const char *fallback,
|
||||
const gint ett, const int **fields, const gboolean little_endian, const int flags);
|
||||
gint ett, const int **fields, gboolean little_endian, int flags);
|
||||
|
||||
#define BMT_NO_APPEND 0x01 /**< Don't change the title at all */
|
||||
#define BMT_NO_INT 0x02 /**< Don't add integral (non-boolean) fields to title */
|
||||
|
@ -1649,7 +1649,7 @@ proto_tree_add_bitmask_text(proto_tree *tree, tvbuff_t *tvb, const guint offset,
|
|||
@param little_endian big or little endian byte representation
|
||||
@return the newly created item */
|
||||
extern proto_item *
|
||||
proto_tree_add_bits_item(proto_tree *tree, const int hf_index, tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits, const gboolean little_endian);
|
||||
proto_tree_add_bits_item(proto_tree *tree, int hf_index, tvbuff_t *tvb, gint bit_offset, gint no_of_bits, gboolean little_endian);
|
||||
|
||||
/** Add bits to a proto_tree, using the text label registered to that item.
|
||||
The item is extracted from the tvbuff handed to it.
|
||||
|
@ -1662,7 +1662,7 @@ proto_tree_add_bits_item(proto_tree *tree, const int hf_index, tvbuff_t *tvb, co
|
|||
@param little_endian big or little endian byte representation
|
||||
@return the newly created item */
|
||||
extern proto_item *
|
||||
proto_tree_add_bits_ret_val(proto_tree *tree, const int hf_index, tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits, guint64 *return_value, const gboolean little_endian);
|
||||
proto_tree_add_bits_ret_val(proto_tree *tree, int hf_index, tvbuff_t *tvb, gint bit_offset, gint no_of_bits, guint64 *return_value, gboolean little_endian);
|
||||
|
||||
/** Add bits for a FT_UINT8, FT_UINT16, FT_UINT24 or FT_UINT32
|
||||
header field to a proto_tree, with the format generating the
|
||||
|
@ -1677,8 +1677,8 @@ proto_tree_add_bits_ret_val(proto_tree *tree, const int hf_index, tvbuff_t *tvb,
|
|||
@param ... printf like parameters
|
||||
@return the newly created item */
|
||||
extern proto_item *
|
||||
proto_tree_add_uint_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits,
|
||||
const guint32 value, const char *format, ...) G_GNUC_PRINTF(7,8);
|
||||
proto_tree_add_uint_bits_format_value(proto_tree *tree, int hf_index, tvbuff_t *tvb, gint bit_offset, gint no_of_bits,
|
||||
guint32 value, const char *format, ...) G_GNUC_PRINTF(7,8);
|
||||
|
||||
/** Add bits for a FT_BOOLEAN header field to a proto_tree, with
|
||||
the format generating the string for the value and with the field
|
||||
|
@ -1693,7 +1693,7 @@ proto_tree_add_uint_bits_format_value(proto_tree *tree, const int hf_index, tvbu
|
|||
@param ... printf like parameters
|
||||
@return the newly created item */
|
||||
extern proto_item *
|
||||
proto_tree_add_boolean_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits,
|
||||
proto_tree_add_boolean_bits_format_value(proto_tree *tree, int hf_index, tvbuff_t *tvb, gint bit_offset, gint no_of_bits,
|
||||
guint32 value, const char *format, ...) G_GNUC_PRINTF(7,8);
|
||||
|
||||
/** Add bits for a FT_INT8, FT_INT16, FT_INT24 or FT_INT32
|
||||
|
@ -1709,7 +1709,7 @@ proto_tree_add_boolean_bits_format_value(proto_tree *tree, const int hf_index, t
|
|||
@param ... printf like parameters
|
||||
@return the newly created item */
|
||||
extern proto_item *
|
||||
proto_tree_add_int_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits,
|
||||
proto_tree_add_int_bits_format_value(proto_tree *tree, int hf_index, tvbuff_t *tvb, gint bit_offset, gint no_of_bits,
|
||||
gint32 value, const char *format, ...) G_GNUC_PRINTF(7,8);
|
||||
|
||||
/** Add bits for a FT_FLOAT header field to a proto_tree, with
|
||||
|
@ -1725,8 +1725,8 @@ proto_tree_add_int_bits_format_value(proto_tree *tree, const int hf_index, tvbuf
|
|||
@param ... printf like parameters
|
||||
@return the newly created item */
|
||||
extern proto_item *
|
||||
proto_tree_add_float_bits_format_value(proto_tree *tree, const int hf_index, tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits,
|
||||
const float value, const char *format, ...) G_GNUC_PRINTF(7,8);
|
||||
proto_tree_add_float_bits_format_value(proto_tree *tree, int hf_index, tvbuff_t *tvb, gint bit_offset, gint no_of_bits,
|
||||
float value, const char *format, ...) G_GNUC_PRINTF(7,8);
|
||||
|
||||
/** Check if given string is a valid field name
|
||||
@param field_name the field name to check
|
||||
|
@ -1741,9 +1741,9 @@ proto_check_field_name(const gchar *field_name);
|
|||
@param expr the filter expression
|
||||
@param aize the size of the string buffer */
|
||||
const gchar *
|
||||
proto_custom_set(proto_tree* tree, const int field_id,
|
||||
proto_custom_set(proto_tree* tree, int field_id,
|
||||
gchar *result,
|
||||
gchar *expr, const int size );
|
||||
gchar *expr, int size );
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
@ -246,7 +246,7 @@ free_all_fragments(gpointer key_arg, gpointer value, gpointer user_data _U_)
|
|||
}
|
||||
|
||||
/* ------------------------- */
|
||||
static fragment_data *new_head(const guint32 flags)
|
||||
static fragment_data *new_head(guint32 flags)
|
||||
{
|
||||
fragment_data *fd_head;
|
||||
/* If head/first structure in list only holds no other data than
|
||||
|
@ -413,7 +413,7 @@ reassemble_init(void)
|
|||
* g_free() that buffer.
|
||||
*/
|
||||
unsigned char *
|
||||
fragment_delete(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table)
|
||||
fragment_delete(packet_info *pinfo, guint32 id, GHashTable *fragment_table)
|
||||
{
|
||||
fragment_data *fd_head, *fd;
|
||||
fragment_key key;
|
||||
|
@ -460,7 +460,7 @@ fragment_delete(const packet_info *pinfo, const guint32 id, GHashTable *fragment
|
|||
* matching this packet. I.e. Is there reassembly going on or not for this packet?
|
||||
*/
|
||||
fragment_data *
|
||||
fragment_get(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table)
|
||||
fragment_get(packet_info *pinfo, guint32 id, GHashTable *fragment_table)
|
||||
{
|
||||
fragment_data *fd_head;
|
||||
fragment_key key;
|
||||
|
@ -477,7 +477,7 @@ fragment_get(const packet_info *pinfo, const guint32 id, GHashTable *fragment_ta
|
|||
|
||||
/* id *must* be the frame number for this to work! */
|
||||
fragment_data *
|
||||
fragment_get_reassembled(const guint32 id, GHashTable *reassembled_table)
|
||||
fragment_get_reassembled(packet_info *pinfo _U_, guint32 id, GHashTable *reassembled_table)
|
||||
{
|
||||
fragment_data *fd_head;
|
||||
reassembled_key key;
|
||||
|
@ -491,7 +491,7 @@ fragment_get_reassembled(const guint32 id, GHashTable *reassembled_table)
|
|||
}
|
||||
|
||||
fragment_data *
|
||||
fragment_get_reassembled_id(const packet_info *pinfo, const guint32 id, GHashTable *reassembled_table)
|
||||
fragment_get_reassembled_id(packet_info *pinfo, guint32 id, GHashTable *reassembled_table)
|
||||
{
|
||||
fragment_data *fd_head;
|
||||
reassembled_key key;
|
||||
|
@ -519,8 +519,8 @@ fragment_get_reassembled_id(const packet_info *pinfo, const guint32 id, GHashTab
|
|||
* actually means we want to defragment 3 blocks, block 0, 1 and 2.
|
||||
*/
|
||||
void
|
||||
fragment_set_tot_len(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table,
|
||||
const guint32 tot_len)
|
||||
fragment_set_tot_len(packet_info *pinfo, guint32 id, GHashTable *fragment_table,
|
||||
guint32 tot_len)
|
||||
{
|
||||
fragment_data *fd_head;
|
||||
fragment_key key;
|
||||
|
@ -541,7 +541,7 @@ fragment_set_tot_len(const packet_info *pinfo, const guint32 id, GHashTable *fra
|
|||
}
|
||||
|
||||
guint32
|
||||
fragment_get_tot_len(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table)
|
||||
fragment_get_tot_len(packet_info *pinfo, guint32 id, GHashTable *fragment_table)
|
||||
{
|
||||
fragment_data *fd_head;
|
||||
fragment_key key;
|
||||
|
@ -570,7 +570,7 @@ fragment_get_tot_len(const packet_info *pinfo, const guint32 id, GHashTable *fra
|
|||
*/
|
||||
|
||||
void
|
||||
fragment_set_partial_reassembly(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table)
|
||||
fragment_set_partial_reassembly(packet_info *pinfo, guint32 id, GHashTable *fragment_table)
|
||||
{
|
||||
fragment_data *fd_head;
|
||||
fragment_key key;
|
||||
|
@ -634,8 +634,8 @@ fragment_unhash(GHashTable *fragment_table, fragment_key *key)
|
|||
* frame number.
|
||||
*/
|
||||
static void
|
||||
fragment_reassembled(fragment_data *fd_head, const packet_info *pinfo,
|
||||
GHashTable *reassembled_table, const guint32 id)
|
||||
fragment_reassembled(fragment_data *fd_head, packet_info *pinfo,
|
||||
GHashTable *reassembled_table, guint32 id)
|
||||
{
|
||||
reassembled_key *new_key;
|
||||
fragment_data *fd;
|
||||
|
@ -687,9 +687,9 @@ fragment_reassembled(fragment_data *fd_head, const packet_info *pinfo,
|
|||
* are lowered when a new extension process is started.
|
||||
*/
|
||||
static gboolean
|
||||
fragment_add_work(fragment_data *fd_head, tvbuff_t *tvb, const int offset,
|
||||
const packet_info *pinfo, const guint32 frag_offset,
|
||||
const guint32 frag_data_len, const gboolean more_frags)
|
||||
fragment_add_work(fragment_data *fd_head, tvbuff_t *tvb, int offset,
|
||||
packet_info *pinfo, guint32 frag_offset,
|
||||
guint32 frag_data_len, gboolean more_frags)
|
||||
{
|
||||
fragment_data *fd;
|
||||
fragment_data *fd_i;
|
||||
|
@ -914,10 +914,10 @@ fragment_add_work(fragment_data *fd_head, tvbuff_t *tvb, const int offset,
|
|||
}
|
||||
|
||||
static fragment_data *
|
||||
fragment_add_common(tvbuff_t *tvb, const int offset, const packet_info *pinfo, const guint32 id,
|
||||
GHashTable *fragment_table, const guint32 frag_offset,
|
||||
const guint32 frag_data_len, const gboolean more_frags,
|
||||
const gboolean check_already_added)
|
||||
fragment_add_common(tvbuff_t *tvb, int offset, packet_info *pinfo, guint32 id,
|
||||
GHashTable *fragment_table, guint32 frag_offset,
|
||||
guint32 frag_data_len, gboolean more_frags,
|
||||
gboolean check_already_added)
|
||||
{
|
||||
fragment_key key, *new_key;
|
||||
fragment_data *fd_head;
|
||||
|
@ -1028,9 +1028,9 @@ fragment_add_common(tvbuff_t *tvb, const int offset, const packet_info *pinfo, c
|
|||
}
|
||||
|
||||
fragment_data *
|
||||
fragment_add(tvbuff_t *tvb, const int offset, const packet_info *pinfo, const guint32 id,
|
||||
GHashTable *fragment_table, const guint32 frag_offset,
|
||||
const guint32 frag_data_len, const gboolean more_frags)
|
||||
fragment_add(tvbuff_t *tvb, int offset, packet_info *pinfo, guint32 id,
|
||||
GHashTable *fragment_table, guint32 frag_offset,
|
||||
guint32 frag_data_len, gboolean more_frags)
|
||||
{
|
||||
return fragment_add_common(tvb, offset, pinfo, id, fragment_table,
|
||||
frag_offset, frag_data_len, more_frags, TRUE);
|
||||
|
@ -1041,20 +1041,20 @@ fragment_add(tvbuff_t *tvb, const int offset, const packet_info *pinfo, const gu
|
|||
* to the same reassembled PDU, e.g. with ONC RPC-over-TCP.
|
||||
*/
|
||||
fragment_data *
|
||||
fragment_add_multiple_ok(tvbuff_t *tvb, const int offset, const packet_info *pinfo,
|
||||
const guint32 id, GHashTable *fragment_table,
|
||||
const guint32 frag_offset, const guint32 frag_data_len,
|
||||
const gboolean more_frags)
|
||||
fragment_add_multiple_ok(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
||||
guint32 id, GHashTable *fragment_table,
|
||||
guint32 frag_offset, guint32 frag_data_len,
|
||||
gboolean more_frags)
|
||||
{
|
||||
return fragment_add_common(tvb, offset, pinfo, id, fragment_table,
|
||||
frag_offset, frag_data_len, more_frags, FALSE);
|
||||
}
|
||||
|
||||
fragment_data *
|
||||
fragment_add_check(tvbuff_t *tvb, const int offset, const packet_info *pinfo,
|
||||
const guint32 id, GHashTable *fragment_table,
|
||||
GHashTable *reassembled_table, const guint32 frag_offset,
|
||||
const guint32 frag_data_len, const gboolean more_frags)
|
||||
fragment_add_check(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
||||
guint32 id, GHashTable *fragment_table,
|
||||
GHashTable *reassembled_table, guint32 frag_offset,
|
||||
guint32 frag_data_len, gboolean more_frags)
|
||||
{
|
||||
reassembled_key reass_key;
|
||||
fragment_key key, *new_key, *old_key;
|
||||
|
@ -1145,7 +1145,7 @@ fragment_add_check(tvbuff_t *tvb, const int offset, const packet_info *pinfo,
|
|||
|
||||
static void
|
||||
fragment_defragment_and_free (fragment_data *fd_head, fragment_data *fd,
|
||||
const packet_info *pinfo)
|
||||
packet_info *pinfo)
|
||||
{
|
||||
fragment_data *fd_i = NULL;
|
||||
fragment_data *last_fd = NULL;
|
||||
|
@ -1216,10 +1216,10 @@ fragment_defragment_and_free (fragment_data *fd_head, fragment_data *fd,
|
|||
* The bsn for the first block is 0.
|
||||
*/
|
||||
static gboolean
|
||||
fragment_add_seq_work(fragment_data *fd_head, tvbuff_t *tvb, const int offset,
|
||||
const packet_info *pinfo, const guint32 frag_number,
|
||||
const guint32 frag_data_len, const gboolean more_frags,
|
||||
const guint32 flags _U_)
|
||||
fragment_add_seq_work(fragment_data *fd_head, tvbuff_t *tvb, int offset,
|
||||
packet_info *pinfo, guint32 frag_number,
|
||||
guint32 frag_data_len, gboolean more_frags,
|
||||
guint32 flags _U_)
|
||||
{
|
||||
fragment_data *fd;
|
||||
fragment_data *fd_i;
|
||||
|
@ -1451,9 +1451,9 @@ fragment_add_seq_work(fragment_data *fd_head, tvbuff_t *tvb, const int offset,
|
|||
* The bsn for the first block is 0.
|
||||
*/
|
||||
fragment_data *
|
||||
fragment_add_seq(tvbuff_t *tvb, const int offset, const packet_info *pinfo, const guint32 id,
|
||||
GHashTable *fragment_table, const guint32 frag_number,
|
||||
const guint32 frag_data_len, const gboolean more_frags)
|
||||
fragment_add_seq(tvbuff_t *tvb, int offset, packet_info *pinfo, guint32 id,
|
||||
GHashTable *fragment_table, guint32 frag_number,
|
||||
guint32 frag_data_len, gboolean more_frags)
|
||||
{
|
||||
fragment_key key;
|
||||
|
||||
|
@ -1470,10 +1470,10 @@ fragment_add_seq(tvbuff_t *tvb, const int offset, const packet_info *pinfo, cons
|
|||
|
||||
|
||||
fragment_data *
|
||||
fragment_add_dcerpc_dg(tvbuff_t *tvb, int offset, const packet_info *pinfo, const guint32 id,
|
||||
fragment_add_dcerpc_dg(tvbuff_t *tvb, int offset, packet_info *pinfo, guint32 id,
|
||||
void *v_act_id,
|
||||
GHashTable *fragment_table, const guint32 frag_number,
|
||||
const guint32 frag_data_len, const gboolean more_frags)
|
||||
GHashTable *fragment_table, guint32 frag_number,
|
||||
guint32 frag_data_len, gboolean more_frags)
|
||||
{
|
||||
e_uuid_t *act_id = (e_uuid_t *)v_act_id;
|
||||
dcerpc_fragment_key key;
|
||||
|
@ -1491,11 +1491,11 @@ fragment_add_dcerpc_dg(tvbuff_t *tvb, int offset, const packet_info *pinfo, cons
|
|||
}
|
||||
|
||||
fragment_data *
|
||||
fragment_add_seq_key(tvbuff_t *tvb, const int offset, const packet_info *pinfo,
|
||||
fragment_add_seq_key(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
||||
void *key, fragment_key_copier key_copier,
|
||||
GHashTable *fragment_table, guint32 frag_number,
|
||||
const guint32 frag_data_len, const gboolean more_frags,
|
||||
const guint32 flags)
|
||||
guint32 frag_data_len, gboolean more_frags,
|
||||
guint32 flags)
|
||||
{
|
||||
fragment_data *fd_head;
|
||||
fd_head = g_hash_table_lookup(fragment_table, key);
|
||||
|
@ -1645,11 +1645,11 @@ fragment_add_seq_key(tvbuff_t *tvb, const int offset, const packet_info *pinfo,
|
|||
* XXX - Should we simply return NULL for zero-length fragments?
|
||||
*/
|
||||
static fragment_data *
|
||||
fragment_add_seq_check_work(tvbuff_t *tvb, const int offset, const packet_info *pinfo,
|
||||
const guint32 id, GHashTable *fragment_table,
|
||||
GHashTable *reassembled_table, const guint32 frag_number,
|
||||
const guint32 frag_data_len, const gboolean more_frags,
|
||||
const guint32 flags)
|
||||
fragment_add_seq_check_work(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
||||
guint32 id, GHashTable *fragment_table,
|
||||
GHashTable *reassembled_table, guint32 frag_number,
|
||||
guint32 frag_data_len, gboolean more_frags,
|
||||
guint32 flags)
|
||||
{
|
||||
reassembled_key reass_key;
|
||||
fragment_key key;
|
||||
|
@ -1713,10 +1713,10 @@ fragment_add_seq_check_work(tvbuff_t *tvb, const int offset, const packet_info *
|
|||
}
|
||||
|
||||
fragment_data *
|
||||
fragment_add_seq_check(tvbuff_t *tvb, const int offset, const packet_info *pinfo,
|
||||
const guint32 id, GHashTable *fragment_table,
|
||||
GHashTable *reassembled_table, const guint32 frag_number,
|
||||
const guint32 frag_data_len, const gboolean more_frags)
|
||||
fragment_add_seq_check(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
||||
guint32 id, GHashTable *fragment_table,
|
||||
GHashTable *reassembled_table, guint32 frag_number,
|
||||
guint32 frag_data_len, gboolean more_frags)
|
||||
{
|
||||
return fragment_add_seq_check_work(tvb, offset, pinfo, id,
|
||||
fragment_table, reassembled_table, frag_number, frag_data_len,
|
||||
|
@ -1746,8 +1746,8 @@ fragment_add_seq_next(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
|||
}
|
||||
|
||||
void
|
||||
fragment_start_seq_check(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table,
|
||||
const guint32 tot_len)
|
||||
fragment_start_seq_check(packet_info *pinfo, guint32 id, GHashTable *fragment_table,
|
||||
guint32 tot_len)
|
||||
{
|
||||
fragment_key key, *new_key;
|
||||
fragment_data *fd_head;
|
||||
|
@ -1790,7 +1790,7 @@ fragment_start_seq_check(const packet_info *pinfo, const guint32 id, GHashTable
|
|||
}
|
||||
|
||||
fragment_data *
|
||||
fragment_end_seq_next(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table,
|
||||
fragment_end_seq_next(packet_info *pinfo, guint32 id, GHashTable *fragment_table,
|
||||
GHashTable *reassembled_table)
|
||||
{
|
||||
reassembled_key reass_key;
|
||||
|
@ -1869,7 +1869,7 @@ fragment_end_seq_next(const packet_info *pinfo, const guint32 id, GHashTable *fr
|
|||
* just put a "reassembled in" item into the protocol tree.
|
||||
*/
|
||||
tvbuff_t *
|
||||
process_reassembled_data(tvbuff_t *tvb, const int offset, packet_info *pinfo,
|
||||
process_reassembled_data(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
||||
const char *name, fragment_data *fd_head, const fragment_items *fit,
|
||||
gboolean *update_col_infop, proto_tree *tree)
|
||||
{
|
||||
|
@ -1953,8 +1953,8 @@ process_reassembled_data(tvbuff_t *tvb, const int offset, packet_info *pinfo,
|
|||
* it in the top-level item for that subtree.
|
||||
*/
|
||||
static void
|
||||
show_fragment(fragment_data *fd, const int offset, const fragment_items *fit,
|
||||
proto_tree *ft, proto_item *fi, const gboolean first_frag, tvbuff_t *tvb)
|
||||
show_fragment(fragment_data *fd, int offset, const fragment_items *fit,
|
||||
proto_tree *ft, proto_item *fi, gboolean first_frag, tvbuff_t *tvb)
|
||||
{
|
||||
proto_item *fei=NULL;
|
||||
int hf;
|
||||
|
|
|
@ -132,12 +132,12 @@ void reassemble_init(void);
|
|||
* Returns a pointer to the head of the fragment data list if we have all the
|
||||
* fragments, NULL otherwise.
|
||||
*/
|
||||
extern fragment_data *fragment_add(tvbuff_t *tvb, const int offset, const packet_info *pinfo,
|
||||
const guint32 id, GHashTable *fragment_table, const guint32 frag_offset,
|
||||
guint32 const frag_data_len, const gboolean more_frags);
|
||||
extern fragment_data *fragment_add_multiple_ok(tvbuff_t *tvb, const int offset,
|
||||
const packet_info *pinfo, const guint32 id, GHashTable *fragment_table,
|
||||
const guint32 frag_offset, const guint32 frag_data_len, const gboolean more_frags);
|
||||
extern fragment_data *fragment_add(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
||||
guint32 id, GHashTable *fragment_table, guint32 frag_offset,
|
||||
guint32 frag_data_len, gboolean more_frags);
|
||||
extern fragment_data *fragment_add_multiple_ok(tvbuff_t *tvb, int offset,
|
||||
packet_info *pinfo, guint32 id, GHashTable *fragment_table,
|
||||
guint32 frag_offset, guint32 frag_data_len, gboolean more_frags);
|
||||
|
||||
/*
|
||||
* This routine extends fragment_add to use a "reassembled_table".
|
||||
|
@ -147,10 +147,10 @@ extern fragment_data *fragment_add_multiple_ok(tvbuff_t *tvb, const int offset,
|
|||
* to the table of reassembled fragments, and return a pointer to the
|
||||
* head of the fragment list.
|
||||
*/
|
||||
extern fragment_data *fragment_add_check(tvbuff_t *tvb, const int offset,
|
||||
const packet_info *pinfo, const guint32 id, GHashTable *fragment_table,
|
||||
GHashTable *reassembled_table, const guint32 frag_offset,
|
||||
const guint32 frag_data_len, const gboolean more_frags);
|
||||
extern fragment_data *fragment_add_check(tvbuff_t *tvb, int offset,
|
||||
packet_info *pinfo, guint32 id, GHashTable *fragment_table,
|
||||
GHashTable *reassembled_table, guint32 frag_offset,
|
||||
guint32 frag_data_len, gboolean more_frags);
|
||||
|
||||
/* same as fragment_add() but this one assumes frag_number is a block
|
||||
sequence number. note that frag_number is 0 for the first fragment. */
|
||||
|
@ -186,24 +186,24 @@ extern fragment_data *fragment_add_check(tvbuff_t *tvb, const int offset,
|
|||
* inserting a new entry to the hash.
|
||||
*/
|
||||
extern fragment_data *
|
||||
fragment_add_seq_key(tvbuff_t *tvb, const int offset, const packet_info *pinfo,
|
||||
fragment_add_seq_key(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
||||
void *key, fragment_key_copier key_copier,
|
||||
GHashTable *fragment_table, guint32 frag_number,
|
||||
const guint32 frag_data_len, const gboolean more_frags,
|
||||
const guint32 flags);
|
||||
guint32 frag_data_len, gboolean more_frags,
|
||||
guint32 flags);
|
||||
|
||||
/* a wrapper for fragment_add_seq_key - uses a key of source, dest and id */
|
||||
extern fragment_data *fragment_add_seq(tvbuff_t *tvb, const int offset, const packet_info *pinfo,
|
||||
const guint32 id, GHashTable *fragment_table, const guint32 frag_number,
|
||||
const guint32 frag_data_len, const gboolean more_frags);
|
||||
extern fragment_data *fragment_add_seq(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
||||
guint32 id, GHashTable *fragment_table, guint32 frag_number,
|
||||
guint32 frag_data_len, gboolean more_frags);
|
||||
|
||||
/* another wrapper for fragment_add_seq_key - uses a key of source, dest, id
|
||||
* and act_id */
|
||||
extern fragment_data *
|
||||
fragment_add_dcerpc_dg(tvbuff_t *tvb, const int offset, const packet_info *pinfo, const guint32 id,
|
||||
fragment_add_dcerpc_dg(tvbuff_t *tvb, int offset, packet_info *pinfo, guint32 id,
|
||||
void *act_id,
|
||||
GHashTable *fragment_table, const guint32 frag_number,
|
||||
const guint32 frag_data_len, const gboolean more_frags);
|
||||
GHashTable *fragment_table, guint32 frag_number,
|
||||
guint32 frag_data_len, gboolean more_frags);
|
||||
|
||||
/*
|
||||
* These routines extend fragment_add_seq_key to use a "reassembled_table".
|
||||
|
@ -214,10 +214,10 @@ fragment_add_dcerpc_dg(tvbuff_t *tvb, const int offset, const packet_info *pinfo
|
|||
* head of the fragment list.
|
||||
*/
|
||||
extern fragment_data *
|
||||
fragment_add_seq_check(tvbuff_t *tvb, const int offset, const packet_info *pinfo,
|
||||
const guint32 id, GHashTable *fragment_table,
|
||||
GHashTable *reassembled_table, const guint32 frag_number,
|
||||
const guint32 frag_data_len, const gboolean more_frags);
|
||||
fragment_add_seq_check(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
||||
guint32 id, GHashTable *fragment_table,
|
||||
GHashTable *reassembled_table, guint32 frag_number,
|
||||
guint32 frag_data_len, gboolean more_frags);
|
||||
|
||||
extern fragment_data *
|
||||
fragment_add_seq_802_11(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
||||
|
@ -231,11 +231,11 @@ fragment_add_seq_next(tvbuff_t *tvb, int offset, packet_info *pinfo, guint32 id,
|
|||
guint32 frag_data_len, gboolean more_frags);
|
||||
|
||||
extern void
|
||||
fragment_start_seq_check(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table,
|
||||
const guint32 tot_len);
|
||||
fragment_start_seq_check(packet_info *pinfo, guint32 id, GHashTable *fragment_table,
|
||||
guint32 tot_len);
|
||||
|
||||
extern fragment_data *
|
||||
fragment_end_seq_next(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table,
|
||||
fragment_end_seq_next(packet_info *pinfo, guint32 id, GHashTable *fragment_table,
|
||||
GHashTable *reassembled_table);
|
||||
/* to specify how much to reassemble, for fragmentation where last fragment can not be
|
||||
* identified by flags or such.
|
||||
|
@ -245,12 +245,12 @@ fragment_end_seq_next(const packet_info *pinfo, const guint32 id, GHashTable *fr
|
|||
*
|
||||
*/
|
||||
extern void
|
||||
fragment_set_tot_len(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table,
|
||||
const guint32 tot_len);
|
||||
fragment_set_tot_len(packet_info *pinfo, guint32 id, GHashTable *fragment_table,
|
||||
guint32 tot_len);
|
||||
|
||||
/* to resad whatever totlen previously set */
|
||||
extern guint32
|
||||
fragment_get_tot_len(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table);
|
||||
fragment_get_tot_len(packet_info *pinfo, guint32 id, GHashTable *fragment_table);
|
||||
|
||||
/*
|
||||
* This function will set the partial reassembly flag(FD_PARTIAL_REASSEMBLY) for a fh.
|
||||
|
@ -261,21 +261,21 @@ fragment_get_tot_len(const packet_info *pinfo, const guint32 id, GHashTable *fra
|
|||
* and if FD_DEFRAGMENTED is set, the reassembly process will be continued.
|
||||
*/
|
||||
extern void
|
||||
fragment_set_partial_reassembly(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table);
|
||||
fragment_set_partial_reassembly(packet_info *pinfo, guint32 id, GHashTable *fragment_table);
|
||||
|
||||
/* This function is used to check if there is partial or completed reassembly state
|
||||
* matching this packet. I.e. Are there reassembly going on or not for this packet?
|
||||
*/
|
||||
extern fragment_data *
|
||||
fragment_get(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table);
|
||||
fragment_get(packet_info *pinfo, guint32 id, GHashTable *fragment_table);
|
||||
|
||||
/* The same for the reassemble table */
|
||||
/* id *must* be the frame number for this to work! */
|
||||
extern fragment_data *
|
||||
fragment_get_reassembled(const guint32 id, GHashTable *reassembled_table);
|
||||
fragment_get_reassembled(packet_info *pinfo, guint32 id, GHashTable *reassembled_table);
|
||||
|
||||
extern fragment_data *
|
||||
fragment_get_reassembled_id(const packet_info *pinfo, const guint32 id, GHashTable *reassembled_table);
|
||||
fragment_get_reassembled_id(packet_info *pinfo, guint32 id, GHashTable *reassembled_table);
|
||||
|
||||
/* This will free up all resources and delete reassembly state for this PDU.
|
||||
* Except if the PDU is completely reassembled, then it would NOT deallocate the
|
||||
|
@ -286,7 +286,7 @@ fragment_get_reassembled_id(const packet_info *pinfo, const guint32 id, GHashTab
|
|||
* g_free() that buffer.
|
||||
*/
|
||||
extern unsigned char *
|
||||
fragment_delete(const packet_info *pinfo, const guint32 id, GHashTable *fragment_table);
|
||||
fragment_delete(packet_info *pinfo, guint32 id, GHashTable *fragment_table);
|
||||
|
||||
/* hf_fragment, hf_fragment_error, and hf_reassembled_in should be
|
||||
FT_FRAMENUM, the others should be FT_BOOLEAN
|
||||
|
@ -309,7 +309,7 @@ typedef struct _fragment_items {
|
|||
} fragment_items;
|
||||
|
||||
extern tvbuff_t *
|
||||
process_reassembled_data(tvbuff_t *tvb, const int offset, packet_info *pinfo,
|
||||
process_reassembled_data(tvbuff_t *tvb, int offset, packet_info *pinfo,
|
||||
const char *name, fragment_data *fd_head, const fragment_items *fit,
|
||||
gboolean *update_col_infop, proto_tree *tree);
|
||||
|
||||
|
|
|
@ -118,7 +118,7 @@ bytes_to_hexstr_punct(char *out, const guint8 *ad, guint32 len, char punct) {
|
|||
* the resulting string is (len-1) bytes shorter)
|
||||
*/
|
||||
gchar *
|
||||
bytestring_to_str(const guint8 *ad, const guint32 len, const char punct) {
|
||||
bytestring_to_str(const guint8 *ad, guint32 len, char punct) {
|
||||
gchar *buf;
|
||||
size_t buflen;
|
||||
|
||||
|
@ -309,7 +309,7 @@ guint32_to_str(guint32 u) {
|
|||
* If time is negative, add a '-' to all non-null components.
|
||||
*/
|
||||
static void
|
||||
time_secs_to_str_buf(gint32 time_val, const guint32 frac, const gboolean is_nsecs,
|
||||
time_secs_to_str_buf(gint32 time_val, guint32 frac, gboolean is_nsecs,
|
||||
emem_strbuf_t *buf)
|
||||
{
|
||||
int hours, mins, secs;
|
||||
|
@ -360,7 +360,7 @@ time_secs_to_str_buf(gint32 time_val, const guint32 frac, const gboolean is_nsec
|
|||
}
|
||||
|
||||
gchar *
|
||||
time_secs_to_str(gint32 const time_val)
|
||||
time_secs_to_str(gint32 time_val)
|
||||
{
|
||||
emem_strbuf_t *buf;
|
||||
|
||||
|
@ -376,7 +376,7 @@ time_secs_to_str(gint32 const time_val)
|
|||
}
|
||||
|
||||
static void
|
||||
time_secs_to_str_buf_unsigned(guint32 time_val, const guint32 frac, const gboolean is_nsecs,
|
||||
time_secs_to_str_buf_unsigned(guint32 time_val, guint32 frac, gboolean is_nsecs,
|
||||
emem_strbuf_t *buf)
|
||||
{
|
||||
int hours, mins, secs;
|
||||
|
@ -473,7 +473,7 @@ static const char *mon_names[12] = {
|
|||
};
|
||||
|
||||
gchar *
|
||||
abs_time_to_str(const nstime_t *abs_time, const absolute_time_display_e fmt)
|
||||
abs_time_to_str(nstime_t *abs_time, absolute_time_display_e fmt)
|
||||
{
|
||||
struct tm *tmp = NULL;
|
||||
const char *zonename = "???";
|
||||
|
@ -543,7 +543,7 @@ abs_time_to_str(const nstime_t *abs_time, const absolute_time_display_e fmt)
|
|||
}
|
||||
|
||||
gchar *
|
||||
abs_time_secs_to_str(const time_t abs_time, const absolute_time_display_e fmt)
|
||||
abs_time_secs_to_str(time_t abs_time, absolute_time_display_e fmt)
|
||||
{
|
||||
struct tm *tmp = NULL;
|
||||
const char *zonename = "???";
|
||||
|
@ -611,8 +611,8 @@ abs_time_secs_to_str(const time_t abs_time, const absolute_time_display_e fmt)
|
|||
}
|
||||
|
||||
void
|
||||
display_signed_time(gchar *buf, int buflen, const gint32 sec, gint32 frac,
|
||||
const to_str_time_res_t units)
|
||||
display_signed_time(gchar *buf, int buflen, gint32 sec, gint32 frac,
|
||||
to_str_time_res_t units)
|
||||
{
|
||||
/* If the fractional part of the time stamp is negative,
|
||||
print its absolute value and, if the seconds part isn't
|
||||
|
@ -659,8 +659,8 @@ display_signed_time(gchar *buf, int buflen, const gint32 sec, gint32 frac,
|
|||
|
||||
|
||||
void
|
||||
display_epoch_time(gchar *buf, int buflen, const time_t sec, gint32 frac,
|
||||
const to_str_time_res_t units)
|
||||
display_epoch_time(gchar *buf, int buflen, time_t sec, gint32 frac,
|
||||
to_str_time_res_t units)
|
||||
{
|
||||
double elapsed_secs;
|
||||
|
||||
|
@ -715,7 +715,7 @@ display_epoch_time(gchar *buf, int buflen, const time_t sec, gint32 frac,
|
|||
* Display a relative time as days/hours/minutes/seconds.
|
||||
*/
|
||||
gchar *
|
||||
rel_time_to_str(const nstime_t *rel_time)
|
||||
rel_time_to_str(nstime_t *rel_time)
|
||||
{
|
||||
emem_strbuf_t *buf;
|
||||
const char *sign;
|
||||
|
@ -757,7 +757,7 @@ rel_time_to_str(const nstime_t *rel_time)
|
|||
* Display a relative time as seconds.
|
||||
*/
|
||||
gchar *
|
||||
rel_time_to_secs_str(const nstime_t *rel_time)
|
||||
rel_time_to_secs_str(nstime_t *rel_time)
|
||||
{
|
||||
gchar *buf;
|
||||
|
||||
|
@ -775,7 +775,7 @@ rel_time_to_secs_str(const nstime_t *rel_time)
|
|||
*/
|
||||
|
||||
char *
|
||||
decode_bits_in_field(const gint bit_offset, const gint no_of_bits, const guint64 value)
|
||||
decode_bits_in_field(gint bit_offset, gint no_of_bits, guint64 value)
|
||||
{
|
||||
guint64 mask = 0,tmp;
|
||||
char *str;
|
||||
|
@ -826,7 +826,7 @@ decode_bits_in_field(const gint bit_offset, const gint no_of_bits, const guint64
|
|||
Return a pointer to the character after that string. */
|
||||
/*XXX this needs a buf_len check */
|
||||
char *
|
||||
other_decode_bitfield_value(char *buf, const guint32 val, const guint32 mask, const int width)
|
||||
other_decode_bitfield_value(char *buf, guint32 val, guint32 mask, int width)
|
||||
{
|
||||
int i;
|
||||
guint32 bit;
|
||||
|
@ -858,7 +858,7 @@ other_decode_bitfield_value(char *buf, const guint32 val, const guint32 mask, co
|
|||
}
|
||||
|
||||
char *
|
||||
decode_bitfield_value(char *buf, const guint32 val, const guint32 mask, const int width)
|
||||
decode_bitfield_value(char *buf, guint32 val, guint32 mask, int width)
|
||||
{
|
||||
char *p;
|
||||
|
||||
|
@ -871,7 +871,7 @@ decode_bitfield_value(char *buf, const guint32 val, const guint32 mask, const in
|
|||
/* Generate a string describing a Boolean bitfield (a one-bit field that
|
||||
says something is either true of false). */
|
||||
const char *
|
||||
decode_boolean_bitfield(const guint32 val, const guint32 mask, const int width,
|
||||
decode_boolean_bitfield(guint32 val, guint32 mask, int width,
|
||||
const char *truedesc, const char *falsedesc)
|
||||
{
|
||||
char *buf;
|
||||
|
@ -889,7 +889,7 @@ decode_boolean_bitfield(const guint32 val, const guint32 mask, const int width,
|
|||
/* Generate a string describing a numeric bitfield (an N-bit field whose
|
||||
value is just a number). */
|
||||
const char *
|
||||
decode_numeric_bitfield(const guint32 val, const guint32 mask, const int width,
|
||||
decode_numeric_bitfield(guint32 val, guint32 mask, int width,
|
||||
const char *fmt)
|
||||
{
|
||||
char *buf;
|
||||
|
@ -912,7 +912,7 @@ decode_numeric_bitfield(const guint32 val, const guint32 mask, const int width,
|
|||
XXX update the ep_address_to_str stuff to use this function.
|
||||
*/
|
||||
void
|
||||
ip_to_str_buf(const guint8 *ad, gchar *buf, const int buf_len)
|
||||
ip_to_str_buf(const guint8 *ad, gchar *buf, int buf_len)
|
||||
{
|
||||
register gchar const *p;
|
||||
register gchar *b=buf;
|
||||
|
|
|
@ -47,10 +47,10 @@ struct e_in6_addr;
|
|||
extern gchar* ep_address_to_str(const address *);
|
||||
extern gchar* se_address_to_str(const address *);
|
||||
extern void address_to_str_buf(const address *addr, gchar *buf, int buf_len);
|
||||
extern gchar* bytestring_to_str(const guint8 *, const guint32, const char);
|
||||
extern gchar* bytestring_to_str(const guint8 *, guint32, char);
|
||||
extern gchar* ether_to_str(const guint8 *);
|
||||
extern const gchar* ip_to_str(const guint8 *);
|
||||
extern void ip_to_str_buf(const guint8 *ad, gchar *buf, const int buf_len);
|
||||
extern void ip_to_str_buf(const guint8 *ad, gchar *buf, int buf_len);
|
||||
extern gchar* fc_to_str(const guint8 *);
|
||||
extern gchar* fcwwn_to_str (const guint8 *);
|
||||
extern gchar* ip6_to_str(const struct e_in6_addr *);
|
||||
|
@ -62,28 +62,28 @@ extern gchar* vines_addr_to_str(const guint8 *addrp);
|
|||
extern gchar* time_secs_to_str(gint32);
|
||||
extern gchar* time_secs_to_str_unsigned(guint32);
|
||||
extern gchar* time_msecs_to_str(gint32);
|
||||
extern gchar* abs_time_to_str(const nstime_t*, const absolute_time_display_e fmt);
|
||||
extern gchar* abs_time_secs_to_str(const time_t, const absolute_time_display_e fmt);
|
||||
extern void display_signed_time(gchar *, int, const gint32, gint32, const to_str_time_res_t);
|
||||
extern void display_epoch_time(gchar *, int, const time_t, gint32, const to_str_time_res_t);
|
||||
extern gchar* abs_time_to_str(nstime_t*, absolute_time_display_e fmt);
|
||||
extern gchar* abs_time_secs_to_str(time_t, absolute_time_display_e fmt);
|
||||
extern void display_signed_time(gchar *, int, gint32, gint32, to_str_time_res_t);
|
||||
extern void display_epoch_time(gchar *, int, time_t, gint32, to_str_time_res_t);
|
||||
|
||||
extern gchar* guint32_to_str(guint32 u);
|
||||
extern void guint32_to_str_buf(guint32 u, gchar *buf, int buf_len);
|
||||
|
||||
extern gchar* rel_time_to_str(const nstime_t*);
|
||||
extern gchar* rel_time_to_secs_str(const nstime_t*);
|
||||
extern gchar* rel_time_to_str(nstime_t*);
|
||||
extern gchar* rel_time_to_secs_str(nstime_t*);
|
||||
extern gchar* guid_to_str(const e_guid_t*);
|
||||
extern gchar* guid_to_str_buf(const e_guid_t*, gchar*, int);
|
||||
|
||||
extern char *decode_bits_in_field(const gint bit_offset, const gint no_of_bits, const guint64 value);
|
||||
extern char *decode_bits_in_field(gint bit_offset, gint no_of_bits, guint64 value);
|
||||
|
||||
extern char *other_decode_bitfield_value(char *buf, const guint32 val, const guint32 mask,
|
||||
const int width);
|
||||
extern char *decode_bitfield_value(char *buf, const guint32 val, const guint32 mask,
|
||||
const int width);
|
||||
extern const char *decode_boolean_bitfield(const guint32 val, const guint32 mask, const int width,
|
||||
extern char *other_decode_bitfield_value(char *buf, guint32 val, guint32 mask,
|
||||
int width);
|
||||
extern char *decode_bitfield_value(char *buf, guint32 val, guint32 mask,
|
||||
int width);
|
||||
extern const char *decode_boolean_bitfield(guint32 val, guint32 mask, int width,
|
||||
const char *truedesc, const char *falsedesc);
|
||||
extern const char *decode_numeric_bitfield(const guint32 val, const guint32 mask, const int width,
|
||||
extern const char *decode_numeric_bitfield(guint32 val, guint32 mask, int width,
|
||||
const char *fmt);
|
||||
|
||||
#endif /* __TO_STR_H__ */
|
||||
|
|
|
@ -104,7 +104,7 @@ static tvbparse_elem_t* new_tok(tvbparse_t* tt,
|
|||
return tok;
|
||||
}
|
||||
|
||||
static int ignore_fcn(tvbparse_t* tt, int offset) {
|
||||
static int ignore_fcn(tvbparse_t* tt,int offset) {
|
||||
int len = 0;
|
||||
int consumed;
|
||||
tvbparse_elem_t* ignored = NULL;
|
||||
|
@ -132,7 +132,7 @@ static int ignore_fcn(tvbparse_t* tt, int offset) {
|
|||
}
|
||||
|
||||
|
||||
static int cond_char (tvbparse_t* tt, const int offset, const tvbparse_wanted_t * wanted, tvbparse_elem_t** tok) {
|
||||
static int cond_char (tvbparse_t* tt, int offset, const tvbparse_wanted_t * wanted, tvbparse_elem_t** tok) {
|
||||
gchar c,t;
|
||||
guint i;
|
||||
|
||||
|
@ -158,7 +158,7 @@ static int cond_char (tvbparse_t* tt, const int offset, const tvbparse_wanted_t
|
|||
return -1;
|
||||
}
|
||||
|
||||
tvbparse_wanted_t* tvbparse_char(const int id,
|
||||
tvbparse_wanted_t* tvbparse_char(int id,
|
||||
const gchar* chr,
|
||||
const void* data,
|
||||
tvbparse_action_t before_cb,
|
||||
|
@ -218,8 +218,8 @@ next_char:
|
|||
}
|
||||
|
||||
tvbparse_wanted_t* tvbparse_chars(int id,
|
||||
const guint min_len,
|
||||
const guint max_len,
|
||||
guint min_len,
|
||||
guint max_len,
|
||||
const gchar* chr,
|
||||
const void* data,
|
||||
tvbparse_action_t before_cb,
|
||||
|
@ -239,7 +239,7 @@ tvbparse_wanted_t* tvbparse_chars(int id,
|
|||
}
|
||||
|
||||
|
||||
static int cond_not_char(tvbparse_t* tt, const int offset, const tvbparse_wanted_t * wanted, tvbparse_elem_t** tok) {
|
||||
static int cond_not_char(tvbparse_t* tt, int offset, const tvbparse_wanted_t * wanted, tvbparse_elem_t** tok) {
|
||||
gchar c, t;
|
||||
guint i;
|
||||
gboolean not_matched = FALSE;
|
||||
|
@ -271,7 +271,7 @@ static int cond_not_char(tvbparse_t* tt, const int offset, const tvbparse_wanted
|
|||
}
|
||||
}
|
||||
|
||||
tvbparse_wanted_t* tvbparse_not_char(const int id,
|
||||
tvbparse_wanted_t* tvbparse_not_char(int id,
|
||||
const gchar* chr,
|
||||
const void* data,
|
||||
tvbparse_action_t before_cb,
|
||||
|
@ -354,7 +354,7 @@ tvbparse_wanted_t* tvbparse_not_chars(int id,
|
|||
}
|
||||
|
||||
|
||||
static int cond_string(tvbparse_t* tt, const int offset, const tvbparse_wanted_t * wanted, tvbparse_elem_t** tok) {
|
||||
static int cond_string(tvbparse_t* tt, int offset, const tvbparse_wanted_t * wanted, tvbparse_elem_t** tok) {
|
||||
int len = wanted->len;
|
||||
#ifdef TVBPARSE_DEBUG
|
||||
if (TVBPARSE_DEBUG & TVBPARSE_DEBUG_STRING) g_warning("cond_string: control='%s'",wanted->control.str);
|
||||
|
@ -374,7 +374,7 @@ static int cond_string(tvbparse_t* tt, const int offset, const tvbparse_wanted_t
|
|||
}
|
||||
}
|
||||
|
||||
tvbparse_wanted_t* tvbparse_string(const int id,
|
||||
tvbparse_wanted_t* tvbparse_string(int id,
|
||||
const gchar* str,
|
||||
const void* data,
|
||||
tvbparse_action_t before_cb,
|
||||
|
@ -392,7 +392,7 @@ tvbparse_wanted_t* tvbparse_string(const int id,
|
|||
return w;
|
||||
}
|
||||
|
||||
static int cond_casestring(tvbparse_t* tt, const int offset, const tvbparse_wanted_t * wanted, tvbparse_elem_t** tok) {
|
||||
static int cond_casestring(tvbparse_t* tt, int offset, const tvbparse_wanted_t * wanted, tvbparse_elem_t** tok) {
|
||||
int len = wanted->len;
|
||||
#ifdef TVBPARSE_DEBUG
|
||||
if (TVBPARSE_DEBUG & TVBPARSE_DEBUG_CASESTRING) g_warning("cond_casestring: control='%s'",wanted->control.str);
|
||||
|
@ -413,7 +413,7 @@ static int cond_casestring(tvbparse_t* tt, const int offset, const tvbparse_want
|
|||
}
|
||||
}
|
||||
|
||||
tvbparse_wanted_t* tvbparse_casestring(const int id,
|
||||
tvbparse_wanted_t* tvbparse_casestring(int id,
|
||||
const gchar* str,
|
||||
const void* data,
|
||||
tvbparse_action_t before_cb,
|
||||
|
@ -431,7 +431,7 @@ tvbparse_wanted_t* tvbparse_casestring(const int id,
|
|||
return w;
|
||||
}
|
||||
|
||||
static int cond_one_of(tvbparse_t* tt, const int offset, const tvbparse_wanted_t * wanted, tvbparse_elem_t** tok) {
|
||||
static int cond_one_of(tvbparse_t* tt, int offset, const tvbparse_wanted_t * wanted, tvbparse_elem_t** tok) {
|
||||
guint i;
|
||||
#ifdef TVBPARSE_DEBUG
|
||||
if (TVBPARSE_DEBUG & TVBPARSE_DEBUG_ONEOF) g_warning("cond_one_of: START");
|
||||
|
@ -463,7 +463,7 @@ static int cond_one_of(tvbparse_t* tt, const int offset, const tvbparse_wanted_t
|
|||
return -1;
|
||||
}
|
||||
|
||||
tvbparse_wanted_t* tvbparse_set_oneof(const int id,
|
||||
tvbparse_wanted_t* tvbparse_set_oneof(int id,
|
||||
const void* data,
|
||||
tvbparse_action_t before_cb,
|
||||
tvbparse_action_t after_cb,
|
||||
|
@ -490,7 +490,7 @@ tvbparse_wanted_t* tvbparse_set_oneof(const int id,
|
|||
return w;
|
||||
}
|
||||
|
||||
static int cond_hash(tvbparse_t* tt, const int offset, const tvbparse_wanted_t* wanted, tvbparse_elem_t** tok) {
|
||||
static int cond_hash(tvbparse_t* tt, int offset, const tvbparse_wanted_t* wanted, tvbparse_elem_t** tok) {
|
||||
int key_len;
|
||||
gchar* key = NULL;
|
||||
tvbparse_elem_t* key_elem = NULL;
|
||||
|
@ -541,7 +541,7 @@ static int cond_hash(tvbparse_t* tt, const int offset, const tvbparse_wanted_t*
|
|||
return tot_len;
|
||||
}
|
||||
|
||||
tvbparse_wanted_t* tvbparse_hashed(const int id,
|
||||
tvbparse_wanted_t* tvbparse_hashed(int id,
|
||||
const void* data,
|
||||
tvbparse_action_t before_cb,
|
||||
tvbparse_action_t after_cb,
|
||||
|
@ -639,7 +639,7 @@ static int cond_seq(tvbparse_t* tt, int offset, const tvbparse_wanted_t * wanted
|
|||
}
|
||||
|
||||
|
||||
tvbparse_wanted_t* tvbparse_set_seq(const int id,
|
||||
tvbparse_wanted_t* tvbparse_set_seq(int id,
|
||||
const void* data,
|
||||
tvbparse_action_t before_cb,
|
||||
tvbparse_action_t after_cb,
|
||||
|
@ -726,9 +726,9 @@ static int cond_some(tvbparse_t* tt, int offset, const tvbparse_wanted_t * wante
|
|||
return offset - start;
|
||||
}
|
||||
|
||||
tvbparse_wanted_t* tvbparse_some(const int id,
|
||||
const guint from,
|
||||
const guint to,
|
||||
tvbparse_wanted_t* tvbparse_some(int id,
|
||||
guint from,
|
||||
guint to,
|
||||
const void* data,
|
||||
tvbparse_action_t before_cb,
|
||||
tvbparse_action_t after_cb,
|
||||
|
@ -751,7 +751,7 @@ tvbparse_wanted_t* tvbparse_some(const int id,
|
|||
}
|
||||
|
||||
|
||||
static int cond_until(tvbparse_t* tt, const int offset, const tvbparse_wanted_t * wanted, tvbparse_elem_t** tok) {
|
||||
static int cond_until(tvbparse_t* tt, int offset, const tvbparse_wanted_t * wanted, tvbparse_elem_t** tok) {
|
||||
tvbparse_elem_t* new = NULL;
|
||||
int len = 0;
|
||||
int target_offset = offset;
|
||||
|
@ -805,7 +805,7 @@ static int cond_until(tvbparse_t* tt, const int offset, const tvbparse_wanted_t
|
|||
}
|
||||
}
|
||||
|
||||
tvbparse_wanted_t* tvbparse_until(const int id,
|
||||
tvbparse_wanted_t* tvbparse_until(int id,
|
||||
const void* data,
|
||||
tvbparse_action_t before_cb,
|
||||
tvbparse_action_t after_cb,
|
||||
|
@ -824,7 +824,7 @@ tvbparse_wanted_t* tvbparse_until(const int id,
|
|||
return w;
|
||||
}
|
||||
|
||||
static int cond_handle(tvbparse_t* tt, const int offset, const tvbparse_wanted_t * wanted, tvbparse_elem_t** tok) {
|
||||
static int cond_handle(tvbparse_t* tt, int offset, const tvbparse_wanted_t * wanted, tvbparse_elem_t** tok) {
|
||||
tvbparse_wanted_t* w = *(wanted->control.handle);
|
||||
int len = w->condition(tt, offset, w, tok);
|
||||
|
||||
|
@ -844,7 +844,7 @@ tvbparse_wanted_t* tvbparse_handle(tvbparse_wanted_t** handle) {
|
|||
return w;
|
||||
}
|
||||
|
||||
static int cond_end(tvbparse_t* tt, const int offset, const tvbparse_wanted_t * wanted _U_, tvbparse_elem_t** tok) {
|
||||
static int cond_end(tvbparse_t* tt, int offset, const tvbparse_wanted_t * wanted _U_, tvbparse_elem_t** tok) {
|
||||
if (offset == tt->end_offset) {
|
||||
*tok = new_tok(tt,wanted->id,offset,0,wanted);
|
||||
return 0;
|
||||
|
@ -853,7 +853,7 @@ static int cond_end(tvbparse_t* tt, const int offset, const tvbparse_wanted_t *
|
|||
}
|
||||
}
|
||||
|
||||
tvbparse_wanted_t* tvbparse_end_of_buffer(const int id,
|
||||
tvbparse_wanted_t* tvbparse_end_of_buffer(int id,
|
||||
const void* data,
|
||||
tvbparse_action_t before_cb,
|
||||
tvbparse_action_t after_cb) {
|
||||
|
@ -1156,12 +1156,12 @@ tvbparse_wanted_t* tvbparse_ft_numcmp(int id,
|
|||
#endif
|
||||
|
||||
|
||||
tvbparse_wanted_t* tvbparse_quoted(const int id,
|
||||
tvbparse_wanted_t* tvbparse_quoted(int id,
|
||||
const void* data,
|
||||
tvbparse_action_t before_cb,
|
||||
tvbparse_action_t after_cb,
|
||||
const char quote,
|
||||
const char esc) {
|
||||
char quote,
|
||||
char esc) {
|
||||
|
||||
gchar* esc_quot = g_strdup_printf("%c%c",esc,quote);
|
||||
gchar* quot = g_strdup_printf("%c",quote);
|
||||
|
@ -1193,7 +1193,7 @@ void tvbparse_shrink_token_cb(void* tvbparse_data _U_,
|
|||
}
|
||||
|
||||
tvbparse_t* tvbparse_init(tvbuff_t* tvb,
|
||||
const int offset,
|
||||
int offset,
|
||||
int len,
|
||||
void* data,
|
||||
const tvbparse_wanted_t* ignore) {
|
||||
|
@ -1214,7 +1214,7 @@ tvbparse_t* tvbparse_init(tvbuff_t* tvb,
|
|||
}
|
||||
|
||||
gboolean tvbparse_reset(tvbparse_t* tt,
|
||||
const int offset,
|
||||
int offset,
|
||||
int len) {
|
||||
|
||||
#ifdef TVBPARSE_DEBUG
|
||||
|
|
|
@ -89,7 +89,7 @@ typedef struct _tvbparse_t tvbparse_t;
|
|||
typedef void (*tvbparse_action_t)(void* tvbparse_data, const void* wanted_data, struct _tvbparse_elem_t* elem);
|
||||
|
||||
typedef int (*tvbparse_condition_t)
|
||||
(tvbparse_t*, const int,
|
||||
(tvbparse_t*, int,
|
||||
const tvbparse_wanted_t*,
|
||||
tvbparse_elem_t**);
|
||||
|
||||
|
@ -192,7 +192,7 @@ struct _tvbparse_elem_t {
|
|||
* When looked for it returns a simple element one character long if the char
|
||||
* at the current offset matches one of the the needles.
|
||||
*/
|
||||
tvbparse_wanted_t* tvbparse_char(const int id,
|
||||
tvbparse_wanted_t* tvbparse_char(int id,
|
||||
const gchar* needles,
|
||||
const void* private_data,
|
||||
tvbparse_action_t before_cb,
|
||||
|
@ -204,7 +204,7 @@ tvbparse_wanted_t* tvbparse_char(const int id,
|
|||
* When looked for it returns a simple element one character long if the char
|
||||
* at the current offset does not match one of the the needles.
|
||||
*/
|
||||
tvbparse_wanted_t* tvbparse_not_char(const int id,
|
||||
tvbparse_wanted_t* tvbparse_not_char(int id,
|
||||
const gchar* needle,
|
||||
const void* private_data,
|
||||
tvbparse_action_t before_cb,
|
||||
|
@ -218,9 +218,9 @@ tvbparse_wanted_t* tvbparse_not_char(const int id,
|
|||
* An element will be returned if at least min_len chars are given (1 if it's 0)
|
||||
* It will get at most max_len chars or as much as it can if max_len is 0.
|
||||
*/
|
||||
tvbparse_wanted_t* tvbparse_chars(const int id,
|
||||
const guint min_len,
|
||||
const guint max_len,
|
||||
tvbparse_wanted_t* tvbparse_chars(int id,
|
||||
guint min_len,
|
||||
guint max_len,
|
||||
const gchar* needles,
|
||||
const void* private_data,
|
||||
tvbparse_action_t before_cb,
|
||||
|
@ -235,9 +235,9 @@ tvbparse_wanted_t* tvbparse_chars(const int id,
|
|||
* An element will be returned if at least min_len chars are given (1 if it's 0)
|
||||
* It will get at most max_len chars or as much as it can if max_len is 0.
|
||||
*/
|
||||
tvbparse_wanted_t* tvbparse_not_chars(const int id,
|
||||
const guint min_len,
|
||||
const guint max_len,
|
||||
tvbparse_wanted_t* tvbparse_not_chars(int id,
|
||||
guint min_len,
|
||||
guint max_len,
|
||||
const gchar* needles,
|
||||
const void* private_data,
|
||||
tvbparse_action_t before_cb,
|
||||
|
@ -249,7 +249,7 @@ tvbparse_wanted_t* tvbparse_not_chars(const int id,
|
|||
* When looked for it returns a simple element if we have the given string at
|
||||
* the current offset
|
||||
*/
|
||||
tvbparse_wanted_t* tvbparse_string(const int id,
|
||||
tvbparse_wanted_t* tvbparse_string(int id,
|
||||
const gchar* string,
|
||||
const void* private_data,
|
||||
tvbparse_action_t before_cb,
|
||||
|
@ -261,7 +261,7 @@ tvbparse_wanted_t* tvbparse_string(const int id,
|
|||
* When looked for it returns a simple element if we have a matching string at
|
||||
* the current offset
|
||||
*/
|
||||
tvbparse_wanted_t* tvbparse_casestring(const int id,
|
||||
tvbparse_wanted_t* tvbparse_casestring(int id,
|
||||
const gchar* str,
|
||||
const void* data,
|
||||
tvbparse_action_t before_cb,
|
||||
|
@ -283,7 +283,7 @@ tvbparse_wanted_t* tvbparse_casestring(const int id,
|
|||
* op_mode values determine how the terminating element and the current offset
|
||||
* of the parser are handled
|
||||
*/
|
||||
tvbparse_wanted_t* tvbparse_until(const int id,
|
||||
tvbparse_wanted_t* tvbparse_until(int id,
|
||||
const void* private_data,
|
||||
tvbparse_action_t before_cb,
|
||||
tvbparse_action_t after_cb,
|
||||
|
@ -299,7 +299,7 @@ tvbparse_wanted_t* tvbparse_until(const int id,
|
|||
* The list of candidates is terminated with a NULL
|
||||
*
|
||||
*/
|
||||
tvbparse_wanted_t* tvbparse_set_oneof(const int id,
|
||||
tvbparse_wanted_t* tvbparse_set_oneof(int id,
|
||||
const void* private_data,
|
||||
tvbparse_action_t before_cb,
|
||||
tvbparse_action_t after_cb,
|
||||
|
@ -309,7 +309,7 @@ tvbparse_wanted_t* tvbparse_set_oneof(const int id,
|
|||
* hashed
|
||||
*/
|
||||
|
||||
tvbparse_wanted_t* tvbparse_hashed(const int id,
|
||||
tvbparse_wanted_t* tvbparse_hashed(int id,
|
||||
const void* data,
|
||||
tvbparse_action_t before_cb,
|
||||
tvbparse_action_t after_cb,
|
||||
|
@ -329,7 +329,7 @@ void tvbparse_hashed_add(tvbparse_wanted_t* w, ...);
|
|||
* The list of candidates is terminated with a NULL.
|
||||
*
|
||||
*/
|
||||
tvbparse_wanted_t* tvbparse_set_seq(const int id,
|
||||
tvbparse_wanted_t* tvbparse_set_seq(int id,
|
||||
const void* private_data,
|
||||
tvbparse_action_t before_cb,
|
||||
tvbparse_action_t after_cb,
|
||||
|
@ -342,9 +342,9 @@ tvbparse_wanted_t* tvbparse_set_seq(const int id,
|
|||
* a composed element is returned.
|
||||
*
|
||||
*/
|
||||
tvbparse_wanted_t* tvbparse_some(const int id,
|
||||
const guint min,
|
||||
const guint max,
|
||||
tvbparse_wanted_t* tvbparse_some(int id,
|
||||
guint min,
|
||||
guint max,
|
||||
const void* private_data,
|
||||
tvbparse_action_t before_cb,
|
||||
tvbparse_action_t after_cb,
|
||||
|
@ -403,12 +403,12 @@ tvbparse_wanted_t* tvbparse_ft_numcmp(int id,
|
|||
*
|
||||
* C strings are matched with tvbparse_quoted(-1,NULL,NULL,NULL,"\"","\\")
|
||||
*/
|
||||
tvbparse_wanted_t* tvbparse_quoted(const int id,
|
||||
tvbparse_wanted_t* tvbparse_quoted(int id,
|
||||
const void* data,
|
||||
tvbparse_action_t before_cb,
|
||||
tvbparse_action_t after_cb,
|
||||
const char quote,
|
||||
const char escape);
|
||||
char quote,
|
||||
char escape);
|
||||
|
||||
/*
|
||||
* a helper callback for quoted strings that will shrink the token to contain
|
||||
|
@ -429,7 +429,7 @@ void tvbparse_shrink_token_cb(void* tvbparse_data,
|
|||
* ignore: a wanted token type to be ignored (the associated cb WILL be called when it matches)
|
||||
*/
|
||||
tvbparse_t* tvbparse_init(tvbuff_t* tvb,
|
||||
const int offset,
|
||||
int offset,
|
||||
int len,
|
||||
void* private_data,
|
||||
const tvbparse_wanted_t* ignore);
|
||||
|
|
200
epan/tvbuff.c
200
epan/tvbuff.c
|
@ -52,11 +52,11 @@
|
|||
#include "proto.h" /* XXX - only used for DISSECTOR_ASSERT, probably a new header file? */
|
||||
|
||||
static const guint8*
|
||||
ensure_contiguous_no_exception(tvbuff_t *tvb, const gint offset, const gint length,
|
||||
ensure_contiguous_no_exception(tvbuff_t *tvb, gint offset, gint length,
|
||||
int *exception);
|
||||
|
||||
static const guint8*
|
||||
ensure_contiguous(tvbuff_t *tvb, const gint offset, const gint length);
|
||||
ensure_contiguous(tvbuff_t *tvb, gint offset, gint length);
|
||||
|
||||
#if GLIB_CHECK_VERSION(2,10,0)
|
||||
#else
|
||||
|
@ -87,7 +87,7 @@ tvbuff_cleanup(void)
|
|||
}
|
||||
|
||||
static void
|
||||
tvb_init(tvbuff_t *tvb, const tvbuff_type type)
|
||||
tvb_init(tvbuff_t *tvb, tvbuff_type type)
|
||||
{
|
||||
tvb_backing_t *backing;
|
||||
tvb_comp_t *composite;
|
||||
|
@ -130,7 +130,7 @@ tvb_init(tvbuff_t *tvb, const tvbuff_type type)
|
|||
|
||||
|
||||
tvbuff_t*
|
||||
tvb_new(const tvbuff_type type)
|
||||
tvb_new(tvbuff_type type)
|
||||
{
|
||||
tvbuff_t *tvb;
|
||||
|
||||
|
@ -146,7 +146,7 @@ tvb_new(const tvbuff_type type)
|
|||
}
|
||||
|
||||
static tvbuff_t*
|
||||
tvb_new_with_subset(const guint subset_tvb_offset, const guint subset_tvb_length)
|
||||
tvb_new_with_subset(guint subset_tvb_offset, guint subset_tvb_length)
|
||||
{
|
||||
tvbuff_t *tvb = tvb_new(TVBUFF_SUBSET);
|
||||
tvb->tvbuffs.subset.offset = subset_tvb_offset;
|
||||
|
@ -217,7 +217,7 @@ tvb_free(tvbuff_t* tvb)
|
|||
}
|
||||
|
||||
guint
|
||||
tvb_increment_usage_count(tvbuff_t* tvb, const guint count)
|
||||
tvb_increment_usage_count(tvbuff_t* tvb, guint count)
|
||||
{
|
||||
tvb->usage_count += count;
|
||||
|
||||
|
@ -225,7 +225,7 @@ tvb_increment_usage_count(tvbuff_t* tvb, const guint count)
|
|||
}
|
||||
|
||||
guint
|
||||
tvb_decrement_usage_count(tvbuff_t* tvb, const guint count)
|
||||
tvb_decrement_usage_count(tvbuff_t* tvb, guint count)
|
||||
{
|
||||
if (tvb->usage_count <= count) {
|
||||
tvb->usage_count = 1;
|
||||
|
@ -256,7 +256,7 @@ tvb_free_chain(tvbuff_t* tvb)
|
|||
|
||||
|
||||
void
|
||||
tvb_set_free_cb(tvbuff_t* tvb, const tvbuff_free_cb_t func)
|
||||
tvb_set_free_cb(tvbuff_t* tvb, tvbuff_free_cb_t func)
|
||||
{
|
||||
DISSECTOR_ASSERT(tvb);
|
||||
DISSECTOR_ASSERT(tvb->type == TVBUFF_REAL_DATA);
|
||||
|
@ -281,7 +281,7 @@ tvb_set_child_real_data_tvbuff(tvbuff_t* parent, tvbuff_t* child)
|
|||
}
|
||||
|
||||
static void
|
||||
tvb_set_real_data_no_exceptions(tvbuff_t* tvb, const guint8* data, const guint length, const gint reported_length)
|
||||
tvb_set_real_data_no_exceptions(tvbuff_t* tvb, const guint8* data, guint length, gint reported_length)
|
||||
{
|
||||
tvb->real_data = data;
|
||||
tvb->length = length;
|
||||
|
@ -290,7 +290,7 @@ tvb_set_real_data_no_exceptions(tvbuff_t* tvb, const guint8* data, const guint l
|
|||
}
|
||||
|
||||
void
|
||||
tvb_set_real_data(tvbuff_t* tvb, const guint8* data, const guint length, const gint reported_length)
|
||||
tvb_set_real_data(tvbuff_t* tvb, const guint8* data, guint length, gint reported_length)
|
||||
{
|
||||
DISSECTOR_ASSERT(tvb);
|
||||
DISSECTOR_ASSERT(tvb->type == TVBUFF_REAL_DATA);
|
||||
|
@ -302,7 +302,7 @@ tvb_set_real_data(tvbuff_t* tvb, const guint8* data, const guint length, const g
|
|||
}
|
||||
|
||||
tvbuff_t*
|
||||
tvb_new_real_data(const guint8* data, const guint length, const gint reported_length)
|
||||
tvb_new_real_data(const guint8* data, guint length, gint reported_length)
|
||||
{
|
||||
tvbuff_t *tvb;
|
||||
|
||||
|
@ -322,7 +322,7 @@ tvb_new_real_data(const guint8* data, const guint length, const gint reported_le
|
|||
}
|
||||
|
||||
tvbuff_t*
|
||||
tvb_new_child_real_data(tvbuff_t *parent, const guint8* data, const guint length, const gint reported_length)
|
||||
tvb_new_child_real_data(tvbuff_t *parent, const guint8* data, guint length, gint reported_length)
|
||||
{
|
||||
tvbuff_t *tvb = tvb_new_real_data(data, length, reported_length);
|
||||
if (tvb) {
|
||||
|
@ -346,7 +346,7 @@ tvb_new_child_real_data(tvbuff_t *parent, const guint8* data, const guint length
|
|||
* that gets an exception, so the error is reported as an error in that
|
||||
* protocol rather than the containing protocol. */
|
||||
static gboolean
|
||||
compute_offset_length(const guint tvb_length_val, const guint tvb_reported_length_val, const gint offset, const gint length_val,
|
||||
compute_offset_length(guint tvb_length_val, guint tvb_reported_length_val, gint offset, gint length_val,
|
||||
guint *offset_ptr, guint *length_ptr, int *exception)
|
||||
{
|
||||
DISSECTOR_ASSERT(offset_ptr);
|
||||
|
@ -410,7 +410,7 @@ compute_offset_length(const guint tvb_length_val, const guint tvb_reported_lengt
|
|||
|
||||
|
||||
static gboolean
|
||||
check_offset_length_no_exception(const guint tvb_length_val, const guint tvb_reported_length_val, const gint offset, gint const length_val,
|
||||
check_offset_length_no_exception(guint tvb_length_val, guint tvb_reported_length_val, gint offset, gint length_val,
|
||||
guint *offset_ptr, guint *length_ptr, int *exception)
|
||||
{
|
||||
guint end_offset;
|
||||
|
@ -460,7 +460,7 @@ check_offset_length_no_exception(const guint tvb_length_val, const guint tvb_rep
|
|||
* either is out of bounds. Sets integer ptrs to the new offset
|
||||
* and length. */
|
||||
static void
|
||||
check_offset_length(const guint tvb_length_val, const guint tvb_reported_length_val, const gint offset, gint const length_val,
|
||||
check_offset_length(guint tvb_length_val, guint tvb_reported_length_val, gint offset, gint length_val,
|
||||
guint *offset_ptr, guint *length_ptr)
|
||||
{
|
||||
int exception = 0;
|
||||
|
@ -472,7 +472,7 @@ check_offset_length(const guint tvb_length_val, const guint tvb_reported_length_
|
|||
}
|
||||
|
||||
static void
|
||||
tvb_set_subset_no_exceptions(tvbuff_t *tvb, tvbuff_t *backing, const gint reported_length)
|
||||
tvb_set_subset_no_exceptions(tvbuff_t *tvb, tvbuff_t *backing, gint reported_length)
|
||||
{
|
||||
tvb->tvbuffs.subset.tvb = backing;
|
||||
tvb->length = tvb->tvbuffs.subset.length;
|
||||
|
@ -495,7 +495,7 @@ tvb_set_subset_no_exceptions(tvbuff_t *tvb, tvbuff_t *backing, const gint report
|
|||
|
||||
void
|
||||
tvb_set_subset(tvbuff_t *tvb, tvbuff_t *backing,
|
||||
const gint backing_offset, const gint backing_length, const gint reported_length)
|
||||
gint backing_offset, gint backing_length, gint reported_length)
|
||||
{
|
||||
DISSECTOR_ASSERT(tvb);
|
||||
DISSECTOR_ASSERT(tvb->type == TVBUFF_SUBSET);
|
||||
|
@ -511,7 +511,7 @@ tvb_set_subset(tvbuff_t *tvb, tvbuff_t *backing,
|
|||
}
|
||||
|
||||
tvbuff_t*
|
||||
tvb_new_subset(tvbuff_t *backing, const gint backing_offset, const gint backing_length, const gint reported_length)
|
||||
tvb_new_subset(tvbuff_t *backing, gint backing_offset, gint backing_length, gint reported_length)
|
||||
{
|
||||
tvbuff_t *tvb;
|
||||
guint subset_tvb_offset;
|
||||
|
@ -539,7 +539,7 @@ tvb_new_subset(tvbuff_t *backing, const gint backing_offset, const gint backing_
|
|||
}
|
||||
|
||||
tvbuff_t*
|
||||
tvb_new_subset_remaining(tvbuff_t *backing, const gint backing_offset)
|
||||
tvb_new_subset_remaining(tvbuff_t *backing, gint backing_offset)
|
||||
{
|
||||
tvbuff_t *tvb;
|
||||
guint subset_tvb_offset;
|
||||
|
@ -626,7 +626,7 @@ tvb_composite_finalize(tvbuff_t* tvb)
|
|||
|
||||
|
||||
guint
|
||||
tvb_length(const tvbuff_t* tvb)
|
||||
tvb_length(tvbuff_t* tvb)
|
||||
{
|
||||
DISSECTOR_ASSERT(tvb && tvb->initialized);
|
||||
|
||||
|
@ -634,7 +634,7 @@ tvb_length(const tvbuff_t* tvb)
|
|||
}
|
||||
|
||||
gint
|
||||
tvb_length_remaining(const tvbuff_t *tvb, const gint offset)
|
||||
tvb_length_remaining(tvbuff_t *tvb, gint offset)
|
||||
{
|
||||
guint abs_offset, abs_length;
|
||||
|
||||
|
@ -649,7 +649,7 @@ tvb_length_remaining(const tvbuff_t *tvb, const gint offset)
|
|||
}
|
||||
|
||||
guint
|
||||
tvb_ensure_length_remaining(const tvbuff_t *tvb, const gint offset)
|
||||
tvb_ensure_length_remaining(tvbuff_t *tvb, gint offset)
|
||||
{
|
||||
guint abs_offset, abs_length;
|
||||
int exception;
|
||||
|
@ -679,7 +679,7 @@ tvb_ensure_length_remaining(const tvbuff_t *tvb, const gint offset)
|
|||
/* Validates that 'length' bytes are available starting from
|
||||
* offset (pos/neg). Does not throw an exception. */
|
||||
gboolean
|
||||
tvb_bytes_exist(const tvbuff_t *tvb, const gint offset, const gint length)
|
||||
tvb_bytes_exist(tvbuff_t *tvb, gint offset, gint length)
|
||||
{
|
||||
guint abs_offset, abs_length;
|
||||
|
||||
|
@ -699,7 +699,7 @@ tvb_bytes_exist(const tvbuff_t *tvb, const gint offset, const gint length)
|
|||
/* Validates that 'length' bytes are available starting from
|
||||
* offset (pos/neg). Throws an exception if they aren't. */
|
||||
void
|
||||
tvb_ensure_bytes_exist(const tvbuff_t *tvb, const gint offset, const gint length)
|
||||
tvb_ensure_bytes_exist(tvbuff_t *tvb, gint offset, gint length)
|
||||
{
|
||||
guint abs_offset, abs_length;
|
||||
|
||||
|
@ -722,7 +722,7 @@ tvb_ensure_bytes_exist(const tvbuff_t *tvb, const gint offset, const gint length
|
|||
}
|
||||
|
||||
gboolean
|
||||
tvb_offset_exists(const tvbuff_t *tvb, const gint offset)
|
||||
tvb_offset_exists(tvbuff_t *tvb, gint offset)
|
||||
{
|
||||
guint abs_offset, abs_length;
|
||||
|
||||
|
@ -739,7 +739,7 @@ tvb_offset_exists(const tvbuff_t *tvb, const gint offset)
|
|||
}
|
||||
|
||||
guint
|
||||
tvb_reported_length(const tvbuff_t* tvb)
|
||||
tvb_reported_length(tvbuff_t* tvb)
|
||||
{
|
||||
DISSECTOR_ASSERT(tvb && tvb->initialized);
|
||||
|
||||
|
@ -747,7 +747,7 @@ tvb_reported_length(const tvbuff_t* tvb)
|
|||
}
|
||||
|
||||
gint
|
||||
tvb_reported_length_remaining(const tvbuff_t *tvb, const gint offset)
|
||||
tvb_reported_length_remaining(tvbuff_t *tvb, gint offset)
|
||||
{
|
||||
guint abs_offset, abs_length;
|
||||
|
||||
|
@ -771,7 +771,7 @@ tvb_reported_length_remaining(const tvbuff_t *tvb, const gint offset)
|
|||
|
||||
Also adjusts the data length. */
|
||||
void
|
||||
tvb_set_reported_length(tvbuff_t* tvb, const guint reported_length)
|
||||
tvb_set_reported_length(tvbuff_t* tvb, guint reported_length)
|
||||
{
|
||||
DISSECTOR_ASSERT(tvb && tvb->initialized);
|
||||
|
||||
|
@ -807,7 +807,7 @@ first_real_data_ptr(tvbuff_t *tvb)
|
|||
#endif
|
||||
|
||||
static guint
|
||||
offset_from_real_beginning(const tvbuff_t *tvb, const guint counter)
|
||||
offset_from_real_beginning(tvbuff_t *tvb, guint counter)
|
||||
{
|
||||
tvbuff_t *member;
|
||||
|
||||
|
@ -827,14 +827,14 @@ offset_from_real_beginning(const tvbuff_t *tvb, const guint counter)
|
|||
}
|
||||
|
||||
guint
|
||||
tvb_offset_from_real_beginning(const tvbuff_t *tvb)
|
||||
tvb_offset_from_real_beginning(tvbuff_t *tvb)
|
||||
{
|
||||
return offset_from_real_beginning(tvb, 0);
|
||||
}
|
||||
|
||||
static const guint8*
|
||||
composite_ensure_contiguous_no_exception(tvbuff_t *tvb, const guint abs_offset,
|
||||
const guint abs_length)
|
||||
composite_ensure_contiguous_no_exception(tvbuff_t *tvb, guint abs_offset,
|
||||
guint abs_length)
|
||||
{
|
||||
guint i, num_members;
|
||||
tvb_comp_t *composite;
|
||||
|
@ -877,7 +877,7 @@ composite_ensure_contiguous_no_exception(tvbuff_t *tvb, const guint abs_offset,
|
|||
}
|
||||
|
||||
static const guint8*
|
||||
ensure_contiguous_no_exception(tvbuff_t *tvb, const gint offset, const gint length,
|
||||
ensure_contiguous_no_exception(tvbuff_t *tvb, gint offset, gint length,
|
||||
int *exception)
|
||||
{
|
||||
guint abs_offset, abs_length;
|
||||
|
@ -912,7 +912,7 @@ ensure_contiguous_no_exception(tvbuff_t *tvb, const gint offset, const gint leng
|
|||
}
|
||||
|
||||
static const guint8*
|
||||
ensure_contiguous(tvbuff_t *tvb, const gint offset, const gint length)
|
||||
ensure_contiguous(tvbuff_t *tvb, gint offset, gint length)
|
||||
{
|
||||
int exception;
|
||||
const guint8 *p;
|
||||
|
@ -926,7 +926,7 @@ ensure_contiguous(tvbuff_t *tvb, const gint offset, const gint length)
|
|||
}
|
||||
|
||||
static const guint8*
|
||||
fast_ensure_contiguous(tvbuff_t *tvb, const gint offset, const guint length)
|
||||
fast_ensure_contiguous(tvbuff_t *tvb, gint offset, guint length)
|
||||
{
|
||||
guint end_offset;
|
||||
guint u_offset;
|
||||
|
@ -955,7 +955,7 @@ fast_ensure_contiguous(tvbuff_t *tvb, const gint offset, const guint length)
|
|||
}
|
||||
|
||||
static const guint8*
|
||||
guint8_find(const guint8* haystack, const size_t haystacklen, const guint8 needle)
|
||||
guint8_find(const guint8* haystack, size_t haystacklen, guint8 needle)
|
||||
{
|
||||
const guint8 *b;
|
||||
int i;
|
||||
|
@ -1056,7 +1056,7 @@ composite_memcpy(tvbuff_t *tvb, guint8* target, guint abs_offset, size_t abs_len
|
|||
}
|
||||
|
||||
void*
|
||||
tvb_memcpy(tvbuff_t *tvb, void* target, const gint offset, size_t length)
|
||||
tvb_memcpy(tvbuff_t *tvb, void* target, gint offset, size_t length)
|
||||
{
|
||||
guint abs_offset, abs_length;
|
||||
|
||||
|
@ -1109,7 +1109,7 @@ tvb_memcpy(tvbuff_t *tvb, void* target, const gint offset, size_t length)
|
|||
* meaning "to the end of the buffer"?
|
||||
*/
|
||||
void*
|
||||
tvb_memdup(tvbuff_t *tvb, const gint offset, size_t length)
|
||||
tvb_memdup(tvbuff_t *tvb, gint offset, size_t length)
|
||||
{
|
||||
guint abs_offset, abs_length;
|
||||
void *duped;
|
||||
|
@ -1139,7 +1139,7 @@ tvb_memdup(tvbuff_t *tvb, const gint offset, size_t length)
|
|||
* after the current packet has been dissected.
|
||||
*/
|
||||
void*
|
||||
ep_tvb_memdup(tvbuff_t *tvb, const gint offset, size_t length)
|
||||
ep_tvb_memdup(tvbuff_t *tvb, gint offset, size_t length)
|
||||
{
|
||||
guint abs_offset, abs_length;
|
||||
void *duped;
|
||||
|
@ -1155,14 +1155,14 @@ ep_tvb_memdup(tvbuff_t *tvb, const gint offset, size_t length)
|
|||
|
||||
|
||||
const guint8*
|
||||
tvb_get_ptr(tvbuff_t *tvb, const gint offset, const gint length)
|
||||
tvb_get_ptr(tvbuff_t *tvb, gint offset, gint length)
|
||||
{
|
||||
return ensure_contiguous(tvb, offset, length);
|
||||
}
|
||||
|
||||
/* ---------------- */
|
||||
guint8
|
||||
tvb_get_guint8(tvbuff_t *tvb, const gint offset)
|
||||
tvb_get_guint8(tvbuff_t *tvb, gint offset)
|
||||
{
|
||||
const guint8* ptr;
|
||||
|
||||
|
@ -1171,7 +1171,7 @@ tvb_get_guint8(tvbuff_t *tvb, const gint offset)
|
|||
}
|
||||
|
||||
guint16
|
||||
tvb_get_ntohs(tvbuff_t *tvb, const gint offset)
|
||||
tvb_get_ntohs(tvbuff_t *tvb, gint offset)
|
||||
{
|
||||
const guint8* ptr;
|
||||
|
||||
|
@ -1180,7 +1180,7 @@ tvb_get_ntohs(tvbuff_t *tvb, const gint offset)
|
|||
}
|
||||
|
||||
guint32
|
||||
tvb_get_ntoh24(tvbuff_t *tvb, const gint offset)
|
||||
tvb_get_ntoh24(tvbuff_t *tvb, gint offset)
|
||||
{
|
||||
const guint8* ptr;
|
||||
|
||||
|
@ -1189,7 +1189,7 @@ tvb_get_ntoh24(tvbuff_t *tvb, const gint offset)
|
|||
}
|
||||
|
||||
guint32
|
||||
tvb_get_ntohl(tvbuff_t *tvb, const gint offset)
|
||||
tvb_get_ntohl(tvbuff_t *tvb, gint offset)
|
||||
{
|
||||
const guint8* ptr;
|
||||
|
||||
|
@ -1198,7 +1198,7 @@ tvb_get_ntohl(tvbuff_t *tvb, const gint offset)
|
|||
}
|
||||
|
||||
guint64
|
||||
tvb_get_ntoh64(tvbuff_t *tvb, const gint offset)
|
||||
tvb_get_ntoh64(tvbuff_t *tvb, gint offset)
|
||||
{
|
||||
const guint8* ptr;
|
||||
|
||||
|
@ -1248,13 +1248,13 @@ tvb_get_ntoh64(tvbuff_t *tvb, const gint offset)
|
|||
#define IEEE_SP_BIAS ((1 << (IEEE_SP_EXP_WIDTH - 1)) - 1)
|
||||
|
||||
static int
|
||||
ieee_float_is_zero(const guint32 w)
|
||||
ieee_float_is_zero(guint32 w)
|
||||
{
|
||||
return ((w & ~IEEE_SP_SIGN_MASK) == 0);
|
||||
}
|
||||
|
||||
static gfloat
|
||||
get_ieee_float(const guint32 w)
|
||||
get_ieee_float(guint32 w)
|
||||
{
|
||||
long sign;
|
||||
long exponent;
|
||||
|
@ -1309,13 +1309,13 @@ get_ieee_float(const guint32 w)
|
|||
#define IEEE_DP_BIAS ((1 << (IEEE_DP_EXP_WIDTH - 1)) - 1)
|
||||
|
||||
static int
|
||||
ieee_double_is_zero(const guint64 w)
|
||||
ieee_double_is_zero(guint64 w)
|
||||
{
|
||||
return ((w & ~IEEE_SP_SIGN_MASK) == 0);
|
||||
}
|
||||
|
||||
static gdouble
|
||||
get_ieee_double(const guint64 w)
|
||||
get_ieee_double(guint64 w)
|
||||
{
|
||||
gint64 sign;
|
||||
gint64 exponent;
|
||||
|
@ -1361,7 +1361,7 @@ get_ieee_double(const guint64 w)
|
|||
* "float" format?
|
||||
*/
|
||||
gfloat
|
||||
tvb_get_ntohieee_float(tvbuff_t *tvb, const int offset)
|
||||
tvb_get_ntohieee_float(tvbuff_t *tvb, int offset)
|
||||
{
|
||||
#if defined(vax)
|
||||
return get_ieee_float(tvb_get_ntohl(tvb, offset));
|
||||
|
@ -1381,7 +1381,7 @@ tvb_get_ntohieee_float(tvbuff_t *tvb, const int offset)
|
|||
* big-endian form, and returns a "double".
|
||||
*/
|
||||
gdouble
|
||||
tvb_get_ntohieee_double(tvbuff_t *tvb, const int offset)
|
||||
tvb_get_ntohieee_double(tvbuff_t *tvb, int offset)
|
||||
{
|
||||
#if defined(vax)
|
||||
union {
|
||||
|
@ -1410,7 +1410,7 @@ tvb_get_ntohieee_double(tvbuff_t *tvb, const int offset)
|
|||
}
|
||||
|
||||
guint16
|
||||
tvb_get_letohs(tvbuff_t *tvb, const gint offset)
|
||||
tvb_get_letohs(tvbuff_t *tvb, gint offset)
|
||||
{
|
||||
const guint8* ptr;
|
||||
|
||||
|
@ -1419,7 +1419,7 @@ tvb_get_letohs(tvbuff_t *tvb, const gint offset)
|
|||
}
|
||||
|
||||
guint32
|
||||
tvb_get_letoh24(tvbuff_t *tvb, const gint offset)
|
||||
tvb_get_letoh24(tvbuff_t *tvb, gint offset)
|
||||
{
|
||||
const guint8* ptr;
|
||||
|
||||
|
@ -1428,7 +1428,7 @@ tvb_get_letoh24(tvbuff_t *tvb, const gint offset)
|
|||
}
|
||||
|
||||
guint32
|
||||
tvb_get_letohl(tvbuff_t *tvb, const gint offset)
|
||||
tvb_get_letohl(tvbuff_t *tvb, gint offset)
|
||||
{
|
||||
const guint8* ptr;
|
||||
|
||||
|
@ -1437,7 +1437,7 @@ tvb_get_letohl(tvbuff_t *tvb, const gint offset)
|
|||
}
|
||||
|
||||
guint64
|
||||
tvb_get_letoh64(tvbuff_t *tvb, const gint offset)
|
||||
tvb_get_letoh64(tvbuff_t *tvb, gint offset)
|
||||
{
|
||||
const guint8* ptr;
|
||||
|
||||
|
@ -1454,7 +1454,7 @@ tvb_get_letoh64(tvbuff_t *tvb, const gint offset)
|
|||
* "float" format?
|
||||
*/
|
||||
gfloat
|
||||
tvb_get_letohieee_float(tvbuff_t *tvb, const int offset)
|
||||
tvb_get_letohieee_float(tvbuff_t *tvb, int offset)
|
||||
{
|
||||
#if defined(vax)
|
||||
return get_ieee_float(tvb_get_letohl(tvb, offset));
|
||||
|
@ -1474,7 +1474,7 @@ tvb_get_letohieee_float(tvbuff_t *tvb, const int offset)
|
|||
* little-endian form, and returns a "double".
|
||||
*/
|
||||
gdouble
|
||||
tvb_get_letohieee_double(tvbuff_t *tvb, const int offset)
|
||||
tvb_get_letohieee_double(tvbuff_t *tvb, int offset)
|
||||
{
|
||||
#if defined(vax)
|
||||
union {
|
||||
|
@ -1506,7 +1506,7 @@ tvb_get_letohieee_double(tvbuff_t *tvb, const int offset)
|
|||
* We do *not* convert them to host byte order; we leave them in
|
||||
* network byte order. */
|
||||
guint32
|
||||
tvb_get_ipv4(tvbuff_t *tvb, const gint offset)
|
||||
tvb_get_ipv4(tvbuff_t *tvb, gint offset)
|
||||
{
|
||||
const guint8* ptr;
|
||||
guint32 addr;
|
||||
|
@ -1518,7 +1518,7 @@ tvb_get_ipv4(tvbuff_t *tvb, const gint offset)
|
|||
|
||||
/* Fetch an IPv6 address. */
|
||||
void
|
||||
tvb_get_ipv6(tvbuff_t *tvb, const gint offset, struct e_in6_addr *addr)
|
||||
tvb_get_ipv6(tvbuff_t *tvb, gint offset, struct e_in6_addr *addr)
|
||||
{
|
||||
const guint8* ptr;
|
||||
|
||||
|
@ -1528,7 +1528,7 @@ tvb_get_ipv6(tvbuff_t *tvb, const gint offset, struct e_in6_addr *addr)
|
|||
|
||||
/* Fetch a GUID. */
|
||||
void
|
||||
tvb_get_ntohguid(tvbuff_t *tvb, const gint offset, e_guid_t *guid)
|
||||
tvb_get_ntohguid(tvbuff_t *tvb, gint offset, e_guid_t *guid)
|
||||
{
|
||||
ensure_contiguous(tvb, offset, sizeof(*guid));
|
||||
guid->data1 = tvb_get_ntohl(tvb, offset);
|
||||
|
@ -1538,7 +1538,7 @@ tvb_get_ntohguid(tvbuff_t *tvb, const gint offset, e_guid_t *guid)
|
|||
}
|
||||
|
||||
void
|
||||
tvb_get_letohguid(tvbuff_t *tvb, const gint offset, e_guid_t *guid)
|
||||
tvb_get_letohguid(tvbuff_t *tvb, gint offset, e_guid_t *guid)
|
||||
{
|
||||
ensure_contiguous(tvb, offset, sizeof(*guid));
|
||||
guid->data1 = tvb_get_letohl(tvb, offset);
|
||||
|
@ -1548,7 +1548,7 @@ tvb_get_letohguid(tvbuff_t *tvb, const gint offset, e_guid_t *guid)
|
|||
}
|
||||
|
||||
void
|
||||
tvb_get_guid(tvbuff_t *tvb, const gint offset, e_guid_t *guid, const gboolean little_endian)
|
||||
tvb_get_guid(tvbuff_t *tvb, gint offset, e_guid_t *guid, gboolean little_endian)
|
||||
{
|
||||
if (little_endian) {
|
||||
tvb_get_letohguid(tvb, offset, guid);
|
||||
|
@ -1582,7 +1582,7 @@ static const guint16 bit_mask16[] = {
|
|||
|
||||
/* Get 1 - 8 bits */
|
||||
guint8
|
||||
tvb_get_bits8(tvbuff_t *tvb, gint bit_offset, const gint no_of_bits)
|
||||
tvb_get_bits8(tvbuff_t *tvb, gint bit_offset, gint no_of_bits)
|
||||
{
|
||||
gint offset;
|
||||
guint16 value = 0;
|
||||
|
@ -1627,7 +1627,7 @@ static const guint32 bit_mask32[] = {
|
|||
};
|
||||
|
||||
guint16
|
||||
tvb_get_bits16(tvbuff_t *tvb, gint bit_offset, const gint no_of_bits,const gboolean little_endian)
|
||||
tvb_get_bits16(tvbuff_t *tvb, gint bit_offset, gint no_of_bits,gboolean little_endian)
|
||||
{
|
||||
gint offset;
|
||||
guint16 value = 0;
|
||||
|
@ -1681,7 +1681,7 @@ static const guint64 bit_mask64[] = {
|
|||
};
|
||||
|
||||
guint32
|
||||
tvb_get_bits32(tvbuff_t *tvb, gint bit_offset, const gint no_of_bits, const gboolean little_endian)
|
||||
tvb_get_bits32(tvbuff_t *tvb, gint bit_offset, gint no_of_bits, gboolean little_endian)
|
||||
{
|
||||
gint offset;
|
||||
guint32 value = 0;
|
||||
|
@ -1723,7 +1723,7 @@ tvb_get_bits32(tvbuff_t *tvb, gint bit_offset, const gint no_of_bits, const gboo
|
|||
}
|
||||
|
||||
guint64
|
||||
tvb_get_bits64(tvbuff_t *tvb, gint bit_offset, const gint no_of_bits, const gboolean little_endian)
|
||||
tvb_get_bits64(tvbuff_t *tvb, gint bit_offset, gint no_of_bits, gboolean little_endian)
|
||||
{
|
||||
gint offset;
|
||||
guint64 value = 0;
|
||||
|
@ -1765,7 +1765,7 @@ tvb_get_bits64(tvbuff_t *tvb, gint bit_offset, const gint no_of_bits, const gboo
|
|||
}
|
||||
|
||||
guint32
|
||||
tvb_get_bits(tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits, const gboolean little_endian)
|
||||
tvb_get_bits(tvbuff_t *tvb, gint bit_offset, gint no_of_bits, gboolean little_endian)
|
||||
{
|
||||
/* This function can handle only up to 32 requested bits */
|
||||
if (no_of_bits > 32)
|
||||
|
@ -1794,7 +1794,7 @@ tvb_get_bits(tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits, const
|
|||
* in that case, -1 will be returned if the boundary is reached before
|
||||
* finding needle. */
|
||||
gint
|
||||
tvb_find_guint8(tvbuff_t *tvb, const gint offset, const gint maxlength, const guint8 needle)
|
||||
tvb_find_guint8(tvbuff_t *tvb, gint offset, gint maxlength, guint8 needle)
|
||||
{
|
||||
const guint8 *result;
|
||||
guint abs_offset, junk_length;
|
||||
|
@ -1859,7 +1859,7 @@ tvb_find_guint8(tvbuff_t *tvb, const gint offset, const gint maxlength, const gu
|
|||
* in that case, -1 will be returned if the boundary is reached before
|
||||
* finding needle. */
|
||||
gint
|
||||
tvb_pbrk_guint8(tvbuff_t *tvb, const gint offset, const gint maxlength, const const guint8 *needles, guchar *found_needle)
|
||||
tvb_pbrk_guint8(tvbuff_t *tvb, gint offset, gint maxlength, const guint8 *needles, guchar *found_needle)
|
||||
{
|
||||
const guint8 *result;
|
||||
guint abs_offset, junk_length;
|
||||
|
@ -1922,7 +1922,7 @@ tvb_pbrk_guint8(tvbuff_t *tvb, const gint offset, const gint maxlength, const co
|
|||
* If the NUL isn't found, it throws the appropriate exception.
|
||||
*/
|
||||
guint
|
||||
tvb_strsize(tvbuff_t *tvb, const gint offset)
|
||||
tvb_strsize(tvbuff_t *tvb, gint offset)
|
||||
{
|
||||
guint abs_offset, junk_length;
|
||||
gint nul_offset;
|
||||
|
@ -1956,7 +1956,7 @@ tvb_strsize(tvbuff_t *tvb, const gint offset)
|
|||
* of tvbuff.
|
||||
* Returns -1 if 'maxlength' reached before finding EOS. */
|
||||
gint
|
||||
tvb_strnlen(tvbuff_t *tvb, const gint offset, const guint maxlength)
|
||||
tvb_strnlen(tvbuff_t *tvb, gint offset, guint maxlength)
|
||||
{
|
||||
gint result_offset;
|
||||
guint abs_offset, junk_length;
|
||||
|
@ -1984,7 +1984,7 @@ tvb_strnlen(tvbuff_t *tvb, const gint offset, const guint maxlength)
|
|||
* it returns 0 (meaning "equal") and -1 otherwise, otherwise return -1.
|
||||
*/
|
||||
gint
|
||||
tvb_strneql(tvbuff_t *tvb, const gint offset, const gchar *str, const gint size)
|
||||
tvb_strneql(tvbuff_t *tvb, gint offset, const gchar *str, gint size)
|
||||
{
|
||||
const guint8 *ptr;
|
||||
|
||||
|
@ -2011,7 +2011,7 @@ tvb_strneql(tvbuff_t *tvb, const gint offset, const gchar *str, const gint size)
|
|||
* 0 if it returns 0 (meaning "equal") and -1 otherwise, otherwise return -1.
|
||||
*/
|
||||
gint
|
||||
tvb_strncaseeql(tvbuff_t *tvb, const gint offset, const gchar *str, const gint size)
|
||||
tvb_strncaseeql(tvbuff_t *tvb, gint offset, const gchar *str, gint size)
|
||||
{
|
||||
const guint8 *ptr;
|
||||
|
||||
|
@ -2038,7 +2038,7 @@ tvb_strncaseeql(tvbuff_t *tvb, const gint offset, const gchar *str, const gint s
|
|||
* it returns 0 (meaning "equal") and -1 otherwise, otherwise return -1.
|
||||
*/
|
||||
gint
|
||||
tvb_memeql(tvbuff_t *tvb, const gint offset, const guint8 *str, size_t size)
|
||||
tvb_memeql(tvbuff_t *tvb, gint offset, const guint8 *str, size_t size)
|
||||
{
|
||||
const guint8 *ptr;
|
||||
|
||||
|
@ -2065,7 +2065,7 @@ tvb_memeql(tvbuff_t *tvb, const gint offset, const guint8 *str, size_t size)
|
|||
* free the result returned. The len parameter is the number of guint16's
|
||||
* to convert from Unicode. */
|
||||
char *
|
||||
tvb_fake_unicode(tvbuff_t *tvb, int offset, const int len, const gboolean little_endian)
|
||||
tvb_fake_unicode(tvbuff_t *tvb, int offset, int len, gboolean little_endian)
|
||||
{
|
||||
char *buffer;
|
||||
int i;
|
||||
|
@ -2100,7 +2100,7 @@ tvb_fake_unicode(tvbuff_t *tvb, int offset, const int len, const gboolean little
|
|||
* when wireshark starts decoding the next packet.
|
||||
*/
|
||||
char *
|
||||
tvb_get_ephemeral_faked_unicode(tvbuff_t *tvb, int offset, const int len, const gboolean little_endian)
|
||||
tvb_get_ephemeral_faked_unicode(tvbuff_t *tvb, int offset, int len, gboolean little_endian)
|
||||
{
|
||||
char *buffer;
|
||||
int i;
|
||||
|
@ -2131,7 +2131,7 @@ tvb_get_ephemeral_faked_unicode(tvbuff_t *tvb, int offset, const int len, const
|
|||
*/
|
||||
|
||||
gchar *
|
||||
tvb_format_text(tvbuff_t *tvb, const gint offset, const gint size)
|
||||
tvb_format_text(tvbuff_t *tvb, gint offset, gint size)
|
||||
{
|
||||
const guint8 *ptr;
|
||||
gint len = size;
|
||||
|
@ -2149,7 +2149,7 @@ tvb_format_text(tvbuff_t *tvb, const gint offset, const gint size)
|
|||
*/
|
||||
|
||||
gchar *
|
||||
tvb_format_text_wsp(tvbuff_t *tvb, const gint offset, const gint size)
|
||||
tvb_format_text_wsp(tvbuff_t *tvb, gint offset, gint size)
|
||||
{
|
||||
const guint8 *ptr;
|
||||
gint len = size;
|
||||
|
@ -2170,7 +2170,7 @@ tvb_format_text_wsp(tvbuff_t *tvb, const gint offset, const gint size)
|
|||
* the null padding characters as "\000".
|
||||
*/
|
||||
gchar *
|
||||
tvb_format_stringzpad(tvbuff_t *tvb, const gint offset, const gint size)
|
||||
tvb_format_stringzpad(tvbuff_t *tvb, gint offset, gint size)
|
||||
{
|
||||
const guint8 *ptr, *p;
|
||||
gint len = size;
|
||||
|
@ -2194,7 +2194,7 @@ tvb_format_stringzpad(tvbuff_t *tvb, const gint offset, const gint size)
|
|||
* the null padding characters as "\000".
|
||||
*/
|
||||
gchar *
|
||||
tvb_format_stringzpad_wsp(tvbuff_t *tvb, const gint offset, const gint size)
|
||||
tvb_format_stringzpad_wsp(tvbuff_t *tvb, gint offset, gint size)
|
||||
{
|
||||
const guint8 *ptr, *p;
|
||||
gint len = size;
|
||||
|
@ -2222,7 +2222,7 @@ tvb_format_stringzpad_wsp(tvbuff_t *tvb, const gint offset, const gint size)
|
|||
* Throws an exception if the tvbuff ends before the string does.
|
||||
*/
|
||||
guint8 *
|
||||
tvb_get_string(tvbuff_t *tvb, const gint offset, const gint length)
|
||||
tvb_get_string(tvbuff_t *tvb, gint offset, gint length)
|
||||
{
|
||||
const guint8 *ptr;
|
||||
guint8 *strbuf = NULL;
|
||||
|
@ -2252,7 +2252,7 @@ tvb_get_string(tvbuff_t *tvb, const gint offset, const gint length)
|
|||
* after the current packet has been dissected.
|
||||
*/
|
||||
guint8 *
|
||||
tvb_get_ephemeral_string(tvbuff_t *tvb, const gint offset, const gint length)
|
||||
tvb_get_ephemeral_string(tvbuff_t *tvb, gint offset, gint length)
|
||||
{
|
||||
const guint8 *ptr;
|
||||
guint8 *strbuf = NULL;
|
||||
|
@ -2281,7 +2281,7 @@ tvb_get_ephemeral_string(tvbuff_t *tvb, const gint offset, const gint length)
|
|||
* when wireshark starts or opens a new capture.
|
||||
*/
|
||||
guint8 *
|
||||
tvb_get_seasonal_string(tvbuff_t *tvb, const gint offset, const gint length)
|
||||
tvb_get_seasonal_string(tvbuff_t *tvb, gint offset, gint length)
|
||||
{
|
||||
const guint8 *ptr;
|
||||
guint8 *strbuf = NULL;
|
||||
|
@ -2306,7 +2306,7 @@ tvb_get_seasonal_string(tvbuff_t *tvb, const gint offset, const gint length)
|
|||
* string (including the terminating null) through a pointer.
|
||||
*/
|
||||
guint8 *
|
||||
tvb_get_stringz(tvbuff_t *tvb, const gint offset, gint *lengthp)
|
||||
tvb_get_stringz(tvbuff_t *tvb, gint offset, gint *lengthp)
|
||||
{
|
||||
guint size;
|
||||
guint8 *strptr;
|
||||
|
@ -2333,7 +2333,7 @@ tvb_get_stringz(tvbuff_t *tvb, const gint offset, gint *lengthp)
|
|||
* after the current packet has been dissected.
|
||||
*/
|
||||
guint8 *
|
||||
tvb_get_ephemeral_stringz(tvbuff_t *tvb, const gint offset, gint *lengthp)
|
||||
tvb_get_ephemeral_stringz(tvbuff_t *tvb, gint offset, gint *lengthp)
|
||||
{
|
||||
guint size;
|
||||
guint8 *strptr;
|
||||
|
@ -2359,7 +2359,7 @@ tvb_get_ephemeral_stringz(tvbuff_t *tvb, const gint offset, gint *lengthp)
|
|||
* when wireshark starts or opens a new capture.
|
||||
*/
|
||||
guint8 *
|
||||
tvb_get_seasonal_stringz(tvbuff_t *tvb, const gint offset, gint *lengthp)
|
||||
tvb_get_seasonal_stringz(tvbuff_t *tvb, gint offset, gint *lengthp)
|
||||
{
|
||||
guint size;
|
||||
guint8 *strptr;
|
||||
|
@ -2391,7 +2391,7 @@ tvb_get_seasonal_stringz(tvbuff_t *tvb, const gint offset, gint *lengthp)
|
|||
* including the terminating-NUL.
|
||||
*/
|
||||
static gint
|
||||
_tvb_get_nstringz(tvbuff_t *tvb, const gint offset, const guint bufsize, guint8* buffer,
|
||||
_tvb_get_nstringz(tvbuff_t *tvb, gint offset, guint bufsize, guint8* buffer,
|
||||
gint *bytes_copied)
|
||||
{
|
||||
gint stringlen;
|
||||
|
@ -2475,7 +2475,7 @@ _tvb_get_nstringz(tvbuff_t *tvb, const gint offset, const guint bufsize, guint8*
|
|||
* at the correct spot, terminating the string.
|
||||
*/
|
||||
gint
|
||||
tvb_get_nstringz(tvbuff_t *tvb, const gint offset, const guint bufsize, guint8* buffer)
|
||||
tvb_get_nstringz(tvbuff_t *tvb, gint offset, guint bufsize, guint8* buffer)
|
||||
{
|
||||
gint bytes_copied;
|
||||
|
||||
|
@ -2489,7 +2489,7 @@ tvb_get_nstringz(tvbuff_t *tvb, const gint offset, const guint bufsize, guint8*
|
|||
* a NUL is placed at the end of buffer to terminate it.
|
||||
*/
|
||||
gint
|
||||
tvb_get_nstringz0(tvbuff_t *tvb, const gint offset, const guint bufsize, guint8* buffer)
|
||||
tvb_get_nstringz0(tvbuff_t *tvb, gint offset, guint bufsize, guint8* buffer)
|
||||
{
|
||||
gint len, bytes_copied;
|
||||
|
||||
|
@ -2526,8 +2526,8 @@ tvb_get_nstringz0(tvbuff_t *tvb, const gint offset, const guint bufsize, guint8*
|
|||
* terminator. (It's not set if we return -1.)
|
||||
*/
|
||||
gint
|
||||
tvb_find_line_end(tvbuff_t *tvb, const gint offset, int len, gint *next_offset,
|
||||
const gboolean desegment)
|
||||
tvb_find_line_end(tvbuff_t *tvb, gint offset, int len, gint *next_offset,
|
||||
gboolean desegment)
|
||||
{
|
||||
gint eob_offset;
|
||||
gint eol_offset;
|
||||
|
@ -2642,7 +2642,7 @@ tvb_find_line_end(tvbuff_t *tvb, const gint offset, int len, gint *next_offset,
|
|||
* terminator.
|
||||
*/
|
||||
gint
|
||||
tvb_find_line_end_unquoted(tvbuff_t *tvb, const gint offset, int len,
|
||||
tvb_find_line_end_unquoted(tvbuff_t *tvb, gint offset, int len,
|
||||
gint *next_offset)
|
||||
{
|
||||
gint cur_offset, char_offset;
|
||||
|
@ -2783,7 +2783,7 @@ tvb_find_line_end_unquoted(tvbuff_t *tvb, const gint offset, int len,
|
|||
* character following offset or offset + maxlength -1 whichever
|
||||
* is smaller.
|
||||
*/
|
||||
gint tvb_skip_wsp(tvbuff_t* tvb, const gint offset, const gint maxlength)
|
||||
gint tvb_skip_wsp(tvbuff_t* tvb, gint offset, gint maxlength)
|
||||
{
|
||||
gint counter = offset;
|
||||
gint end = offset + maxlength,tvb_len;
|
||||
|
@ -2807,7 +2807,7 @@ gint tvb_skip_wsp(tvbuff_t* tvb, const gint offset, const gint maxlength)
|
|||
return (counter);
|
||||
}
|
||||
|
||||
gint tvb_skip_wsp_return(tvbuff_t* tvb, const gint offset){
|
||||
gint tvb_skip_wsp_return(tvbuff_t* tvb, gint offset){
|
||||
gint counter = offset;
|
||||
gint end;
|
||||
guint8 tempchar;
|
||||
|
@ -2827,7 +2827,7 @@ gint tvb_skip_wsp_return(tvbuff_t* tvb, const gint offset){
|
|||
* separator.
|
||||
*/
|
||||
gchar *
|
||||
tvb_bytes_to_str_punct(tvbuff_t *tvb, const gint offset, const gint len, const gchar punct)
|
||||
tvb_bytes_to_str_punct(tvbuff_t *tvb, gint offset, gint len, gchar punct)
|
||||
{
|
||||
return bytes_to_str_punct(tvb_get_ptr(tvb, offset, len), len, punct);
|
||||
}
|
||||
|
@ -2837,14 +2837,14 @@ tvb_bytes_to_str_punct(tvbuff_t *tvb, const gint offset, const gint len, const g
|
|||
* to the string with the formatted data.
|
||||
*/
|
||||
gchar *
|
||||
tvb_bytes_to_str(tvbuff_t *tvb, const gint offset, const gint len)
|
||||
tvb_bytes_to_str(tvbuff_t *tvb, gint offset, gint len)
|
||||
{
|
||||
return bytes_to_str(tvb_get_ptr(tvb, offset, len), len);
|
||||
}
|
||||
|
||||
/* Find a needle tvbuff within a haystack tvbuff. */
|
||||
gint
|
||||
tvb_find_tvb(tvbuff_t *haystack_tvb, tvbuff_t *needle_tvb, const gint haystack_offset)
|
||||
tvb_find_tvb(tvbuff_t *haystack_tvb, tvbuff_t *needle_tvb, gint haystack_offset)
|
||||
{
|
||||
guint haystack_abs_offset, haystack_abs_length;
|
||||
const guint8 *haystack_data;
|
||||
|
@ -2887,7 +2887,7 @@ tvb_find_tvb(tvbuff_t *haystack_tvb, tvbuff_t *needle_tvb, const gint haystack_o
|
|||
#undef TVB_Z_DEBUG
|
||||
|
||||
tvbuff_t *
|
||||
tvb_uncompress(tvbuff_t *tvb, const int offset, int comprlen)
|
||||
tvb_uncompress(tvbuff_t *tvb, int offset, int comprlen)
|
||||
{
|
||||
gint err = Z_OK;
|
||||
guint bytes_out = 0;
|
||||
|
@ -3139,13 +3139,13 @@ tvb_uncompress(tvbuff_t *tvb, const int offset, int comprlen)
|
|||
}
|
||||
#else
|
||||
tvbuff_t *
|
||||
tvb_uncompress(tvbuff_t *tvb _U_, const int offset _U_, int comprlen _U_)
|
||||
tvb_uncompress(tvbuff_t *tvb _U_, int offset _U_, int comprlen _U_)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
tvbuff_t* tvb_child_uncompress(tvbuff_t *parent, tvbuff_t *tvb, const int offset, int comprlen)
|
||||
tvbuff_t* tvb_child_uncompress(tvbuff_t *parent, tvbuff_t *tvb, int offset, int comprlen)
|
||||
{
|
||||
tvbuff_t *new_tvb = tvb_uncompress(tvb, offset, comprlen);
|
||||
if (new_tvb)
|
||||
|
|
140
epan/tvbuff.h
140
epan/tvbuff.h
|
@ -266,35 +266,35 @@ extern void tvb_composite_finalize(tvbuff_t* tvb);
|
|||
|
||||
|
||||
/* Get total length of buffer */
|
||||
extern guint tvb_length(const tvbuff_t*);
|
||||
extern guint tvb_length(tvbuff_t*);
|
||||
|
||||
/** Computes bytes to end of buffer, from offset (which can be negative,
|
||||
* to indicate bytes from end of buffer). Function returns -1 to
|
||||
* indicate that offset is out of bounds. No exception is thrown. */
|
||||
extern gint tvb_length_remaining(const tvbuff_t*, const gint offset);
|
||||
extern gint tvb_length_remaining(tvbuff_t*, gint offset);
|
||||
|
||||
/** Same as above, but throws an exception if the offset is out of bounds. */
|
||||
extern guint tvb_ensure_length_remaining(const tvbuff_t*, const gint offset);
|
||||
extern guint tvb_ensure_length_remaining(tvbuff_t*, gint offset);
|
||||
|
||||
/* Checks (w/o throwing exception) that the bytes referred to by
|
||||
* 'offset'/'length' actually exist in the buffer */
|
||||
extern gboolean tvb_bytes_exist(const tvbuff_t*, const gint offset, const gint length);
|
||||
extern gboolean tvb_bytes_exist(tvbuff_t*, gint offset, gint length);
|
||||
|
||||
/** Checks that the bytes referred to by 'offset'/'length' actually exist
|
||||
* in the buffer, and throws an exception if they aren't. */
|
||||
extern void tvb_ensure_bytes_exist(const tvbuff_t *tvb, const gint offset, const gint length);
|
||||
extern void tvb_ensure_bytes_exist(tvbuff_t *tvb, gint offset, gint length);
|
||||
|
||||
/* Checks (w/o throwing exception) that offset exists in buffer */
|
||||
extern gboolean tvb_offset_exists(const tvbuff_t*, const gint offset);
|
||||
extern gboolean tvb_offset_exists(tvbuff_t*, gint offset);
|
||||
|
||||
/* Get reported length of buffer */
|
||||
extern guint tvb_reported_length(const tvbuff_t*);
|
||||
extern guint tvb_reported_length(tvbuff_t*);
|
||||
|
||||
/** Computes bytes of reported packet data to end of buffer, from offset
|
||||
* (which can be negative, to indicate bytes from end of buffer). Function
|
||||
* returns -1 to indicate that offset is out of bounds. No exception is
|
||||
* thrown. */
|
||||
extern gint tvb_reported_length_remaining(const tvbuff_t *tvb, const gint offset);
|
||||
extern gint tvb_reported_length_remaining(tvbuff_t *tvb, gint offset);
|
||||
|
||||
/** Set the reported length of a tvbuff to a given value; used for protocols
|
||||
whose headers contain an explicit length and where the calling
|
||||
|
@ -302,9 +302,9 @@ extern gint tvb_reported_length_remaining(const tvbuff_t *tvb, const gint offset
|
|||
this protocol.
|
||||
|
||||
Also adjusts the data length. */
|
||||
extern void tvb_set_reported_length(tvbuff_t*, const guint);
|
||||
extern void tvb_set_reported_length(tvbuff_t*, guint);
|
||||
|
||||
extern guint tvb_offset_from_real_beginning(const tvbuff_t *tvb);
|
||||
extern guint tvb_offset_from_real_beginning(tvbuff_t *tvb);
|
||||
|
||||
/* Returns the offset from the first byte of real data. */
|
||||
#define TVB_RAW_OFFSET(tvb) \
|
||||
|
@ -313,48 +313,48 @@ extern guint tvb_offset_from_real_beginning(const tvbuff_t *tvb);
|
|||
/************** START OF ACCESSORS ****************/
|
||||
/* All accessors will throw an exception if appropriate */
|
||||
|
||||
extern guint8 tvb_get_guint8(tvbuff_t*, const gint offset);
|
||||
extern guint8 tvb_get_guint8(tvbuff_t*, gint offset);
|
||||
|
||||
extern guint16 tvb_get_ntohs(tvbuff_t*, const gint offset);
|
||||
extern guint32 tvb_get_ntoh24(tvbuff_t*, const gint offset);
|
||||
extern guint32 tvb_get_ntohl(tvbuff_t*, const gint offset);
|
||||
extern guint64 tvb_get_ntoh64(tvbuff_t*, const gint offset);
|
||||
extern gfloat tvb_get_ntohieee_float(tvbuff_t*, const gint offset);
|
||||
extern gdouble tvb_get_ntohieee_double(tvbuff_t*, const gint offset);
|
||||
extern guint16 tvb_get_ntohs(tvbuff_t*, gint offset);
|
||||
extern guint32 tvb_get_ntoh24(tvbuff_t*, gint offset);
|
||||
extern guint32 tvb_get_ntohl(tvbuff_t*, gint offset);
|
||||
extern guint64 tvb_get_ntoh64(tvbuff_t*, gint offset);
|
||||
extern gfloat tvb_get_ntohieee_float(tvbuff_t*, gint offset);
|
||||
extern gdouble tvb_get_ntohieee_double(tvbuff_t*, gint offset);
|
||||
|
||||
extern guint16 tvb_get_letohs(tvbuff_t*, const gint offset);
|
||||
extern guint32 tvb_get_letoh24(tvbuff_t*, const gint offset);
|
||||
extern guint32 tvb_get_letohl(tvbuff_t*, const gint offset);
|
||||
extern guint64 tvb_get_letoh64(tvbuff_t*, const gint offset);
|
||||
extern gfloat tvb_get_letohieee_float(tvbuff_t*, const gint offset);
|
||||
extern gdouble tvb_get_letohieee_double(tvbuff_t*, const gint offset);
|
||||
extern guint16 tvb_get_letohs(tvbuff_t*, gint offset);
|
||||
extern guint32 tvb_get_letoh24(tvbuff_t*, gint offset);
|
||||
extern guint32 tvb_get_letohl(tvbuff_t*, gint offset);
|
||||
extern guint64 tvb_get_letoh64(tvbuff_t*, gint offset);
|
||||
extern gfloat tvb_get_letohieee_float(tvbuff_t*, gint offset);
|
||||
extern gdouble tvb_get_letohieee_double(tvbuff_t*, gint offset);
|
||||
|
||||
/**
|
||||
* Fetch an IPv4 address, in network byte order.
|
||||
* We do *not* convert it to host byte order; we leave it in
|
||||
* network byte order, as that's what its callers expect. */
|
||||
extern guint32 tvb_get_ipv4(tvbuff_t*, const gint offset);
|
||||
extern guint32 tvb_get_ipv4(tvbuff_t*, gint offset);
|
||||
|
||||
/* Fetch an IPv6 address. */
|
||||
extern void tvb_get_ipv6(tvbuff_t*, const gint offset, struct e_in6_addr *addr);
|
||||
extern void tvb_get_ipv6(tvbuff_t*, gint offset, struct e_in6_addr *addr);
|
||||
|
||||
/* Fetch a GUID. */
|
||||
extern void tvb_get_ntohguid(tvbuff_t *tvb, const gint offset, e_guid_t *guid);
|
||||
extern void tvb_get_letohguid(tvbuff_t *tvb, const gint offset, e_guid_t *guid);
|
||||
extern void tvb_get_guid(tvbuff_t *tvb, const gint offset, e_guid_t *guid, const gboolean little_endian);
|
||||
extern void tvb_get_ntohguid(tvbuff_t *tvb, gint offset, e_guid_t *guid);
|
||||
extern void tvb_get_letohguid(tvbuff_t *tvb, gint offset, e_guid_t *guid);
|
||||
extern void tvb_get_guid(tvbuff_t *tvb, gint offset, e_guid_t *guid, gboolean little_endian);
|
||||
|
||||
/* Fetch a specified number of bits from bit offset in a tvb */
|
||||
extern guint8 tvb_get_bits8(tvbuff_t *tvb, gint bit_offset, const gint no_of_bits);
|
||||
extern guint16 tvb_get_bits16(tvbuff_t *tvb, gint bit_offset, const gint no_of_bits, const gboolean little_endian);
|
||||
extern guint32 tvb_get_bits32(tvbuff_t *tvb, gint bit_offset, const gint no_of_bits, const gboolean little_endian);
|
||||
extern guint64 tvb_get_bits64(tvbuff_t *tvb, gint bit_offset, const gint no_of_bits, const gboolean little_endian);
|
||||
extern guint8 tvb_get_bits8(tvbuff_t *tvb, gint bit_offset, gint no_of_bits);
|
||||
extern guint16 tvb_get_bits16(tvbuff_t *tvb, gint bit_offset, gint no_of_bits, gboolean little_endian);
|
||||
extern guint32 tvb_get_bits32(tvbuff_t *tvb, gint bit_offset, gint no_of_bits, gboolean little_endian);
|
||||
extern guint64 tvb_get_bits64(tvbuff_t *tvb, gint bit_offset, gint no_of_bits, gboolean little_endian);
|
||||
|
||||
/* Fetch a specified number of bits from bit offset in a tvb, but allow number
|
||||
* of bits to range between 1 and 32. If the requested number of bits is known
|
||||
* beforehand, or its range can be handled by a single function of the group
|
||||
* above, use one of them instead.
|
||||
*/
|
||||
extern guint32 tvb_get_bits(tvbuff_t *tvb, const gint bit_offset, const gint no_of_bits, const gboolean little_endian);
|
||||
extern guint32 tvb_get_bits(tvbuff_t *tvb, gint bit_offset, gint no_of_bits, gboolean little_endian);
|
||||
|
||||
/** Returns target for convenience. Does not suffer from possible
|
||||
* expense of tvb_get_ptr(), since this routine is smart enough
|
||||
|
@ -362,17 +362,17 @@ extern guint32 tvb_get_bits(tvbuff_t *tvb, const gint bit_offset, const gint no_
|
|||
* different TVBUFF_REAL_DATA tvbuffs. This function assumes that the
|
||||
* target memory is already allocated; it does not allocate or free the
|
||||
* target memory. */
|
||||
extern void* tvb_memcpy(tvbuff_t*, void* target, const gint offset, size_t length);
|
||||
extern void* tvb_memcpy(tvbuff_t*, void* target, gint offset, size_t length);
|
||||
|
||||
/** It is the user's responsibility to g_free() the memory allocated by
|
||||
* tvb_memdup(). Calls tvb_memcpy() */
|
||||
extern void* tvb_memdup(tvbuff_t*, const gint offset, size_t length);
|
||||
extern void* tvb_memdup(tvbuff_t*, gint offset, size_t length);
|
||||
|
||||
/* Same as above but the buffer returned from this function does not have to
|
||||
* be freed. It will be automatically freed after the packet is dissected.
|
||||
* Buffers allocated by this function are NOT persistent.
|
||||
*/
|
||||
extern void* ep_tvb_memdup(tvbuff_t *tvb, const gint offset, size_t length);
|
||||
extern void* ep_tvb_memdup(tvbuff_t *tvb, gint offset, size_t length);
|
||||
|
||||
/** WARNING! This function is possibly expensive, temporarily allocating
|
||||
* another copy of the packet data. Furthermore, it's dangerous because once
|
||||
|
@ -399,7 +399,7 @@ extern void* ep_tvb_memdup(tvbuff_t *tvb, const gint offset, size_t length);
|
|||
* and the pointer to the newly-contiguous data is returned. This dynamically-
|
||||
* allocated memory will be freed when the tvbuff is freed, after the
|
||||
* tvbuff_free_cb_t() is called, if any. */
|
||||
extern const guint8* tvb_get_ptr(tvbuff_t*, const gint offset, const gint length);
|
||||
extern const guint8* tvb_get_ptr(tvbuff_t*, gint offset, gint length);
|
||||
|
||||
/** Find first occurence of any of the needles in tvbuff, starting at offset.
|
||||
* Searches at most maxlength number of bytes; if maxlength is -1, searches
|
||||
|
@ -408,8 +408,8 @@ extern const guint8* tvb_get_ptr(tvbuff_t*, const gint offset, const gint length
|
|||
* Will not throw an exception, even if maxlength exceeds boundary of tvbuff;
|
||||
* in that case, -1 will be returned if the boundary is reached before
|
||||
* finding needle. */
|
||||
extern gint tvb_find_guint8(tvbuff_t*, const gint offset, const gint maxlength,
|
||||
const guint8 needle);
|
||||
extern gint tvb_find_guint8(tvbuff_t*, gint offset, gint maxlength,
|
||||
guint8 needle);
|
||||
|
||||
/** Find first occurence of any of the needles in tvbuff, starting at offset.
|
||||
* Searches at most maxlength number of bytes. Returns the offset of the
|
||||
|
@ -417,7 +417,7 @@ extern gint tvb_find_guint8(tvbuff_t*, const gint offset, const gint maxlength,
|
|||
* Will not throw an exception, even if
|
||||
* maxlength exceeds boundary of tvbuff; in that case, -1 will be returned if
|
||||
* the boundary is reached before finding needle. */
|
||||
extern gint tvb_pbrk_guint8(tvbuff_t *, const gint offset, const gint maxlength,
|
||||
extern gint tvb_pbrk_guint8(tvbuff_t *, gint offset, gint maxlength,
|
||||
const guint8 *needles, guchar *found_needle);
|
||||
|
||||
/** Find size of stringz (NUL-terminated string) by looking for terminating
|
||||
|
@ -425,13 +425,13 @@ extern gint tvb_pbrk_guint8(tvbuff_t *, const gint offset, const gint maxlength,
|
|||
*
|
||||
* If the NUL isn't found, it throws the appropriate exception.
|
||||
*/
|
||||
extern guint tvb_strsize(tvbuff_t *tvb, const gint offset);
|
||||
extern guint tvb_strsize(tvbuff_t *tvb, gint offset);
|
||||
|
||||
/** Find length of string by looking for end of zero terminated string, up to
|
||||
* 'maxlength' characters'; if 'maxlength' is -1, searches to end
|
||||
* of tvbuff.
|
||||
* Returns -1 if 'maxlength' reached before finding EOS. */
|
||||
extern gint tvb_strnlen(tvbuff_t*, const gint offset, const guint maxlength);
|
||||
extern gint tvb_strnlen(tvbuff_t*, gint offset, guint maxlength);
|
||||
|
||||
/** Convert a string from Unicode to ASCII. At the moment we fake it by
|
||||
* assuming all characters are ASCII )-: The len parameter is the number
|
||||
|
@ -444,33 +444,33 @@ extern gint tvb_strnlen(tvbuff_t*, const gint offset, const guint maxlength);
|
|||
* automatically freed when wireshark starts dissecting
|
||||
* the next packet.
|
||||
*/
|
||||
extern char *tvb_fake_unicode(tvbuff_t *tvb, int offset, const int len,
|
||||
const gboolean little_endian);
|
||||
extern char *tvb_get_ephemeral_faked_unicode(tvbuff_t *tvb, int offset, const int len,
|
||||
const gboolean little_endian);
|
||||
extern char *tvb_fake_unicode(tvbuff_t *tvb, int offset, int len,
|
||||
gboolean little_endian);
|
||||
extern char *tvb_get_ephemeral_faked_unicode(tvbuff_t *tvb, int offset, int len,
|
||||
gboolean little_endian);
|
||||
|
||||
/**
|
||||
* Format the data in the tvb from offset for size ...
|
||||
*/
|
||||
extern gchar * tvb_format_text(tvbuff_t *tvb, const gint offset, const gint size);
|
||||
extern gchar * tvb_format_text(tvbuff_t *tvb, gint offset, gint size);
|
||||
|
||||
/**
|
||||
* Like "tvb_format_text()", but for 'wsp'; don't show
|
||||
* the characters as C-style escapes.
|
||||
*/
|
||||
extern gchar * tvb_format_text_wsp(tvbuff_t *tvb, const gint offset, const gint size);
|
||||
extern gchar * tvb_format_text_wsp(tvbuff_t *tvb, gint offset, gint size);
|
||||
|
||||
/**
|
||||
* Like "tvb_format_text()", but for null-padded strings; don't show
|
||||
* the null padding characters as "\000".
|
||||
*/
|
||||
extern gchar *tvb_format_stringzpad(tvbuff_t *tvb, const gint offset, const gint size);
|
||||
extern gchar *tvb_format_stringzpad(tvbuff_t *tvb, gint offset, gint size);
|
||||
|
||||
/**
|
||||
* Like "tvb_format_text_wsp()", but for null-padded strings; don't show
|
||||
* the null padding characters as "\000".
|
||||
*/
|
||||
extern gchar *tvb_format_stringzpad_wsp(tvbuff_t *tvb, const gint offset, const gint size);
|
||||
extern gchar *tvb_format_stringzpad_wsp(tvbuff_t *tvb, gint offset, gint size);
|
||||
|
||||
|
||||
/**
|
||||
|
@ -493,9 +493,9 @@ extern gchar *tvb_format_stringzpad_wsp(tvbuff_t *tvb, const gint offset, const
|
|||
* instead it will automatically be freed when a new capture
|
||||
* or file is opened.
|
||||
*/
|
||||
extern guint8 *tvb_get_string(tvbuff_t *tvb, const gint offset, const gint length);
|
||||
extern guint8 *tvb_get_ephemeral_string(tvbuff_t *tvb, const gint offset, const gint length);
|
||||
extern guint8 *tvb_get_seasonal_string(tvbuff_t *tvb, const gint offset, const gint length);
|
||||
extern guint8 *tvb_get_string(tvbuff_t *tvb, gint offset, gint length);
|
||||
extern guint8 *tvb_get_ephemeral_string(tvbuff_t *tvb, gint offset, gint length);
|
||||
extern guint8 *tvb_get_seasonal_string(tvbuff_t *tvb, gint offset, gint length);
|
||||
|
||||
|
||||
/**
|
||||
|
@ -520,7 +520,7 @@ extern guint8 *tvb_get_seasonal_string(tvbuff_t *tvb, const gint offset, const g
|
|||
*/
|
||||
extern guint8 *tvb_get_stringz(tvbuff_t *tvb, gint offset, gint *lengthp);
|
||||
extern guint8 *tvb_get_ephemeral_stringz(tvbuff_t *tvb, gint offset, gint *lengthp);
|
||||
extern guint8 *tvb_get_seasonal_stringz(tvbuff_t *tvb, const gint offset, gint *lengthp);
|
||||
extern guint8 *tvb_get_seasonal_stringz(tvbuff_t *tvb, gint offset, gint *lengthp);
|
||||
|
||||
/** Looks for a stringz (NUL-terminated string) in tvbuff and copies
|
||||
* no more than bufsize number of bytes, including terminating NUL, to buffer.
|
||||
|
@ -535,7 +535,7 @@ extern guint8 *tvb_get_seasonal_stringz(tvbuff_t *tvb, const gint offset, gint *
|
|||
* is truncated with a NUL, albeit not at buffer[bufsize - 1], but
|
||||
* at the correct spot, terminating the string.
|
||||
*/
|
||||
extern gint tvb_get_nstringz(tvbuff_t *tvb, const gint offset, guint bufsize,
|
||||
extern gint tvb_get_nstringz(tvbuff_t *tvb, gint offset, guint bufsize,
|
||||
guint8* buffer);
|
||||
|
||||
/** Like tvb_get_nstringz(), but never returns -1. The string is guaranteed to
|
||||
|
@ -544,7 +544,7 @@ extern gint tvb_get_nstringz(tvbuff_t *tvb, const gint offset, guint bufsize,
|
|||
*
|
||||
* bufsize MUST be greater than 0.
|
||||
*/
|
||||
extern gint tvb_get_nstringz0(tvbuff_t *tvb, const gint offset, const guint bufsize,
|
||||
extern gint tvb_get_nstringz0(tvbuff_t *tvb, gint offset, guint bufsize,
|
||||
guint8* buffer);
|
||||
|
||||
/**
|
||||
|
@ -566,8 +566,8 @@ extern gint tvb_get_nstringz0(tvbuff_t *tvb, const gint offset, const guint bufs
|
|||
* terminator, or past the end of the buffer if we don't find a line
|
||||
* terminator. (It's not set if we return -1.)
|
||||
*/
|
||||
extern gint tvb_find_line_end(tvbuff_t *tvb, const gint offset, int len,
|
||||
gint *next_offset, const gboolean desegment);
|
||||
extern gint tvb_find_line_end(tvbuff_t *tvb, gint offset, int len,
|
||||
gint *next_offset, gboolean desegment);
|
||||
|
||||
/**
|
||||
* Given a tvbuff, an offset into the tvbuff, and a length that starts
|
||||
|
@ -587,7 +587,7 @@ extern gint tvb_find_line_end(tvbuff_t *tvb, const gint offset, int len,
|
|||
* terminator, or past the end of the buffer if we don't find a line
|
||||
* terminator.
|
||||
*/
|
||||
extern gint tvb_find_line_end_unquoted(tvbuff_t *tvb, const gint offset, int len,
|
||||
extern gint tvb_find_line_end_unquoted(tvbuff_t *tvb, gint offset, int len,
|
||||
gint *next_offset);
|
||||
|
||||
/**
|
||||
|
@ -607,16 +607,16 @@ extern gint tvb_find_line_end_unquoted(tvbuff_t *tvb, const gint offset, int len
|
|||
* is smaller.
|
||||
*/
|
||||
|
||||
extern gint tvb_skip_wsp(tvbuff_t* tvb, const gint offset, const gint maxlength);
|
||||
extern gint tvb_skip_wsp(tvbuff_t* tvb, gint offset, gint maxlength);
|
||||
|
||||
extern gint tvb_skip_wsp_return(tvbuff_t* tvb, const gint offset);
|
||||
extern gint tvb_skip_wsp_return(tvbuff_t* tvb, gint offset);
|
||||
|
||||
/**
|
||||
* Call strncmp after checking if enough chars left, returning 0 if
|
||||
* it returns 0 (meaning "equal") and -1 otherwise, otherwise return -1.
|
||||
*/
|
||||
extern gint tvb_strneql(tvbuff_t *tvb, const gint offset, const gchar *str,
|
||||
const gint size);
|
||||
extern gint tvb_strneql(tvbuff_t *tvb, gint offset, const gchar *str,
|
||||
gint size);
|
||||
|
||||
/**
|
||||
* Call g_ascii_strncasecmp after checking if enough chars left, returning
|
||||
|
@ -629,7 +629,7 @@ extern gint tvb_strncaseeql(tvbuff_t *tvb, gint offset, const gchar *str,
|
|||
* Call memcmp after checking if enough chars left, returning 0 if
|
||||
* it returns 0 (meaning "equal") and -1 otherwise, otherwise return -1.
|
||||
*/
|
||||
extern gint tvb_memeql(tvbuff_t *tvb, const gint offset, const guint8 *str,
|
||||
extern gint tvb_memeql(tvbuff_t *tvb, gint offset, const guint8 *str,
|
||||
size_t size);
|
||||
|
||||
/**
|
||||
|
@ -637,14 +637,14 @@ extern gint tvb_memeql(tvbuff_t *tvb, const gint offset, const guint8 *str,
|
|||
* to the string with the formatted data, with "punct" as a byte
|
||||
* separator.
|
||||
*/
|
||||
extern gchar *tvb_bytes_to_str_punct(tvbuff_t *tvb, const gint offset, const gint len,
|
||||
const gchar punct);
|
||||
extern gchar *tvb_bytes_to_str_punct(tvbuff_t *tvb, gint offset, gint len,
|
||||
gchar punct);
|
||||
|
||||
/*
|
||||
* Format a bunch of data from a tvbuff as bytes, returning a pointer
|
||||
* to the string with the formatted data.
|
||||
*/
|
||||
extern gchar *tvb_bytes_to_str(tvbuff_t *tvb, const gint offset, const gint len);
|
||||
extern gchar *tvb_bytes_to_str(tvbuff_t *tvb, gint offset, gint len);
|
||||
|
||||
#define TVB_GET_DS_TVB(tvb) \
|
||||
(tvb->ds_tvb)
|
||||
|
@ -654,21 +654,21 @@ extern gchar *tvb_bytes_to_str(tvbuff_t *tvb, const gint offset, const gint len)
|
|||
* 'haystack', or -1 if 'needle' is not found. The index is relative
|
||||
* to the start of 'haystack', not 'haystack_offset'. */
|
||||
extern gint tvb_find_tvb(tvbuff_t *haystack_tvb, tvbuff_t *needle_tvb,
|
||||
const gint haystack_offset);
|
||||
gint haystack_offset);
|
||||
|
||||
/**
|
||||
* Uncompresses a zlib compressed packet inside a tvbuff at offset with
|
||||
* length comprlen. Returns an uncompressed tvbuffer if uncompression
|
||||
* succeeded or NULL if uncompression failed.
|
||||
*/
|
||||
extern tvbuff_t* tvb_uncompress(tvbuff_t *tvb, const int offset, int comprlen);
|
||||
extern tvbuff_t* tvb_uncompress(tvbuff_t *tvb, int offset, int comprlen);
|
||||
|
||||
/**
|
||||
* Uncompresses a zlib compressed packet inside a tvbuff at offset with
|
||||
* length comprlen. Returns an uncompressed tvbuffer attached to tvb if uncompression
|
||||
* succeeded or NULL if uncompression failed.
|
||||
*/
|
||||
extern tvbuff_t* tvb_child_uncompress(tvbuff_t *parent, tvbuff_t *tvb, const int offset, int comprlen);
|
||||
extern tvbuff_t* tvb_child_uncompress(tvbuff_t *parent, tvbuff_t *tvb, int offset, int comprlen);
|
||||
|
||||
/************** END OF ACCESSORS ****************/
|
||||
|
||||
|
|
|
@ -37,7 +37,7 @@
|
|||
Returns the associated string ptr on a match.
|
||||
Formats val with fmt, and returns the resulting string, on failure. */
|
||||
const gchar*
|
||||
val_to_str(const guint32 val, const value_string *vs, const char *fmt) {
|
||||
val_to_str(guint32 val, const value_string *vs, const char *fmt) {
|
||||
const gchar *ret;
|
||||
|
||||
g_assert(fmt != NULL);
|
||||
|
@ -53,7 +53,7 @@ val_to_str(const guint32 val, const value_string *vs, const char *fmt) {
|
|||
Returns the associated string ptr on a match.
|
||||
Returns 'unknown_str', on failure. */
|
||||
const gchar*
|
||||
val_to_str_const(const guint32 val, const value_string *vs, const char *unknown_str) {
|
||||
val_to_str_const(guint32 val, const value_string *vs, const char *unknown_str) {
|
||||
const gchar *ret;
|
||||
|
||||
g_assert(unknown_str != NULL);
|
||||
|
@ -70,7 +70,7 @@ val_to_str_const(const guint32 val, const value_string *vs, const char *unknown_
|
|||
that table, on a match, and returns NULL, and sets "*idx" to -1,
|
||||
on failure. */
|
||||
const gchar*
|
||||
match_strval_idx(const guint32 val, const value_string *vs, gint *idx) {
|
||||
match_strval_idx(guint32 val, const value_string *vs, gint *idx) {
|
||||
gint i = 0;
|
||||
|
||||
if(vs) {
|
||||
|
@ -89,7 +89,7 @@ match_strval_idx(const guint32 val, const value_string *vs, gint *idx) {
|
|||
|
||||
/* Like match_strval_idx(), but doesn't return the index. */
|
||||
const gchar*
|
||||
match_strval(const guint32 val, const value_string *vs) {
|
||||
match_strval(guint32 val, const value_string *vs) {
|
||||
gint ignore_me;
|
||||
return match_strval_idx(val, vs, &ignore_me);
|
||||
}
|
||||
|
@ -142,7 +142,7 @@ match_strstr(const gchar *val, const string_string *vs) {
|
|||
/* Generate a string describing an enumerated bitfield (an N-bit field
|
||||
with various specific values having particular names). */
|
||||
const char *
|
||||
decode_enumerated_bitfield(const guint32 val, const guint32 mask, const int width,
|
||||
decode_enumerated_bitfield(guint32 val, guint32 mask, int width,
|
||||
const value_string *tab, const char *fmt)
|
||||
{
|
||||
static char buf[1025];
|
||||
|
@ -157,7 +157,7 @@ decode_enumerated_bitfield(const guint32 val, const guint32 mask, const int widt
|
|||
/* Generate a string describing an enumerated bitfield (an N-bit field
|
||||
with various specific values having particular names). */
|
||||
const char *
|
||||
decode_enumerated_bitfield_shifted(const guint32 val, const guint32 mask, const int width,
|
||||
decode_enumerated_bitfield_shifted(guint32 val, guint32 mask, int width,
|
||||
const value_string *tab, const char *fmt)
|
||||
{
|
||||
static char buf[1025];
|
||||
|
@ -180,7 +180,7 @@ decode_enumerated_bitfield_shifted(const guint32 val, const guint32 mask, const
|
|||
/* Tries to match val against each range in the range_string array rs.
|
||||
Returns the associated string ptr on a match.
|
||||
Formats val with fmt, and returns the resulting string, on failure. */
|
||||
const gchar *rval_to_str(const guint32 val, const range_string *rs, const char *fmt)
|
||||
const gchar *rval_to_str(guint32 val, const range_string *rs, const char *fmt)
|
||||
{
|
||||
const gchar *ret = NULL;
|
||||
|
||||
|
@ -197,7 +197,7 @@ const gchar *rval_to_str(const guint32 val, const range_string *rs, const char *
|
|||
Returns the associated string ptr, and sets "*idx" to the index in
|
||||
that table, on a match, and returns NULL, and sets "*idx" to -1,
|
||||
on failure. */
|
||||
const gchar *match_strrval_idx(const guint32 val, const range_string *rs, gint *idx)
|
||||
const gchar *match_strrval_idx(guint32 val, const range_string *rs, gint *idx)
|
||||
{
|
||||
gint i = 0;
|
||||
|
||||
|
@ -216,7 +216,7 @@ const gchar *match_strrval_idx(const guint32 val, const range_string *rs, gint *
|
|||
}
|
||||
|
||||
/* Like match_strrval_idx(), but doesn't return the index. */
|
||||
const gchar *match_strrval(const guint32 val, const range_string *rs)
|
||||
const gchar *match_strrval(guint32 val, const range_string *rs)
|
||||
{
|
||||
gint ignore_me = 0;
|
||||
return match_strrval_idx(val, rs, &ignore_me);
|
||||
|
|
|
@ -55,20 +55,20 @@ typedef struct _range_string {
|
|||
Returns the associated string ptr, and sets "*idx" to the index in
|
||||
that table, on a match, and returns NULL, and sets "*idx" to -1,
|
||||
on failure. */
|
||||
extern const gchar* match_strval_idx(const guint32 val, const value_string *vs, gint *idx);
|
||||
extern const gchar* match_strval_idx(guint32 val, const value_string *vs, gint *idx);
|
||||
|
||||
/* Like match_strval_idx(), but doesn't return the index. */
|
||||
extern const gchar* match_strval(const guint32 val, const value_string *vs);
|
||||
extern const gchar* match_strval(guint32 val, const value_string *vs);
|
||||
|
||||
/* Tries to match val against each element in the value_string array vs.
|
||||
Returns the associated string ptr on a match.
|
||||
Formats val with fmt, and returns the resulting string, on failure. */
|
||||
extern const gchar* val_to_str(const guint32 val, const value_string *vs, const char *fmt);
|
||||
extern const gchar* val_to_str(guint32 val, const value_string *vs, const char *fmt);
|
||||
|
||||
/* Tries to match val against each element in the value_string array vs.
|
||||
Returns the associated string ptr on a match.
|
||||
Returns 'unknown_str', on failure. */
|
||||
extern const gchar* val_to_str_const(const guint32 val, const value_string *vs, const char *unknown_str);
|
||||
extern const gchar* val_to_str_const(guint32 val, const value_string *vs, const char *unknown_str);
|
||||
|
||||
/* Tries to match val against each element in the value_string array vs.
|
||||
Returns the associated string ptr, and sets "*idx" to the index in
|
||||
|
@ -86,13 +86,13 @@ extern const gchar* str_to_str(const gchar *val, const string_string *vs, const
|
|||
|
||||
/* Generate a string describing an enumerated bitfield (an N-bit field
|
||||
with various specific values having particular names). */
|
||||
extern const char *decode_enumerated_bitfield(const guint32 val, const guint32 mask,
|
||||
const int width, const value_string *tab, const char *fmt);
|
||||
extern const char *decode_enumerated_bitfield(guint32 val, guint32 mask,
|
||||
int width, const value_string *tab, const char *fmt);
|
||||
|
||||
/* Generate a string describing an enumerated bitfield (an N-bit field
|
||||
with various specific values having particular names). */
|
||||
extern const char *decode_enumerated_bitfield_shifted(const guint32 val, const guint32 mask,
|
||||
const int width, const value_string *tab, const char *fmt);
|
||||
extern const char *decode_enumerated_bitfield_shifted(guint32 val, guint32 mask,
|
||||
int width, const value_string *tab, const char *fmt);
|
||||
|
||||
|
||||
/* ranges aware versions */
|
||||
|
@ -100,15 +100,15 @@ extern const char *decode_enumerated_bitfield_shifted(const guint32 val, const g
|
|||
/* Tries to match val against each range in the range_string array rs.
|
||||
Returns the associated string ptr on a match.
|
||||
Formats val with fmt, and returns the resulting string, on failure. */
|
||||
extern const gchar* rval_to_str(const guint32 val, const range_string *rs, const char *fmt);
|
||||
extern const gchar* rval_to_str(guint32 val, const range_string *rs, const char *fmt);
|
||||
|
||||
/* Tries to match val against each range in the range_string array rs.
|
||||
Returns the associated string ptr, and sets "*idx" to the index in
|
||||
that table, on a match, and returns NULL, and sets "*idx" to -1,
|
||||
on failure. */
|
||||
extern const gchar *match_strrval_idx(const guint32 val, const range_string *rs, gint *idx);
|
||||
extern const gchar *match_strrval_idx(guint32 val, const range_string *rs, gint *idx);
|
||||
|
||||
/* Like match_strrval_idx(), but doesn't return the index. */
|
||||
extern const gchar *match_strrval(const guint32 val, const range_string *rs);
|
||||
extern const gchar *match_strrval(guint32 val, const range_string *rs);
|
||||
|
||||
#endif /* __VALUE_STRING_H__ */
|
||||
|
|
Loading…
Reference in New Issue