static void
wmem_test_allocator_jumbo(wmem_allocator_type_t type, wmem_verify_func verify)
{
wmem_allocator_t *allocator;
char *ptr, *ptr1;
allocator = wmem_allocator_force_new(type);
ptr = (char*)wmem_alloc0(allocator, 4*1024*1024);
wmem_free(allocator, ptr);
wmem_gc(allocator);
ptr = (char*)wmem_alloc0(allocator, 4*1024*1024);
if (verify) (*verify)(allocator);
wmem_free(allocator, ptr);
wmem_gc(allocator);
if (verify) (*verify)(allocator);
ptr = (char *)wmem_alloc0(allocator, 10*1024*1024);
ptr1 = (char *)wmem_alloc0(allocator, 13*1024*1024);
ptr1 = (char *)wmem_realloc(allocator, ptr1, 10*1024*1024);
memset(ptr1, 0, 10*1024*1024);
ptr = (char *)wmem_realloc(allocator, ptr, 13*1024*1024);
memset(ptr, 0, 13*1024*1024);
if (verify) (*verify)(allocator);
wmem_gc(allocator);
if (verify) (*verify)(allocator);
wmem_free(allocator, ptr1);
if (verify) (*verify)(allocator);
wmem_free_all(allocator);
wmem_gc(allocator);
if (verify) (*verify)(allocator);
wmem_destroy_allocator(allocator);
}
char *get_hostlist_filter(hostlist_talker_t *host)
{
char *sport, *src_addr;
char *str;
sport = ct_port_to_str(host->ptype, host->port);
src_addr = address_to_str(NULL, &host->myaddress);
if (host->myaddress.type == AT_STRINGZ || host->myaddress.type == AT_USB) {
char *new_addr;
new_addr = wmem_strdup_printf(NULL, "\"%s\"", src_addr);
wmem_free(NULL, src_addr);
src_addr = new_addr;
}
str = g_strdup_printf("%s==%s%s%s%s%s",
hostlist_get_filter_name(host, CONV_FT_ANY_ADDRESS),
src_addr,
sport?" && ":"",
sport?hostlist_get_filter_name(host, CONV_FT_ANY_PORT):"",
sport?"==":"",
sport?sport:"");
g_free(sport);
wmem_free(NULL, src_addr);
return str;
}
static void
wmem_block_fast_free_all(void *private_data)
{
wmem_block_fast_allocator_t *allocator = (wmem_block_fast_allocator_t*) private_data;
wmem_block_fast_hdr_t *cur, *nxt;
wmem_block_fast_jumbo_t *cur_jum, *nxt_jum;
/* iterate through the blocks, freeing all but the first and reinitializing
* that one */
cur = allocator->block_list;
if (cur) {
cur->pos = WMEM_BLOCK_HEADER_SIZE;
nxt = cur->next;
cur->next = NULL;
cur = nxt;
}
while (cur) {
nxt = cur->next;
wmem_free(NULL, cur);
cur = nxt;
}
/* now do the jumbo blocks, freeing all of them */
cur_jum = allocator->jumbo_list;
while (cur_jum) {
nxt_jum = cur_jum->next;
wmem_free(NULL, cur_jum);
cur_jum = nxt_jum;
}
allocator->jumbo_list = NULL;
}
static void
wmem_strict_block_free(wmem_strict_allocator_block_t *block)
{
memset(block->real_data, WMEM_POSTFILL, block->data_len);
wmem_free(NULL, block->leading_canary);
wmem_free(NULL, block);
}
static void
rtd_draw(void *arg)
{
rtd_data_t* rtd_data = (rtd_data_t*)arg;
rtd_t* rtd = (rtd_t*)rtd_data->user_data;
gchar* tmp_str;
guint i, j;
/* printing results */
printf("\n");
printf("=====================================================================================================\n");
printf("%s Response Time Delay (RTD) Statistics:\n", rtd->type);
printf("Filter for statistics: %s\n", rtd->filter ? rtd->filter : "");
if (rtd_data->stat_table.num_rtds == 1)
{
printf("Duplicate requests: %u\n", rtd_data->stat_table.time_stats[0].req_dup_num);
printf("Duplicate responses: %u\n", rtd_data->stat_table.time_stats[0].rsp_dup_num);
printf("Open requests: %u\n", rtd_data->stat_table.time_stats[0].open_req_num);
printf("Discarded responses: %u\n", rtd_data->stat_table.time_stats[0].disc_rsp_num);
printf("Type | Messages | Min RTD | Max RTD | Avg RTD | Min in Frame | Max in Frame |\n");
for (i=0; i<rtd_data->stat_table.time_stats[0].num_timestat; i++) {
if (rtd_data->stat_table.time_stats[0].rtd[i].num) {
tmp_str = val_to_str_wmem(NULL, i, rtd->vs_type, "Other (%d)");
printf("%s | %7u | %8.2f msec | %8.2f msec | %8.2f msec | %10u | %10u |\n",
tmp_str, rtd_data->stat_table.time_stats[0].rtd[i].num,
nstime_to_msec(&(rtd_data->stat_table.time_stats[0].rtd[i].min)), nstime_to_msec(&(rtd_data->stat_table.time_stats[0].rtd[i].max)),
get_average(&(rtd_data->stat_table.time_stats[0].rtd[i].tot), rtd_data->stat_table.time_stats[0].rtd[i].num),
rtd_data->stat_table.time_stats[0].rtd[i].min_num, rtd_data->stat_table.time_stats[0].rtd[i].max_num
);
wmem_free(NULL, tmp_str);
}
}
}
else
{
printf("Type | Messages | Min RTD | Max RTD | Avg RTD | Min in Frame | Max in Frame | Open Requests | Discarded responses | Duplicate requests | Duplicate responses\n");
for (i=0; i<rtd_data->stat_table.num_rtds; i++) {
for (j=0; j<rtd_data->stat_table.time_stats[i].num_timestat; j++) {
if (rtd_data->stat_table.time_stats[i].rtd[j].num) {
tmp_str = val_to_str_wmem(NULL, i, rtd->vs_type, "Other (%d)");
printf("%s | %7u | %8.2f msec | %8.2f msec | %8.2f msec | %10u | %10u | %10u | %10u | %4u (%4.2f%%) | %4u (%4.2f%%) |\n",
tmp_str, rtd_data->stat_table.time_stats[i].rtd[j].num,
nstime_to_msec(&(rtd_data->stat_table.time_stats[i].rtd[j].min)), nstime_to_msec(&(rtd_data->stat_table.time_stats[i].rtd[j].max)),
get_average(&(rtd_data->stat_table.time_stats[i].rtd[j].tot), rtd_data->stat_table.time_stats[i].rtd[j].num),
rtd_data->stat_table.time_stats[i].rtd[j].min_num, rtd_data->stat_table.time_stats[i].rtd[j].max_num,
rtd_data->stat_table.time_stats[i].open_req_num, rtd_data->stat_table.time_stats[i].disc_rsp_num,
rtd_data->stat_table.time_stats[i].req_dup_num,
rtd_data->stat_table.time_stats[i].rtd[j].num?((double)rtd_data->stat_table.time_stats[i].req_dup_num*100)/(double)rtd_data->stat_table.time_stats[i].rtd[j].num:0,
rtd_data->stat_table.time_stats[i].rsp_dup_num,
rtd_data->stat_table.time_stats[i].rtd[j].num?((double)rtd_data->stat_table.time_stats[i].rsp_dup_num*100)/(double)rtd_data->stat_table.time_stats[i].rtd[j].num:0
);
wmem_free(NULL, tmp_str);
}
}
}
}
printf("=====================================================================================================\n");
}
static gboolean
ipv6_from_unparsed(fvalue_t *fv, const char *s, gboolean allow_partial_value _U_, gchar **err_msg)
{
const char *slash;
const char *addr_str;
char *addr_str_to_free = NULL;
unsigned int nmask_bits;
fvalue_t *nmask_fvalue;
/* Look for prefix: Is there a single slash in the string? */
slash = strchr(s, '/');
if (slash) {
/* Make a copy of the string up to but not including the
* slash; that's the address portion. */
addr_str_to_free = wmem_strndup(NULL, s, slash-s);
addr_str = addr_str_to_free;
}
else
addr_str = s;
if (!get_host_ipaddr6(addr_str, &(fv->value.ipv6.addr))) {
if (err_msg != NULL)
*err_msg = g_strdup_printf("\"%s\" is not a valid hostname or IPv6 address.", s);
if (addr_str_to_free)
wmem_free(NULL, addr_str_to_free);
return FALSE;
}
if (addr_str_to_free)
wmem_free(NULL, addr_str_to_free);
/* If prefix */
if (slash) {
/* XXX - this is inefficient */
nmask_fvalue = fvalue_from_unparsed(FT_UINT32, slash+1, FALSE, err_msg);
if (!nmask_fvalue) {
return FALSE;
}
nmask_bits = fvalue_get_uinteger(nmask_fvalue);
FVALUE_FREE(nmask_fvalue);
if (nmask_bits > 128) {
if (err_msg != NULL) {
*err_msg = g_strdup_printf("Prefix in a IPv6 address should be <= 128, not %u",
nmask_bits);
}
return FALSE;
}
fv->value.ipv6.prefix = nmask_bits;
} else {
/* Not CIDR; mask covers entire address. */
fv->value.ipv6.prefix = 128;
}
return TRUE;
}
static void
wmem_simple_allocator_cleanup(void *private_data)
{
wmem_simple_allocator_t *allocator;
allocator = (wmem_simple_allocator_t*) private_data;
wmem_free(NULL, allocator->ptrs);
wmem_free(NULL, allocator);
}
static void
wmem_block_fast_allocator_cleanup(void *private_data)
{
wmem_block_fast_allocator_t *allocator = (wmem_block_fast_allocator_t*) private_data;
/* wmem guarantees that free_all() is called directly before this, so
* simply free the first block */
wmem_free(NULL, allocator->block_list);
/* then just free the allocator structs */
wmem_free(NULL, private_data);
}
void oid_add_from_string(const char* name, const gchar *oid_str) {
guint32* subids;
guint oid_len = oid_string2subid(NULL, oid_str, &subids);
if (oid_len) {
gchar* sub = oid_subid2string(NULL, subids,oid_len);
D(3,("\tOid (from string): %s %s ",name?name:"NULL", sub));
add_oid(name,OID_KIND_UNKNOWN,NULL,NULL,oid_len,subids);
wmem_free(NULL, sub);
} else {
D(1,("Failed to add Oid: %s %s ",name?name:"NULL", oid_str?oid_str:NULL));
}
wmem_free(NULL, subids);
}
void
wmem_destroy_list(wmem_list_t *list)
{
wmem_list_frame_t *cur, *next;
cur = list->head;
while (cur) {
next = cur->next;
wmem_free(list->allocator, cur);
cur = next;
}
wmem_free(list->allocator, list);
}
static void
wmem_block_free_all(void *private_data)
{
wmem_block_allocator_t *allocator = (wmem_block_allocator_t*) private_data;
wmem_block_hdr_t *cur;
wmem_block_chunk_t *chunk;
/* the existing free lists are entirely irrelevant */
allocator->master_head = NULL;
allocator->recycler_head = NULL;
/* iterate through the blocks, reinitializing each one */
cur = allocator->block_list;
while (cur) {
chunk = WMEM_BLOCK_TO_CHUNK(cur);
if (chunk->jumbo) {
wmem_block_remove_from_block_list(allocator, cur);
cur = cur->next;
wmem_free(NULL, WMEM_CHUNK_TO_BLOCK(chunk));
}
else {
wmem_block_init_block(allocator, cur);
cur = cur->next;
}
}
}
/*
* Set the address 2 value in a key. Remove the original from
* table, update the options and port values, insert the updated key.
*/
void
conversation_set_addr2(conversation_t *conv, const address *addr)
{
char* addr_str;
DISSECTOR_ASSERT_HINT(!(conv->options & CONVERSATION_TEMPLATE),
"Use the conversation_create_from_template function when the CONVERSATION_TEMPLATE bit is set in the options mask");
addr_str = address_to_str(NULL, addr);
DPRINT(("called for addr=%s", addr_str));
wmem_free(NULL, addr_str);
/*
* If the address 2 value is not wildcarded, don't set it.
*/
if (!(conv->options & NO_ADDR2))
return;
DINDENT();
if (conv->options & NO_PORT2) {
conversation_remove_from_hashtable(conversation_hashtable_no_addr2_or_port2, conv);
} else {
conversation_remove_from_hashtable(conversation_hashtable_no_port2, conv);
}
conv->options &= ~NO_ADDR2;
copy_address_wmem(wmem_file_scope(), &conv->key_ptr->addr2, addr);
if (conv->options & NO_PORT2) {
conversation_insert_into_hashtable(conversation_hashtable_no_port2, conv);
} else {
conversation_insert_into_hashtable(conversation_hashtable_exact, conv);
}
DENDENT();
}
extern void oid_add_from_encoded(const char* name, const guint8 *oid, gint oid_len) {
guint32* subids = NULL;
guint subids_len = oid_encoded2subid(NULL, oid, oid_len, &subids);
if (subids_len) {
gchar* sub = oid_subid2string(NULL, subids,subids_len);
D(3,("\tOid (from encoded): %s %s ",name, sub));
add_oid(name,OID_KIND_UNKNOWN,NULL,NULL,subids_len,subids);
wmem_free(NULL, sub);
} else {
gchar* bytestr = bytestring_to_str(NULL, oid, oid_len, ':');
D(1,("Failed to add Oid: %s [%d]%s ",name?name:"NULL", oid_len, bytestr));
wmem_free(NULL, bytestr);
}
wmem_free(NULL, subids);
}
WSLUA_METAMETHOD NSTime__tostring(lua_State* L) {
NSTime nstime = checkNSTime(L,1);
gchar *str;
long secs = (long)nstime->secs;
gint nsecs = nstime->nsecs;
gboolean negative_zero = FALSE;
/* Time is defined as sec + nsec/10^9, both parts can be negative.
* Translate this into the more familiar sec.nsec notation instead. */
if (secs > 0 && nsecs < 0) {
/* sign mismatch: (2, -3ns) -> 1.7 */
nsecs += NS_PER_S;
secs--;
} else if (secs < 0 && nsecs > 0) {
/* sign mismatch: (-2, 3ns) -> -1.7 */
nsecs = NS_PER_S - nsecs;
secs--;
} else if (nsecs < 0) {
/* Drop sign, the integer part already has it: (-2, -3ns) -> -2.3 */
nsecs = -nsecs;
/* In case the integer part is zero, it does not has a sign, so remember
* that it must be explicitly added. */
negative_zero = secs == 0;
}
if (negative_zero) {
str = wmem_strdup_printf(NULL, "-0.%09d", nsecs);
} else {
str = wmem_strdup_printf(NULL, "%ld.%09d", secs, nsecs);
}
lua_pushstring(L, str);
wmem_free(NULL, str);
WSLUA_RETURN(1); /* The string representing the nstime. */
}
static void
tacplus_print_key_entry( gpointer data, gpointer user_data )
{
tacplus_key_entry *tacplus_data=(tacplus_key_entry *)data;
gchar *s_str, *c_str;
s_str = address_to_str( NULL, tacplus_data->s );
c_str = address_to_str( NULL, tacplus_data->c );
if( user_data ) {
printf("%s:%s=%s\n", s_str, c_str, tacplus_data->k );
} else {
printf("%s:%s\n", s_str, c_str );
}
wmem_free(NULL, s_str);
wmem_free(NULL, c_str);
}
void LBMStreamDialog::fillTree(void)
{
gchar * error_string;
if (m_capture_file == NULL)
{
return;
}
m_dialog_info->setDialog(this);
error_string = register_tap_listener("lbm_stream",
(void *)m_dialog_info,
m_ui->displayFilterLineEdit->text().toUtf8().constData(),
TL_REQUIRES_COLUMNS,
resetTap,
tapPacket,
drawTreeItems);
if (error_string)
{
QMessageBox::critical(this, tr("LBM Stream failed to attach to tap"),
error_string);
wmem_free(NULL, error_string);
reject();
}
cf_retap_packets(m_capture_file);
drawTreeItems(&m_dialog_info);
remove_tap_listener((void *)m_dialog_info);
}
/* WSLUA_ATTRIBUTE FieldInfo_label RO The string representing this field. */
WSLUA_METAMETHOD FieldInfo__tostring(lua_State* L) {
/* The string representation of the field. */
FieldInfo fi = checkFieldInfo(L,1);
if (fi->ws_fi->value.ftype->val_to_string_repr) {
gchar* repr = NULL;
if (fi->ws_fi->hfinfo->type == FT_PROTOCOL || fi->ws_fi->hfinfo->type == FT_PCRE) {
repr = fvalue_to_string_repr(NULL, &fi->ws_fi->value,FTREPR_DFILTER,BASE_NONE);
}
else {
repr = fvalue_to_string_repr(NULL, &fi->ws_fi->value,FTREPR_DISPLAY,fi->ws_fi->hfinfo->display);
}
if (repr) {
lua_pushstring(L,repr);
/* fvalue_to_string_repr() wmem_alloc's the string's buffer */
wmem_free(NULL, repr);
}
else {
lua_pushstring(L,"(unknown)");
}
}
else if (fi->ws_fi->hfinfo->type == FT_NONE) {
lua_pushstring(L, "(none)");
}
else {
lua_pushstring(L,"(n/a)");
}
return 1;
}
void packet_range_convert_str(packet_range_t *range, const gchar *es)
{
range_t *new_range;
convert_ret_t ret;
if (range->user_range != NULL)
wmem_free(NULL, range->user_range);
g_assert(range->cf != NULL);
ret = range_convert_str(NULL, &new_range, es, range->cf->count);
if (ret != CVT_NO_ERROR) {
/* range isn't valid */
range->user_range = NULL;
range->user_range_status = ret;
range->user_range_cnt = 0;
range->ignored_user_range_cnt = 0;
range->displayed_user_range_cnt = 0;
range->displayed_ignored_user_range_cnt = 0;
return;
}
range->user_range = new_range;
/* calculate new user specified packet range counts */
packet_range_calc_user(range);
} /* packet_range_convert_str */
gchar *
wmem_strdup_vprintf(wmem_allocator_t *allocator, const gchar *fmt, va_list ap)
{
va_list ap2;
gchar *dst;
int needed_len;
G_VA_COPY(ap2, ap);
/* needed_len = g_printf_string_upper_bound(fmt, ap2); */
dst = (gchar *)wmem_alloc(allocator, WMEM_STRDUP_VPRINTF_DEFAULT_BUFFER);
/* Returns: the number of characters which would be produced if the buffer was large enough
* (not including the null, for which we add +1 ourselves). */
needed_len = g_vsnprintf(dst, (gulong) WMEM_STRDUP_VPRINTF_DEFAULT_BUFFER, fmt, ap2) + 1;
va_end(ap2);
if (needed_len > WMEM_STRDUP_VPRINTF_DEFAULT_BUFFER) {
wmem_free(allocator, dst);
dst = (gchar *)wmem_alloc(allocator, needed_len);
G_VA_COPY(ap2, ap);
g_vsnprintf(dst, (gulong) needed_len, fmt, ap2);
va_end(ap2);
}
return dst;
}
void
wmem_call_callbacks(wmem_allocator_t *allocator, wmem_cb_event_t event)
{
wmem_user_cb_container_t **prev, *cur;
gboolean again;
prev = &(allocator->callbacks);
cur = allocator->callbacks;
while (cur) {
/* call it */
again = cur->cb(allocator, event, cur->user_data);
/* if the callback requested deregistration, or this is being triggered
* by the final destruction of the allocator, remove the callback */
if (! again || event == WMEM_CB_DESTROY_EVENT) {
*prev = cur->next;
wmem_free(NULL, cur);
cur = *prev;
}
else {
prev = &(cur->next);
cur = cur->next;
}
}
}
static void
remove_old_requests(ipmi_packet_data_t * data, const nstime_t * curr_time)
{
wmem_list_frame_t * iter = wmem_list_head(data->request_list);
while (iter) {
ipmi_request_t * rq = (ipmi_request_t *) wmem_list_frame_data(iter);
ipmi_frame_data_t * frame = get_frame_data(data, rq->frame_num);
nstime_t delta;
/* calculate time delta */
nstime_delta(&delta, curr_time, &frame->ts);
if (nstime_to_msec(&delta) > response_after_req) {
wmem_list_frame_t * del = iter;
/* proceed to next request */
iter = wmem_list_frame_next(iter);
/* free request data */
wmem_free(wmem_file_scope(), rq);
/* remove list item */
wmem_list_remove_frame(data->request_list, del);
} else {
break;
}
}
}
static void
wmem_test_allocator_det(wmem_allocator_t *allocator, wmem_verify_func verify,
guint len)
{
int i;
char *ptrs[MAX_SIMULTANEOUS_ALLOCS];
/* we use wmem_alloc0 in part because it tests slightly more code, but
* primarily so that if the allocator doesn't give us enough memory or
* gives us memory that includes its own metadata, we write to it and
* things go wrong, causing the tests to fail */
for (i=0; i<MAX_SIMULTANEOUS_ALLOCS; i++) {
ptrs[i] = (char *)wmem_alloc0(allocator, len);
}
for (i=MAX_SIMULTANEOUS_ALLOCS-1; i>=0; i--) {
/* no wmem_realloc0 so just use memset manually */
ptrs[i] = (char *)wmem_realloc(allocator, ptrs[i], 4*len);
memset(ptrs[i], 0, 4*len);
}
for (i=0; i<MAX_SIMULTANEOUS_ALLOCS; i++) {
wmem_free(allocator, ptrs[i]);
}
if (verify) (*verify)(allocator);
wmem_free_all(allocator);
wmem_gc(allocator);
if (verify) (*verify)(allocator);
}
void SequenceDialog::fillDiagram()
{
if (!sainfo_ || file_closed_) return;
QCustomPlot *sp = ui->sequencePlot;
if (sainfo_->type == SEQ_ANALYSIS_VOIP) {
seq_diagram_->setData(sainfo_);
} else {
seq_diagram_->clearData();
sequence_analysis_list_free(sainfo_);
sequence_analysis_list_get(cap_file_.capFile(), sainfo_);
num_items_ = sequence_analysis_get_nodes(sainfo_);
seq_diagram_->setData(sainfo_);
}
QFontMetrics vfm = QFontMetrics(sp->xAxis2->labelFont());
char* addr_str;
node_label_w_ = 0;
for (guint i = 0; i < sainfo_->num_nodes; i++) {
addr_str = (char*)address_to_display(NULL, &(sainfo_->nodes[i]));
int label_w = vfm.width(addr_str);
if (node_label_w_ < label_w) {
node_label_w_ = label_w;
}
wmem_free(NULL, addr_str);
}
node_label_w_ = (node_label_w_ * 3 / 4) + one_em_;
mouseMoved(NULL);
resetAxes();
// XXX QCustomPlot doesn't seem to draw any sort of focus indicator.
sp->setFocus();
}
static void
relative_val_to_repr(fvalue_t *fv, ftrepr_t rtype _U_, int field_display _U_, char *buf)
{
gchar *rep;
rep = rel_time_to_secs_str(NULL, &fv->value.time);
strcpy(buf, rep);
wmem_free(NULL, rep);
}
const QString val_ext_to_qstring(const guint32 val, value_string_ext *vse, const char *fmt)
{
QString val_qstr = QString();
gchar* gchar_p = val_to_str_ext_wmem(NULL, val, vse, fmt);
val_qstr = gchar_p;
wmem_free(NULL, gchar_p);
return val_qstr;
}
static oid_info_t* add_oid(const char* name, oid_kind_t kind, const oid_value_type_t* type, oid_key_t* key, guint oid_len, guint32 *subids) {
guint i = 0;
oid_info_t* c = &oid_root;
prepopulate_oids();
oid_len--;
do {
oid_info_t* n = (oid_info_t *)wmem_tree_lookup32(c->children,subids[i]);
if(n) {
if (i == oid_len) {
if (n->name) {
if (!g_str_equal(n->name,name)) {
D(2,("Renaming Oid from: %s -> %s, this means the same oid is registered more than once",n->name,name));
}
wmem_free(wmem_epan_scope(), n->name);
}
n->name = wmem_strdup(wmem_epan_scope(), name);
if (! n->value_type) {
n->value_type = type;
}
return n;
}
} else {
n = wmem_new(wmem_epan_scope(), oid_info_t);
n->subid = subids[i];
n->kind = kind;
n->children = wmem_tree_new(wmem_epan_scope());
n->value_hfid = -2;
n->key = key;
n->parent = c;
n->bits = NULL;
wmem_tree_insert32(c->children,n->subid,n);
if (i == oid_len) {
n->name = wmem_strdup(wmem_epan_scope(), name);
n->value_type = type;
n->kind = kind;
return n;
} else {
n->name = NULL;
n->value_type = NULL;
n->kind = OID_KIND_UNKNOWN;
}
}
c = n;
} while(++i);
g_assert_not_reached();
return NULL;
}
const QString address_to_display_qstring(const _address *address)
{
QString address_qstr = QString();
if (address) {
gchar *address_gchar_p = address_to_display(NULL, address);
address_qstr = address_gchar_p;
wmem_free(NULL, address_gchar_p);
}
return address_qstr;
}
const QString range_to_qstring(const epan_range *range)
{
QString range_qstr = QString();
if (range) {
gchar *range_gchar_p = range_convert_range(NULL, range);
range_qstr = range_gchar_p;
wmem_free(NULL, range_gchar_p);
}
return range_qstr;
}
static void
wmem_strict_allocator_cleanup(void *private_data)
{
wmem_strict_allocator_t *allocator;
allocator = (wmem_strict_allocator_t*) private_data;
g_hash_table_destroy(allocator->block_table);
wmem_free(NULL, allocator);
}
WSLUA_METAMETHOD NSTime__tostring(lua_State* L) {
NSTime nstime = checkNSTime(L,1);
gchar *str;
str = wmem_strdup_printf(NULL, "%ld.%09d", (long)nstime->secs, nstime->nsecs);
lua_pushstring(L, str);
wmem_free(NULL, str);
WSLUA_RETURN(1); /* The string representing the nstime. */
}
