osmith
/
wireshark
forked from osmocom/wireshark
1
0
Fork 0
Code Pull Requests Releases Wiki Activity

Replace g_assert() with ws_assert()

pespin/rlcmac
João Valverde 2021-06-18 19:21:42 +01:00 committed by Wireshark GitLab Utility
parent b4eddd32c1
commit 0e50979b3f
95 changed files with 679 additions and 584 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
capinfos.c
View File

@ -83,6 +83,7 @@
#include <wsutil/report_message.h>
#include <wsutil/str_util.h>
#include <wsutil/file_util.h>
#include <wsutil/ws_assert.h>
#include <wsutil/wsgcrypt.h>
@ -781,7 +782,7 @@ print_stats(const gchar *filename, capture_info *cf_info)
if (cap_file_idb && cf_info->num_interfaces != 0) {
guint i;
g_assert(cf_info->num_interfaces == cf_info->idb_info_strings->len);
ws_assert(cf_info->num_interfaces == cf_info->idb_info_strings->len);
printf ("Number of interfaces in file: %u\n", cf_info->num_interfaces);
for (i = 0; i < cf_info->idb_info_strings->len; i++) {
gchar *s = g_array_index(cf_info->idb_info_strings, gchar*, i);
@ -1123,7 +1124,7 @@ static void
cleanup_capture_info(capture_info *cf_info)
{
guint i;
g_assert(cf_info != NULL);
ws_assert(cf_info != NULL);
g_free(cf_info->encap_counts);
cf_info->encap_counts = NULL;
@ -1210,7 +1211,7 @@ process_cap_file(const char *filename, gboolean need_separator)
idb_info = wtap_file_get_idb_info(cf_info.wth);
g_assert(idb_info->interface_data != NULL);
ws_assert(idb_info->interface_data != NULL);
cf_info.num_interfaces = idb_info->interface_data->len;
cf_info.interface_packet_counts = g_array_sized_new(FALSE, TRUE, sizeof(guint32), cf_info.num_interfaces);

79
capture/capture-wpcap.c
View File

@ -35,6 +35,7 @@ gboolean has_wpcap = FALSE;
#include "capture/capture-pcap-util-int.h"
#include <wsutil/file_util.h>
#include <wsutil/ws_assert.h>
/* XXX - yes, I know, I should move cppmagic.h to a generic location. */
#include "tools/lemon/cppmagic.h"
@ -247,7 +248,7 @@ local_code_page_str_to_utf8(char *str)
static void
prepare_errbuf(char *errbuf)
{
g_assert(errbuf);
ws_assert(errbuf);
errbuf[0] = '\0';
}
@ -283,49 +284,49 @@ cant_load_winpcap_err(const char *app_name)
void
pcap_close(pcap_t *a)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
p_pcap_close(a);
}
int
pcap_stats(pcap_t *a, struct pcap_stat *b)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
return p_pcap_stats(a, b);
}
int
pcap_dispatch(pcap_t *a, int b, pcap_handler c, guchar *d)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
return p_pcap_dispatch(a, b, c, d);
}
int
pcap_snapshot(pcap_t *a)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
return p_pcap_snapshot(a);
}
int
pcap_datalink(pcap_t *a)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
return p_pcap_datalink(a);
}
int
pcap_set_datalink(pcap_t *p, int dlt)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
return p_pcap_set_datalink(p, dlt);
}
int
pcap_setfilter(pcap_t *a, struct bpf_program *b)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
return p_pcap_setfilter(a, b);
}
@ -333,7 +334,7 @@ char*
pcap_geterr(pcap_t *a)
{
char *errbuf;
g_assert(has_wpcap);
ws_assert(has_wpcap);
errbuf = p_pcap_geterr(a);
convert_errbuf_to_utf8(errbuf);
return errbuf;
@ -343,7 +344,7 @@ int
pcap_compile(pcap_t *a, struct bpf_program *b, const char *c, int d,
bpf_u_int32 e)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
return p_pcap_compile(a, b, c, d, e);
}
@ -351,7 +352,7 @@ int
pcap_compile_nopcap(int a, int b, struct bpf_program *c, const char *d, int e,
bpf_u_int32 f)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
return p_pcap_compile_nopcap(a, b, c, d, e, f);
}
@ -359,7 +360,7 @@ int
pcap_lookupnet(const char *a, bpf_u_int32 *b, bpf_u_int32 *c, char *errbuf)
{
int ret;
g_assert(has_wpcap);
ws_assert(has_wpcap);
ret = p_pcap_lookupnet(a, b, c, errbuf);
if (ret == -1)
convert_errbuf_to_utf8(errbuf);
@ -421,7 +422,7 @@ int
pcap_findalldevs_ex(const char *a, struct pcap_rmtauth *b, pcap_if_t **c, char *errbuf)
{
int ret;
g_assert(has_wpcap);
ws_assert(has_wpcap);
ret = p_pcap_findalldevs_ex(a, b, c, errbuf);
if (ret == -1)
convert_errbuf_to_utf8(errbuf);
@ -433,7 +434,7 @@ pcap_createsrcstr(char *a, int b, const char *c, const char *d, const char *e,
char *errbuf)
{
int ret;
g_assert(has_wpcap);
ws_assert(has_wpcap);
ret = p_pcap_createsrcstr(a, b, c, d, e, errbuf);
if (ret == -1)
convert_errbuf_to_utf8(errbuf);
@ -445,7 +446,7 @@ pcap_createsrcstr(char *a, int b, const char *c, const char *d, const char *e,
struct pcap_samp *
pcap_setsampling(pcap_t *a)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
if (p_pcap_setsampling != NULL) {
return p_pcap_setsampling(a);
}
@ -456,14 +457,14 @@ pcap_setsampling(pcap_t *a)
int
pcap_loop(pcap_t *a, int b, pcap_handler c, guchar *d)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
return p_pcap_loop(a, b, c, d);
}
void
pcap_freecode(struct bpf_program *a)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
p_pcap_freecode(a);
}
@ -471,7 +472,7 @@ int
pcap_findalldevs(pcap_if_t **a, char *errbuf)
{
int ret;
g_assert(has_wpcap);
ws_assert(has_wpcap);
ret = p_pcap_findalldevs(a, errbuf);
if (ret == -1)
convert_errbuf_to_utf8(errbuf);
@ -481,7 +482,7 @@ pcap_findalldevs(pcap_if_t **a, char *errbuf)
void
pcap_freealldevs(pcap_if_t *a)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
p_pcap_freealldevs(a);
}
@ -490,7 +491,7 @@ pcap_t *
pcap_create(const char *a, char *errbuf)
{
pcap_t *p;
g_assert(has_wpcap && p_pcap_create != NULL);
ws_assert(has_wpcap && p_pcap_create != NULL);
p = p_pcap_create(a, errbuf);
if (p == NULL)
convert_errbuf_to_utf8(errbuf);
@ -500,21 +501,21 @@ pcap_create(const char *a, char *errbuf)
int
pcap_set_snaplen(pcap_t *a, int b)
{
g_assert(has_wpcap && p_pcap_set_snaplen != NULL);
ws_assert(has_wpcap && p_pcap_set_snaplen != NULL);
return p_pcap_set_snaplen(a, b);
}
int
pcap_set_promisc(pcap_t *a, int b)
{
g_assert(has_wpcap && p_pcap_set_promisc != NULL);
ws_assert(has_wpcap && p_pcap_set_promisc != NULL);
return p_pcap_set_promisc(a, b);
}
int
pcap_can_set_rfmon(pcap_t *a)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
if (p_pcap_can_set_rfmon != NULL) {
return p_pcap_can_set_rfmon(a);
}
@ -524,27 +525,27 @@ pcap_can_set_rfmon(pcap_t *a)
int
pcap_set_rfmon(pcap_t *a, int b)
{
g_assert(has_wpcap && p_pcap_set_rfmon != NULL);
ws_assert(has_wpcap && p_pcap_set_rfmon != NULL);
return p_pcap_set_rfmon(a, b);
}
int
pcap_set_timeout(pcap_t *a, int b)
{
g_assert(has_wpcap && p_pcap_set_timeout != NULL);
ws_assert(has_wpcap && p_pcap_set_timeout != NULL);
return p_pcap_set_timeout(a, b);
}
int
pcap_set_buffer_size(pcap_t *a, int b)
{
g_assert(has_wpcap && p_pcap_set_buffer_size != NULL);
ws_assert(has_wpcap && p_pcap_set_buffer_size != NULL);
return p_pcap_set_buffer_size(a, b);
}
int
pcap_activate(pcap_t *a)
{
g_assert(has_wpcap && p_pcap_activate != NULL);
ws_assert(has_wpcap && p_pcap_activate != NULL);
return p_pcap_activate(a);
}
@ -554,7 +555,7 @@ pcap_statustostr(int a)
{
static char ebuf[15 + 10 + 1];
g_assert(has_wpcap);
ws_assert(has_wpcap);
if (p_pcap_statustostr != NULL) {
return p_pcap_statustostr(a);
}
@ -569,7 +570,7 @@ pcap_statustostr(int a)
#ifdef HAVE_PCAP_SET_TSTAMP_TYPE
int
pcap_set_tstamp_type(pcap_t *a, int b) {
g_assert(has_wpcap);
ws_assert(has_wpcap);
if (p_pcap_set_tstamp_type != NULL) {
return p_pcap_set_tstamp_type(a, b);
}
@ -578,7 +579,7 @@ pcap_set_tstamp_type(pcap_t *a, int b) {
int
pcap_set_tstamp_precision(pcap_t *a, int b) {
g_assert(has_wpcap);
ws_assert(has_wpcap);
if (p_pcap_set_tstamp_precision != NULL) {
return p_pcap_set_tstamp_precision(a, b);
}
@ -588,7 +589,7 @@ pcap_set_tstamp_precision(pcap_t *a, int b) {
int
pcap_get_tstamp_precision(pcap_t *a) {
g_assert(has_wpcap);
ws_assert(has_wpcap);
if (p_pcap_get_tstamp_precision != NULL) {
return p_pcap_get_tstamp_precision(a);
}
@ -598,7 +599,7 @@ pcap_get_tstamp_precision(pcap_t *a) {
int
pcap_list_tstamp_types(pcap_t *a, int **b) {
g_assert(has_wpcap);
ws_assert(has_wpcap);
if (p_pcap_list_tstamp_types != NULL) {
return p_pcap_list_tstamp_types(a, b);
}
@ -607,7 +608,7 @@ pcap_list_tstamp_types(pcap_t *a, int **b) {
void
pcap_free_tstamp_types(int *a) {
g_assert(has_wpcap);
ws_assert(has_wpcap);
if (p_pcap_free_tstamp_types != NULL) {
p_pcap_free_tstamp_types(a);
}
@ -615,7 +616,7 @@ pcap_free_tstamp_types(int *a) {
int
pcap_tstamp_type_name_to_val(const char *a) {
g_assert(has_wpcap);
ws_assert(has_wpcap);
if (p_pcap_tstamp_type_name_to_val != NULL) {
return p_pcap_tstamp_type_name_to_val(a);
}
@ -624,7 +625,7 @@ pcap_tstamp_type_name_to_val(const char *a) {
const char *
pcap_tstamp_type_val_to_name(int a) {
g_assert(has_wpcap);
ws_assert(has_wpcap);
if (p_pcap_tstamp_type_val_to_name != NULL) {
return p_pcap_tstamp_type_val_to_name(a);
}
@ -633,7 +634,7 @@ pcap_tstamp_type_val_to_name(int a) {
const char *
pcap_tstamp_type_val_to_description(int a) {
g_assert(has_wpcap);
ws_assert(has_wpcap);
if (p_pcap_tstamp_type_val_to_description != NULL) {
return p_pcap_tstamp_type_val_to_description(a);
}
@ -663,7 +664,7 @@ pcap_list_datalinks(pcap_t *p, int **ddlt)
void
pcap_free_datalinks(int *ddlt)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
/*
* If we don't have pcap_free_datalinks() in WinPcap,
@ -703,7 +704,7 @@ void pcap_breakloop(pcap_t *a)
/* setbuff is win32 specific! */
int pcap_setbuff(pcap_t *a, int b)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
return p_pcap_setbuff(a, b);
}
@ -711,7 +712,7 @@ int pcap_setbuff(pcap_t *a, int b)
/* (if you get a declaration warning here, try to update to at least WinPcap 3.1b4 develpack) */
int pcap_next_ex(pcap_t *a, struct pcap_pkthdr **b, const u_char **c)
{
g_assert(has_wpcap);
ws_assert(has_wpcap);
return p_pcap_next_ex(a, b, c);
}

9
capture/capture_sync.c
View File

@ -22,6 +22,7 @@
#include <wsutil/strtoi.h>
#include <wsutil/wslog.h>
#include <wsutil/ws_assert.h>
#ifdef _WIN32
#include <wsutil/unicode-utils.h>
@ -1515,9 +1516,9 @@ sync_pipe_gets_nonblock(int pipe_fd, char *bytes, int max) {
/* convert header values (indicator and 3-byte length) */
static void
pipe_convert_header(const guchar *header, int header_len, char *indicator, int *block_len) {
pipe_convert_header(const guchar *header, int header_len _U_, char *indicator, int *block_len) {
g_assert(header_len == 4);
ws_assert(header_len == 4);
/* convert header values */
*indicator = header[0];
@ -1742,7 +1743,7 @@ sync_pipe_input_cb(gint source, gpointer user_data)
break;
}
default:
g_assert_not_reached();
ws_assert_not_reached();
}
return TRUE;
@ -1772,7 +1773,7 @@ sync_pipe_wait_for_child(ws_process_id fork_child, gchar **msgp)
start_time = g_get_monotonic_time();
ws_debug("wait till child closed");
g_assert(fork_child != WS_INVALID_PID);
ws_assert(fork_child != WS_INVALID_PID);
*msgp = NULL; /* assume no error */
#ifdef _WIN32

3
capture_opts.c
View File

@ -29,6 +29,7 @@
#include <ui/exit_codes.h>
#include <wsutil/file_util.h>
#include <wsutil/ws_pipe.h>
#include <wsutil/ws_assert.h>
#include "capture/capture_ifinfo.h"
#include "capture/capture-pcap-util.h"
@ -997,7 +998,7 @@ capture_opts_add_opt(capture_options *capture_opts, int opt, const char *optarg_
break;
default:
/* the caller is responsible to send us only the right opt's */
g_assert_not_reached();
ws_assert_not_reached();
}
return 0;

11
dumpcap.c
View File

@ -88,6 +88,7 @@
#include "wsutil/time_util.h"
#include "wsutil/please_report_bug.h"
#include "wsutil/glib-compat.h"
#include <wsutil/ws_assert.h>
#include "capture/ws80211_utils.h"
@ -2134,7 +2135,7 @@ pcapng_adjust_block(capture_src *pcap_src, const pcapng_block_header_t *bh, u_ch
for (unsigned i = 0; i < pcap_src->cap_pipe_info.pcapng.src_iface_to_global->len; i++) {
guint32 iface_id = g_array_index(pcap_src->cap_pipe_info.pcapng.src_iface_to_global, guint32, i);
saved_idb_t *idb_source = &g_array_index(global_ld.saved_idbs, saved_idb_t, iface_id);
g_assert(idb_source->interface_id == pcap_src->interface_id);
ws_assert(idb_source->interface_id == pcap_src->interface_id);
g_free(idb_source->idb);
memset(idb_source, 0, sizeof(saved_idb_t));
idb_source->deleted = TRUE;
@ -3361,7 +3362,7 @@ capture_loop_dispatch(loop_data *ld,
if (inpkts < 0) {
ws_debug("%s: src %u pipe reached EOF or err, rcv: %u drop: %u flush: %u",
G_STRFUNC, pcap_src->interface_id, pcap_src->received, pcap_src->dropped, pcap_src->flushed);
g_assert(pcap_src->cap_pipe_err != PIPOK);
ws_assert(pcap_src->cap_pipe_err != PIPOK);
}
}
}
@ -4346,7 +4347,7 @@ capture_loop_start(capture_options *capture_opts, gboolean *stats_known, struct
interface_opts = &g_array_index(capture_opts->ifaces, interface_options, i);
received = pcap_src->received;
if (pcap_src->pcap_h != NULL) {
g_assert(!pcap_src->from_cap_pipe);
ws_assert(!pcap_src->from_cap_pipe);
/* Get the capture statistics, so we know how many packets were dropped. */
if (pcap_stats(pcap_src->pcap_h, stats) >= 0) {
*stats_known = TRUE;
@ -4511,7 +4512,7 @@ capture_loop_write_pcapng_cb(capture_src *pcap_src, const pcapng_block_header_t
/*
* This should never be called if we're not writing pcapng.
*/
g_assert(global_capture_opts.use_pcapng);
ws_assert(global_capture_opts.use_pcapng);
/* We may be called multiple times from pcap_dispatch(); if we've set
the "stop capturing" flag, ignore this packet, as we're not
@ -4523,7 +4524,7 @@ capture_loop_write_pcapng_cb(capture_src *pcap_src, const pcapng_block_header_t
if (!pcapng_adjust_block(pcap_src, bh, pd)) {
ws_info("%s failed to adjust pcapng block.", G_STRFUNC);
g_assert_not_reached();
ws_assert_not_reached();
return;
}

7
editcap.c
View File

@ -83,6 +83,7 @@
#include <version_info.h>
#include <wsutil/pint.h>
#include <wsutil/strtoi.h>
#include <wsutil/ws_assert.h>
#include <wiretap/wtap_opttypes.h>
#include "ui/failure_message.h"
@ -1731,7 +1732,7 @@ main(int argc, char *argv[])
} else {
filename = g_strdup(argv[optind+1]);
}
g_assert(filename);
ws_assert(filename);
/* If we don't have an application name add one */
if (wtap_block_get_string_option_value(g_array_index(params.shb_hdrs, wtap_block_t, 0), OPT_SHB_USERAPPL, &shb_user_appl) != WTAP_OPTTYPE_SUCCESS) {
@ -1785,7 +1786,7 @@ main(int argc, char *argv[])
nstime_add(&block_next, &secs_per_block); /* reset for next interval */
g_free(filename);
filename = fileset_get_filename_by_pattern(block_cnt++, rec, fprefix, fsuffix);
g_assert(filename);
ws_assert(filename);
if (verbose)
fprintf(stderr, "Continuing writing in file %s\n", filename);
@ -1817,7 +1818,7 @@ main(int argc, char *argv[])
g_free(filename);
filename = fileset_get_filename_by_pattern(block_cnt++, rec, fprefix, fsuffix);
g_assert(filename);
ws_assert(filename);
if (verbose)
fprintf(stderr, "Continuing writing in file %s\n", filename);

3
epan/addr_and_mask.c
View File

@ -17,6 +17,7 @@
#include "tvbuff.h"
#include "ipv6.h"
#include "addr_and_mask.h"
#include <wsutil/ws_assert.h>
guint32
ip_get_subnet_mask(const guint32 mask_length)
@ -33,7 +34,7 @@ ip_get_subnet_mask(const guint32 mask_length)
0xfffffff8, 0xfffffffc, 0xfffffffe, 0xffffffff,
};
g_assert(mask_length <= 32);
ws_assert(mask_length <= 32);
return masks[mask_length];
}

31
epan/addr_resolv.c
View File

@ -21,6 +21,7 @@
#include <errno.h>
#include <wsutil/strtoi.h>
#include <wsutil/ws_assert.h>
/*
* Win32 doesn't have SIGALRM (and it's the OS where name lookup calls
@ -818,7 +819,7 @@ static void
initialize_services(void)
{
gboolean parse_file = TRUE;
g_assert(serv_port_hashtable == NULL);
ws_assert(serv_port_hashtable == NULL);
serv_port_hashtable = wmem_map_new(wmem_epan_scope(), g_direct_hash, g_direct_equal);
/* Compute the pathname of the services file. */
@ -906,7 +907,7 @@ parse_enterprises_file(const char * path)
static void
initialize_enterprises(void)
{
g_assert(enterprises_hashtable == NULL);
ws_assert(enterprises_hashtable == NULL);
enterprises_hashtable = g_hash_table_new_full(NULL, NULL, NULL, g_free);
if (g_enterprises_path == NULL) {
@ -957,10 +958,10 @@ enterprises_base_custom(char *buf, guint32 value)
static void
enterprises_cleanup(void)
{
g_assert(enterprises_hashtable);
ws_assert(enterprises_hashtable);
g_hash_table_destroy(enterprises_hashtable);
enterprises_hashtable = NULL;
g_assert(g_enterprises_path);
ws_assert(g_enterprises_path);
g_free(g_enterprises_path);
g_enterprises_path = NULL;
g_free(g_penterprises_path);
@ -1870,7 +1871,7 @@ eth_addr_resolve(hashether_t *tp) {
tp->status = HASHETHER_STATUS_RESOLVED_DUMMY;
return tp;
}
g_assert_not_reached();
ws_assert_not_reached();
} /* eth_addr_resolve */
static hashether_t *
@ -2208,7 +2209,7 @@ get_vlannamebyid(guint16 id)
static void
initialize_vlans(void)
{
g_assert(vlan_hash_table == NULL);
ws_assert(vlan_hash_table == NULL);
vlan_hash_table = wmem_map_new(wmem_epan_scope(), g_direct_hash, g_direct_equal);
/* Set g_pvlan_path here, but don't actually do anything
@ -2534,7 +2535,7 @@ subnet_lookup(const guint32 addr)
/* Note that we run from 31 (length 32) to 0 (length 1) */
--i;
g_assert(i < SUBNETLENGTHSIZE);
ws_assert(i < SUBNETLENGTHSIZE);
length_entry = &subnet_length_entries[i];
@ -2578,7 +2579,7 @@ subnet_entry_set(guint32 subnet_addr, const guint8 mask_length, const gchar* nam
sub_net_hashipv4_t * tp;
gsize hash_idx;
g_assert(mask_length > 0 && mask_length <= 32);
ws_assert(mask_length > 0 && mask_length <= 32);
entry = &subnet_length_entries[mask_length - 1];
@ -2779,7 +2780,7 @@ ss7pc_name_lookup_init(void)
{
char *ss7pcspath;
g_assert(ss7pc_hash_table == NULL);
ws_assert(ss7pc_hash_table == NULL);
ss7pc_hash_table = wmem_map_new(wmem_epan_scope(), g_direct_hash, g_direct_equal);
@ -3100,16 +3101,16 @@ host_name_lookup_init(void)
char *hostspath;
guint i;
g_assert(ipxnet_hash_table == NULL);
ws_assert(ipxnet_hash_table == NULL);
ipxnet_hash_table = wmem_map_new(wmem_epan_scope(), g_direct_hash, g_direct_equal);
g_assert(ipv4_hash_table == NULL);
ws_assert(ipv4_hash_table == NULL);
ipv4_hash_table = wmem_map_new(wmem_epan_scope(), g_direct_hash, g_direct_equal);
g_assert(ipv6_hash_table == NULL);
ws_assert(ipv6_hash_table == NULL);
ipv6_hash_table = wmem_map_new(wmem_epan_scope(), ipv6_oat_hash, ipv6_equal);
g_assert(async_dns_queue_head == NULL);
ws_assert(async_dns_queue_head == NULL);
async_dns_queue_head = wmem_list_new(wmem_epan_scope());
if (manually_resolved_ipv4_list == NULL)
@ -3266,7 +3267,7 @@ port_with_resolution_to_str(wmem_allocator_t *scope, port_type proto, guint port
return wmem_strdup_printf(scope, "%u", port);
}
port_str = serv_name_lookup(proto, port);
g_assert(port_str);
ws_assert(port_str);
return wmem_strdup_printf(scope, "%s (%u)", port_str, port);
}
@ -3280,7 +3281,7 @@ port_with_resolution_to_str_buf(gchar *buf, gulong buf_size, port_type proto, gu
return g_snprintf(buf, buf_size, "%u", port);
}
port_str = serv_name_lookup(proto, port);
g_assert(port_str);
ws_assert(port_str);
return g_snprintf(buf, buf_size, "%s (%u)", port_str, port);
}

19
epan/address.h
View File

@ -16,6 +16,7 @@
#include "tvbuff.h"
#include "wmem/wmem.h"
#include <wsutil/ws_assert.h>
#ifdef __cplusplus
extern "C" {
@ -78,12 +79,12 @@ static inline void
set_address(address *addr, int addr_type, int addr_len, const void *addr_data) {
if (addr_len == 0) {
/* Zero length must mean no data */
g_assert(addr_data == NULL);
ws_assert(addr_data == NULL);
} else {
/* Must not be AT_NONE - AT_NONE must have no data */
g_assert(addr_type != AT_NONE);
ws_assert(addr_type != AT_NONE);
/* Make sure we *do* have data */
g_assert(addr_data != NULL);
ws_assert(addr_data != NULL);
}
addr->type = addr_type;
addr->len = addr_len;
@ -112,7 +113,7 @@ set_address_tvb(address *addr, int addr_type, int addr_len, tvbuff_t *tvb, int o
if (addr_len != 0) {
/* Must not be AT_NONE - AT_NONE must have no data */
g_assert(addr_type != AT_NONE);
ws_assert(addr_type != AT_NONE);
p = tvb_get_ptr(tvb, offset, addr_len);
} else
p = NULL;
@ -132,19 +133,19 @@ set_address_tvb(address *addr, int addr_type, int addr_len, tvbuff_t *tvb, int o
static inline void
alloc_address_wmem(wmem_allocator_t *scope, address *addr,
int addr_type, int addr_len, const void *addr_data) {
g_assert(addr);
ws_assert(addr);
clear_address(addr);
addr->type = addr_type;
if (addr_len == 0) {
/* Zero length must mean no data */
g_assert(addr_data == NULL);
ws_assert(addr_data == NULL);
/* Nothing to copy */
return;
}
/* Must not be AT_NONE - AT_NONE must have no data */
g_assert(addr_type != AT_NONE);
ws_assert(addr_type != AT_NONE);
/* Make sure we *do* have data to copy */
g_assert(addr_data != NULL);
ws_assert(addr_data != NULL);
addr->data = addr->priv = wmem_memdup(scope, addr_data, addr_len);
addr->len = addr_len;
}
@ -287,7 +288,7 @@ free_address_wmem(wmem_allocator_t *scope, address *addr) {
if (addr->type != AT_NONE && addr->len > 0 && addr->priv != NULL) {
/* Make sure API use is correct */
/* if priv is not null then data == priv */
g_assert(addr->data == addr->priv);
ws_assert(addr->data == addr->priv);
wmem_free(scope, addr->priv);
}
clear_address(addr);

35
epan/address_types.c
View File

@ -18,6 +18,7 @@
#include "wsutil/pint.h"
#include "wsutil/str_util.h"
#include "wsutil/inet_addr.h"
#include <wsutil/ws_assert.h>
struct _address_type_t {
int addr_type; /* From address_type enumeration or registered value */
@ -54,18 +55,18 @@ static address_type_t* type_list[MAX_ADDR_TYPE_VALUE + 1];
static void address_type_register(int addr_type, address_type_t *at)
{
/* Check input */
g_assert(addr_type < MAX_ADDR_TYPE_VALUE);
g_assert(addr_type == at->addr_type);
ws_assert(addr_type < MAX_ADDR_TYPE_VALUE);
ws_assert(addr_type == at->addr_type);
/* Don't re-register. */
g_assert(type_list[addr_type] == NULL);
ws_assert(type_list[addr_type] == NULL);
/* Sanity check */
g_assert(at->name);
g_assert(at->pretty_name);
g_assert(at->addr_to_str);
g_assert(at->addr_str_len);
g_assert(((at->addr_name_res_str != NULL) && (at->addr_name_res_len != NULL)) ||
ws_assert(at->name);
ws_assert(at->pretty_name);
ws_assert(at->addr_to_str);
ws_assert(at->addr_str_len);
ws_assert(((at->addr_name_res_str != NULL) && (at->addr_name_res_len != NULL)) ||
((at->addr_name_res_str == NULL) && (at->addr_name_res_len == NULL)));
type_list[addr_type] = at;
@ -79,16 +80,16 @@ int address_type_dissector_register(const char* name, const char* pretty_name,
int addr_type;
/* Ensure valid data/functions for required fields */
g_assert(name);
g_assert(pretty_name);
g_assert(to_str_func);
g_assert(str_len_func);
ws_assert(name);
ws_assert(pretty_name);
ws_assert(to_str_func);
ws_assert(str_len_func);
/* Either have both or neither */
g_assert(((name_res_str_func != NULL) && (name_res_len_func != NULL)) ||
ws_assert(((name_res_str_func != NULL) && (name_res_len_func != NULL)) ||
((name_res_str_func == NULL) && (name_res_len_func == NULL)));
/* This shouldn't happen, so flag it for fixing */
g_assert(num_dissector_addr_type < MAX_DISSECTOR_ADDR_TYPE);
ws_assert(num_dissector_addr_type < MAX_DISSECTOR_ADDR_TYPE);
addr_type = AT_END_OF_LIST+num_dissector_addr_type;
dissector_type_addresses[num_dissector_addr_type].addr_type = addr_type;
@ -699,7 +700,7 @@ void address_types_initialize(void)
/* Given an address type id, return an address_type_t* */
#define ADDR_TYPE_LOOKUP(addr_type, result) \
/* Check input */ \
g_assert(addr_type < MAX_ADDR_TYPE_VALUE); \
ws_assert(addr_type < MAX_ADDR_TYPE_VALUE); \
result = type_list[addr_type];
static int address_type_get_length(const address* addr)
@ -938,7 +939,7 @@ tvb_address_to_str(wmem_allocator_t *scope, tvbuff_t *tvb, int type, const gint
/* For variable length fields, use tvb_address_var_to_str() */
if (at->addr_fixed_len == NULL)
{
g_assert_not_reached();
ws_assert_not_reached();
return NULL;
}
@ -973,7 +974,7 @@ tvb_address_with_resolution_to_str(wmem_allocator_t *scope, tvbuff_t *tvb, int t
/* For variable length fields, use tvb_address_var_with_resolution_to_str() */
if (at->addr_fixed_len == NULL)
{
g_assert_not_reached();
ws_assert_not_reached();
return NULL;
}

5
epan/capture_dissectors.c
View File

@ -17,6 +17,7 @@
#include "packet.h"
#include "capture_dissectors.h"
#include <wsutil/ws_assert.h>
#include <wsutil/wslog.h>
@ -107,7 +108,7 @@ capture_dissector_handle_t register_capture_dissector(const char *name, capture_
capture_dissector_handle_t handle;
/* Make sure the registration is unique */
g_assert(g_hash_table_lookup(registered_dissectors, name) == NULL);
ws_assert(g_hash_table_lookup(registered_dissectors, name) == NULL);
handle = new_capture_dissector_handle(dissector, proto, name);
g_hash_table_insert(registered_dissectors, (gpointer)name, handle);
@ -131,7 +132,7 @@ void capture_dissector_add_uint(const char *name, const guint32 pattern, capture
}
/* Make sure the registration is unique */
g_assert(g_hash_table_lookup(sub_dissectors->hash_table, GUINT_TO_POINTER(pattern)) == NULL);
ws_assert(g_hash_table_lookup(sub_dissectors->hash_table, GUINT_TO_POINTER(pattern)) == NULL);
g_hash_table_insert(sub_dissectors->hash_table, GUINT_TO_POINTER(pattern), (gpointer) handle);
}

11
epan/color_filters.c
View File

@ -23,6 +23,7 @@
#include <wsutil/filesystem.h>
#include <wsutil/file_util.h>
#include <wsutil/wslog.h>
#include <wsutil/ws_assert.h>
#include <epan/packet.h>
#include "color_filters.h"
@ -84,8 +85,8 @@ color_filters_add_tmp(GSList **cfl)
color_t bg_color, fg_color;
color_filter_t *colorf;
g_assert(strlen(prefs.gui_colorized_fg)==69);
g_assert(strlen(prefs.gui_colorized_bg)==69);
ws_assert(strlen(prefs.gui_colorized_fg)==69);
ws_assert(strlen(prefs.gui_colorized_bg)==69);
fg_colors = g_strsplit(prefs.gui_colorized_fg, ",", -1);
bg_colors = g_strsplit(prefs.gui_colorized_bg, ",", -1);
@ -406,7 +407,7 @@ color_filter_compile_cb(gpointer filter_arg, gpointer err)
gchar **err_msg = (gchar**)err;
gchar *local_err_msg = NULL;
g_assert(colorf->c_colorfilter == NULL);
ws_assert(colorf->c_colorfilter == NULL);
/* If the filter is disabled it doesn't matter if it compiles or not. */
if (colorf->disabled) return;
@ -417,7 +418,7 @@ color_filter_compile_cb(gpointer filter_arg, gpointer err)
g_free(local_err_msg);
/* this filter was compilable before, so this should never happen */
/* except if the OK button of the parent window has been clicked */
/* so don't use g_assert_not_reached() but check the filters again */
/* so don't use ws_assert_not_reached() but check the filters again */
}
}
@ -428,7 +429,7 @@ color_filter_validate_cb(gpointer filter_arg, gpointer err)
gchar **err_msg = (gchar**)err;
gchar *local_err_msg;
g_assert(colorf->c_colorfilter == NULL);
ws_assert(colorf->c_colorfilter == NULL);
/* If the filter is disabled it doesn't matter if it compiles or not. */
if (colorf->disabled) return;

55
epan/column-utils.c
View File

@ -33,6 +33,7 @@
#include <epan/dfilter/dfilter.h>
#include <wsutil/utf8_entities.h>
#include <wsutil/ws_assert.h>
#ifdef HAVE_LUA
#include <epan/wslua/wslua.h>
@ -912,7 +913,7 @@ set_abs_ymd_time(const frame_data *fd, gchar *buf, char *decimal_point, gboolean
tsprecision = fd->tsprec;
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
switch (tsprecision) {
case WTAP_TSPREC_SEC:
@ -980,7 +981,7 @@ set_abs_ymd_time(const frame_data *fd, gchar *buf, char *decimal_point, gboolean
fd->abs_ts.nsecs);
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
} else {
buf[0] = '\0';
@ -1046,7 +1047,7 @@ set_abs_ydoy_time(const frame_data *fd, gchar *buf, char *decimal_point, gboolea
tsprecision = fd->tsprec;
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
switch (tsprecision) {
case WTAP_TSPREC_SEC:
@ -1108,7 +1109,7 @@ set_abs_ydoy_time(const frame_data *fd, gchar *buf, char *decimal_point, gboolea
fd->abs_ts.nsecs);
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
} else {
buf[0] = '\0';
@ -1163,7 +1164,7 @@ set_time_seconds(const frame_data *fd, const nstime_t *ts, gchar *buf)
tsprecision = fd->tsprec;
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
switch (tsprecision) {
case WTAP_TSPREC_SEC:
@ -1191,7 +1192,7 @@ set_time_seconds(const frame_data *fd, const nstime_t *ts, gchar *buf)
(gint64) ts->secs, ts->nsecs, TO_STR_TIME_RES_T_NSECS);
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
}
@ -1235,7 +1236,7 @@ set_time_hour_min_sec(const frame_data *fd, const nstime_t *ts, gchar *buf, char
tsprecision = fd->tsprec;
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
switch (tsprecision) {
case WTAP_TSPREC_SEC:
@ -1377,7 +1378,7 @@ set_time_hour_min_sec(const frame_data *fd, const nstime_t *ts, gchar *buf, char
}
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
}
@ -1405,7 +1406,7 @@ col_set_rel_time(const frame_data *fd, column_info *cinfo, const int col)
set_time_seconds(fd, &del_rel_ts, cinfo->col_expr.col_expr_val[col]);
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
cinfo->columns[col].col_data = cinfo->columns[col].col_buf;
}
@ -1429,7 +1430,7 @@ col_set_delta_time(const frame_data *fd, column_info *cinfo, const int col)
set_time_seconds(fd, &del_cap_ts, cinfo->col_expr.col_expr_val[col]);
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
cinfo->columns[col].col_data = cinfo->columns[col].col_buf;
@ -1459,7 +1460,7 @@ col_set_delta_time_dis(const frame_data *fd, column_info *cinfo, const int col)
set_time_seconds(fd, &del_dis_ts, cinfo->col_expr.col_expr_val[col]);
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
cinfo->columns[col].col_data = cinfo->columns[col].col_buf;
@ -1504,7 +1505,7 @@ set_abs_time(const frame_data *fd, gchar *buf, char *decimal_point, gboolean loc
tsprecision = fd->tsprec;
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
switch (tsprecision) {
case WTAP_TSPREC_SEC:
@ -1554,7 +1555,7 @@ set_abs_time(const frame_data *fd, gchar *buf, char *decimal_point, gboolean loc
fd->abs_ts.nsecs);
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
} else {
@ -1614,7 +1615,7 @@ set_epoch_time(const frame_data *fd, gchar *buf)
tsprecision = fd->tsprec;
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
switch (tsprecision) {
case WTAP_TSPREC_SEC:
@ -1642,7 +1643,7 @@ set_epoch_time(const frame_data *fd, gchar *buf)
fd->abs_ts.secs, fd->abs_ts.nsecs, TO_STR_TIME_RES_T_NSECS);
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
return TRUE;
}
@ -1688,7 +1689,7 @@ set_fd_time(const epan_t *epan, frame_data *fd, gchar *buf)
set_time_seconds(fd, &del_rel_ts, buf);
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
} else {
buf[0] = '\0';
@ -1709,7 +1710,7 @@ set_fd_time(const epan_t *epan, frame_data *fd, gchar *buf)
set_time_hour_min_sec(fd, &del_cap_ts, buf, col_decimal_point);
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
} else {
buf[0] = '\0';
@ -1730,7 +1731,7 @@ set_fd_time(const epan_t *epan, frame_data *fd, gchar *buf)
set_time_hour_min_sec(fd, &del_dis_ts, buf, col_decimal_point);
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
} else {
buf[0] = '\0';
@ -1755,7 +1756,7 @@ set_fd_time(const epan_t *epan, frame_data *fd, gchar *buf)
case TS_NOT_SET:
/* code is missing for this case, but I don't know which [jmayer20051219] */
g_assert_not_reached();
ws_assert_not_reached();
break;
}
}
@ -1806,7 +1807,7 @@ col_set_cls_time(const frame_data *fd, column_info *cinfo, const gint col)
case TS_NOT_SET:
/* code is missing for this case, but I don't know which [jmayer20051219] */
g_assert_not_reached();
ws_assert_not_reached();
break;
}
}
@ -1859,7 +1860,7 @@ col_set_fmt_time(const frame_data *fd, column_info *cinfo, const gint fmt, const
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
break;
}
}
@ -1918,7 +1919,7 @@ col_set_time(column_info *cinfo, const gint el, const nstime_t *ts, const char *
(gint64) ts->secs, ts->nsecs, TO_STR_TIME_RES_T_NSECS);
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
col_item->col_data = col_item->col_buf;
cinfo->col_expr.col_expr[col] = fieldname;
@ -2049,8 +2050,8 @@ 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)
{
g_assert(cinfo);
g_assert(col < cinfo->num_cols);
ws_assert(cinfo);
ws_assert(col < cinfo->num_cols);
switch (cinfo->columns[col].col_fmt) {
case COL_NUMBER:
@ -2236,11 +2237,11 @@ col_fill_in(packet_info *pinfo, const gboolean fill_col_exprs, const gboolean fi
break;
case NUM_COL_FMTS: /* keep compiler happy - shouldn't get here */
g_assert_not_reached();
ws_assert_not_reached();
break;
default:
if (col_item->col_fmt >= NUM_COL_FMTS) {
g_assert_not_reached();
ws_assert_not_reached();
}
/*
* Formatting handled by col_custom_set_edt() (COL_CUSTOM), expert.c
@ -2276,7 +2277,7 @@ col_fill_in_error(column_info *cinfo, frame_data *fdata, const gboolean fill_col
col_item->col_data = "Read error";
} else {
if (col_item->col_fmt >= NUM_COL_FMTS) {
g_assert_not_reached();
ws_assert_not_reached();
}
/*
* No dissection was done, and these columns are set as the

15
epan/column.c
View File

@ -23,6 +23,7 @@
#include <epan/dfilter/dfilter.h>
#include <epan/column.h>
#include <epan/packet.h>
#include <wsutil/ws_assert.h>
/* Given a format number (as defined in column-utils.h), returns its equivalent
string */
@ -171,7 +172,7 @@ col_format_desc(const gint fmt_num) {
};
const gchar *val_str = try_val_to_str(fmt_num, dlist_vals);
g_assert(val_str != NULL);
ws_assert(val_str != NULL);
return val_str;
}
@ -294,7 +295,7 @@ get_timestamp_column_longest_string(const gint type, const gint precision)
return "0000-00-00 00:00:00.000000000";
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
break;
case(TS_ABSOLUTE_WITH_YDOY):
@ -320,7 +321,7 @@ get_timestamp_column_longest_string(const gint type, const gint precision)
return "0000/000 00:00:00.000000000";
break;
default:
g_assert_not_reached();
ws_assert_not_reached();
}
break;
case(TS_ABSOLUTE):