stats_tree_get_displayname@Base 1.12.0~rc1
stats_tree_get_values_from_node@Base 1.12.0~rc1
stats_tree_is_default_sort_DESC@Base 1.12.0~rc1
- stats_tree_manip_node@Base 1.9.1
+ stats_tree_manip_node_float@Base 2.9.0
+ stats_tree_manip_node_int@Base 2.9.0
stats_tree_new@Base 1.9.1
stats_tree_node_to_str@Base 1.9.1
stats_tree_packet@Base 1.9.1
static void
ancp_stats_tree_init(stats_tree *st)
{
- st_node_packets = stats_tree_create_node(st, st_str_packets, 0, TRUE);
+ st_node_packets = stats_tree_create_node(st, st_str_packets, 0, STAT_DT_INT, TRUE);
st_node_packet_types = stats_tree_create_pivot(st, st_str_packet_types,
st_node_packets);
st_node_adj_pack_types = stats_tree_create_node(st, st_str_adj_pack_types,
- st_node_packets, TRUE);
+ st_node_packets, STAT_DT_INT, TRUE);
}
static int
bacapp_packet_stats_tree_init(stats_tree* st)
{
st_node_packets_by_ip = stats_tree_create_pivot(st, st_str_packets_by_ip, 0);
- st_node_packets_by_ip_src = stats_tree_create_node(st, st_str_packets_by_ip_src, st_node_packets_by_ip, TRUE);
- st_node_packets_by_ip_dst = stats_tree_create_node(st, st_str_packets_by_ip_dst, st_node_packets_by_ip, TRUE);
+ st_node_packets_by_ip_src = stats_tree_create_node(st, st_str_packets_by_ip_src, st_node_packets_by_ip, STAT_DT_INT, TRUE);
+ st_node_packets_by_ip_dst = stats_tree_create_node(st, st_str_packets_by_ip_dst, st_node_packets_by_ip, STAT_DT_INT, TRUE);
}
static gchar *
static void
collectd_stats_tree_init (stats_tree *st)
{
- st_collectd_packets = stats_tree_create_node (st, "Packets", 0, FALSE);
- st_collectd_values = stats_tree_create_node (st, "Values", 0, TRUE);
+ st_collectd_packets = stats_tree_create_node (st, "Packets", 0, STAT_DT_INT, FALSE);
+ st_collectd_values = stats_tree_create_node (st, "Values", 0, STAT_DT_INT, TRUE);
st_collectd_values_hosts = stats_tree_create_pivot (st, "By host",
st_collectd_values);
static void dns_stats_tree_init(stats_tree* st)
{
- st_node_packets = stats_tree_create_node(st, st_str_packets, 0, TRUE);
+ st_node_packets = stats_tree_create_node(st, st_str_packets, 0, STAT_DT_INT, TRUE);
st_node_packet_qr = stats_tree_create_pivot(st, st_str_packet_qr, st_node_packets);
st_node_packet_qtypes = stats_tree_create_pivot(st, st_str_packet_qtypes, st_node_packets);
st_node_packet_qclasses = stats_tree_create_pivot(st, st_str_packet_qclasses, st_node_packets);
st_node_packet_rcodes = stats_tree_create_pivot(st, st_str_packet_rcodes, st_node_packets);
st_node_packet_opcodes = stats_tree_create_pivot(st, st_str_packet_opcodes, st_node_packets);
- st_node_packets_avg_size = stats_tree_create_node(st, st_str_packets_avg_size, 0, FALSE);
- st_node_query_stats = stats_tree_create_node(st, st_str_query_stats, 0, TRUE);
- st_node_query_qname_len = stats_tree_create_node(st, st_str_query_qname_len, st_node_query_stats, FALSE);
- st_node_query_domains = stats_tree_create_node(st, st_str_query_domains, st_node_query_stats, TRUE);
- st_node_query_domains_l1 = stats_tree_create_node(st, st_str_query_domains_l1, st_node_query_domains, FALSE);
- st_node_query_domains_l2 = stats_tree_create_node(st, st_str_query_domains_l2, st_node_query_domains, FALSE);
- st_node_query_domains_l3 = stats_tree_create_node(st, st_str_query_domains_l3, st_node_query_domains, FALSE);
- st_node_query_domains_lmore = stats_tree_create_node(st, st_str_query_domains_lmore, st_node_query_domains, FALSE);
- st_node_response_stats = stats_tree_create_node(st, st_str_response_stats, 0, TRUE);
+ st_node_packets_avg_size = stats_tree_create_node(st, st_str_packets_avg_size, 0, STAT_DT_INT, FALSE);
+ st_node_query_stats = stats_tree_create_node(st, st_str_query_stats, 0, STAT_DT_INT, TRUE);
+ st_node_query_qname_len = stats_tree_create_node(st, st_str_query_qname_len, st_node_query_stats, STAT_DT_INT, FALSE);
+ st_node_query_domains = stats_tree_create_node(st, st_str_query_domains, st_node_query_stats, STAT_DT_INT, TRUE);
+ st_node_query_domains_l1 = stats_tree_create_node(st, st_str_query_domains_l1, st_node_query_domains, STAT_DT_INT, FALSE);
+ st_node_query_domains_l2 = stats_tree_create_node(st, st_str_query_domains_l2, st_node_query_domains, STAT_DT_INT, FALSE);
+ st_node_query_domains_l3 = stats_tree_create_node(st, st_str_query_domains_l3, st_node_query_domains, STAT_DT_INT, FALSE);
+ st_node_query_domains_lmore = stats_tree_create_node(st, st_str_query_domains_lmore, st_node_query_domains, STAT_DT_INT, FALSE);
+ st_node_response_stats = stats_tree_create_node(st, st_str_response_stats, 0, STAT_DT_INT, TRUE);
st_node_response_nquestions = stats_tree_create_node(st, st_str_response_nquestions,
- st_node_response_stats, FALSE);
+ st_node_response_stats, STAT_DT_INT, FALSE);
st_node_response_nanswers = stats_tree_create_node(st, st_str_response_nanswers,
- st_node_response_stats, FALSE);
+ st_node_response_stats, STAT_DT_INT, FALSE);
st_node_response_nauthorities = stats_tree_create_node(st, st_str_response_nauthorities,
- st_node_response_stats, FALSE);
+ st_node_response_stats, STAT_DT_INT, FALSE);
st_node_response_nadditionals = stats_tree_create_node(st, st_str_response_nadditionals,
- st_node_response_stats, FALSE);
- st_node_service_stats = stats_tree_create_node(st, st_str_service_stats, 0, TRUE);
- st_node_service_unsolicited = stats_tree_create_node(st, st_str_service_unsolicited, st_node_service_stats, FALSE);
- st_node_service_retransmission = stats_tree_create_node(st, st_str_service_retransmission, st_node_service_stats, FALSE);
- st_node_service_rrt = stats_tree_create_node(st, st_str_service_rrt, st_node_service_stats, FALSE);
+ st_node_response_stats, STAT_DT_INT, FALSE);
+ st_node_service_stats = stats_tree_create_node(st, st_str_service_stats, 0, STAT_DT_INT, TRUE);
+ st_node_service_unsolicited = stats_tree_create_node(st, st_str_service_unsolicited, st_node_service_stats, STAT_DT_INT, FALSE);
+ st_node_service_retransmission = stats_tree_create_node(st, st_str_service_retransmission, st_node_service_stats, STAT_DT_INT, FALSE);
+ st_node_service_rrt = stats_tree_create_node(st, st_str_service_rrt, st_node_service_stats, STAT_DT_INT, FALSE);
}
static int dns_stats_tree_packet(stats_tree* st, packet_info* pinfo _U_, epan_dissect_t* edt _U_, const void* p)
val_to_str(pi->packet_rcode, rcode_vals, "Unknown rcode (%d)"));
stats_tree_tick_pivot(st, st_node_packet_opcodes,
val_to_str(pi->packet_opcode, opcode_vals, "Unknown opcode (%d)"));
- avg_stat_node_add_value(st, st_str_packets_avg_size, 0, FALSE,
+ avg_stat_node_add_value_int(st, st_str_packets_avg_size, 0, FALSE,
pi->payload_size);
/* split up stats for queries and responses */
if (pi->packet_qr == 0) {
- avg_stat_node_add_value(st, st_str_query_qname_len, 0, FALSE, pi->qname_len);
+ avg_stat_node_add_value_int(st, st_str_query_qname_len, 0, FALSE, pi->qname_len);
switch(pi->qname_labels) {
case 1:
tick_stat_node(st, st_str_query_domains_l1, 0, FALSE);
break;
}
} else {
- avg_stat_node_add_value(st, st_str_response_nquestions, 0, FALSE, pi->nquestions);
- avg_stat_node_add_value(st, st_str_response_nanswers, 0, FALSE, pi->nanswers);
- avg_stat_node_add_value(st, st_str_response_nauthorities, 0, FALSE, pi->nauthorities);
- avg_stat_node_add_value(st, st_str_response_nadditionals, 0, FALSE, pi->nadditionals);
+ avg_stat_node_add_value_int(st, st_str_response_nquestions, 0, FALSE, pi->nquestions);
+ avg_stat_node_add_value_int(st, st_str_response_nanswers, 0, FALSE, pi->nanswers);
+ avg_stat_node_add_value_int(st, st_str_response_nauthorities, 0, FALSE, pi->nauthorities);
+ avg_stat_node_add_value_int(st, st_str_response_nadditionals, 0, FALSE, pi->nadditionals);
if (pi->unsolicited) {
tick_stat_node(st, st_str_service_unsolicited, 0, FALSE);
} else {
- avg_stat_node_add_value(st, st_str_response_nquestions, 0, FALSE, pi->nquestions);
- avg_stat_node_add_value(st, st_str_response_nanswers, 0, FALSE, pi->nanswers);
- avg_stat_node_add_value(st, st_str_response_nauthorities, 0, FALSE, pi->nauthorities);
- avg_stat_node_add_value(st, st_str_response_nadditionals, 0, FALSE, pi->nadditionals);
+ avg_stat_node_add_value_int(st, st_str_response_nquestions, 0, FALSE, pi->nquestions);
+ avg_stat_node_add_value_int(st, st_str_response_nanswers, 0, FALSE, pi->nanswers);
+ avg_stat_node_add_value_int(st, st_str_response_nauthorities, 0, FALSE, pi->nauthorities);
+ avg_stat_node_add_value_int(st, st_str_response_nadditionals, 0, FALSE, pi->nadditionals);
if (pi->unsolicited) {
tick_stat_node(st, st_str_service_unsolicited, 0, FALSE);
} else {
if (pi->retransmission)
tick_stat_node(st, st_str_service_retransmission, 0, FALSE);
else
- avg_stat_node_add_value(st, st_str_service_rrt, 0, FALSE, (guint32)(pi->rrt.secs * 1000000 + pi->rrt.nsecs/1000));
+ avg_stat_node_add_value_int(st, st_str_service_rrt, 0, FALSE, (guint32)(pi->rrt.secs * 1000000 + pi->rrt.nsecs/1000));
}
}
}
static void f5eth_tmmdist_stats_tree_init(
stats_tree *st
) {
- st_node_tmmpktdist = stats_tree_create_node(st, st_str_tmmdist_pkts, 0, TRUE);
+ st_node_tmmpktdist = stats_tree_create_node(st, st_str_tmmdist_pkts, 0, STAT_DT_INT, TRUE);
stat_node_set_flags(st, st_str_tmmdist_pkts, 0, TRUE, ST_FLG_SORT_TOP);
- st_node_tmmbytedist = stats_tree_create_node(st, st_str_tmmdist_bytes, 0, TRUE);
+ st_node_tmmbytedist = stats_tree_create_node(st, st_str_tmmdist_bytes, 0, STAT_DT_INT, TRUE);
} /* f5eth_tmmdist_stats_tree_init() */
#define PER_TMM_STAT_NAME_BUF_LEN (sizeof("slot SSS,tmm TTT"))
static void f5eth_virtdist_stats_tree_init(
stats_tree *st
) {
- st_node_virtpktdist = stats_tree_create_node(st, st_str_virtdist_pkts, 0, TRUE);
+ st_node_virtpktdist = stats_tree_create_node(st, st_str_virtdist_pkts, 0, STAT_DT_INT, TRUE);
stat_node_set_flags(st, st_str_virtdist_pkts, 0, TRUE, ST_FLG_SORT_TOP);
- st_node_virtbytedist = stats_tree_create_node(st, st_str_virtdist_bytes, 0, TRUE);
+ st_node_virtbytedist = stats_tree_create_node(st, st_str_virtdist_bytes, 0, STAT_DT_INT, TRUE);
- stats_tree_create_node(st, st_str_virtdist_noflow, st_node_virtpktdist, TRUE);
+ stats_tree_create_node(st, st_str_virtdist_noflow, st_node_virtpktdist, STAT_DT_INT, TRUE);
stat_node_set_flags(st, st_str_virtdist_noflow, st_node_virtpktdist, TRUE, ST_FLG_SORT_TOP);
- stats_tree_create_node(st, st_str_virtdist_novirt, st_node_virtpktdist, TRUE);
+ stats_tree_create_node(st, st_str_virtdist_novirt, st_node_virtpktdist, STAT_DT_INT, TRUE);
stat_node_set_flags(st, st_str_virtdist_novirt, st_node_virtpktdist, TRUE, ST_FLG_SORT_TOP);
- stats_tree_create_node(st, st_str_virtdist_noflow, st_node_virtbytedist, TRUE);
+ stats_tree_create_node(st, st_str_virtdist_noflow, st_node_virtbytedist, STAT_DT_INT, TRUE);
stat_node_set_flags(st, st_str_virtdist_noflow, st_node_virtbytedist, TRUE, ST_FLG_SORT_TOP);
- stats_tree_create_node(st, st_str_virtdist_novirt, st_node_virtbytedist, TRUE);
+ stats_tree_create_node(st, st_str_virtdist_novirt, st_node_virtbytedist, STAT_DT_INT, TRUE);
stat_node_set_flags(st, st_str_virtdist_novirt, st_node_virtbytedist, TRUE, ST_FLG_SORT_TOP);
} /* f5eth_virtdist_stats_tree_init() */
static void osmux_stats_tree_init(stats_tree *st)
{
wmem_map_foreach(osmux_stream_hash, stream_hash_clean_stats, NULL);
- st_osmux_stats = stats_tree_create_node(st, st_str_total_pkts, 0, TRUE);
- st_osmux_stats_conn = stats_tree_create_node(st, st_str_conn, st_osmux_stats, TRUE);
+ st_osmux_stats = stats_tree_create_node(st, st_str_total_pkts, 0, STAT_DT_INT, TRUE);
+ st_osmux_stats_conn = stats_tree_create_node(st, st_str_conn, st_osmux_stats, STAT_DT_INT, TRUE);
}
static int osmux_stats_tree_packet(stats_tree *st, packet_info *pinfo,
if (!stream->stats.node_id) {
tick_stat_node(st, st_str_conn, st_osmux_stats, TRUE);
- stream->stats.node_id = stats_tree_create_node(st, stream_name, st_osmux_stats_conn, TRUE);
+ stream->stats.node_id = stats_tree_create_node(st, stream_name, st_osmux_stats_conn, STAT_DT_INT, TRUE);
}
tick_stat_node(st, stream_name, st_osmux_stats_conn, TRUE);
/* Calculate relative transmit time */
if ((stream->stats.prev_ts.secs == 0 && stream->stats.prev_ts.nsecs == 0) || osmuxh->rtp_m) {
- avg_stat_node_add_value(st, st_str_jit_rtt, stream->stats.node_id, TRUE, 0);
- avg_stat_node_add_value(st, st_str_jit_rtt_abs, stream->stats.node_id, TRUE, 0);
- avg_stat_node_add_value(st, st_str_jit_jit, stream->stats.node_id, TRUE, 0);
+ avg_stat_node_add_value_int(st, st_str_jit_rtt, stream->stats.node_id, TRUE, 0);
+ avg_stat_node_add_value_int(st, st_str_jit_rtt_abs, stream->stats.node_id, TRUE, 0);
+ avg_stat_node_add_value_int(st, st_str_jit_jit, stream->stats.node_id, TRUE, 0);
stream->stats.jitter = 0;
} else {
nstime_t diff_rx;
Dij = diff_rx_ms - diff_tx_ms;
abs_Dij = Dij * ( Dij >= 0 ? 1 : -1 );
stream->stats.jitter = stream->stats.jitter + ((double) abs_Dij - stream->stats.jitter)/16.0;
- avg_stat_node_add_value(st, st_str_jit_rtt, stream->stats.node_id, TRUE, Dij);
- avg_stat_node_add_value(st, st_str_jit_rtt_abs, stream->stats.node_id, TRUE, abs_Dij);
- avg_stat_node_add_value(st, st_str_jit_jit, stream->stats.node_id, TRUE, (gint) stream->stats.jitter);
+ avg_stat_node_add_value_int(st, st_str_jit_rtt, stream->stats.node_id, TRUE, Dij);
+ avg_stat_node_add_value_int(st, st_str_jit_rtt_abs, stream->stats.node_id, TRUE, abs_Dij);
+ avg_stat_node_add_value_int(st, st_str_jit_jit, stream->stats.node_id, TRUE, (gint) stream->stats.jitter);
}
stream->stats.prev_ts = pinfo->abs_ts;
stream->stats.prev_seq = osmuxh->seq;
static void
hartip_stats_tree_init(stats_tree* st)
{
- st_node_packets = stats_tree_create_node(st, st_str_packets, 0, TRUE);
+ st_node_packets = stats_tree_create_node(st, st_str_packets, 0, STAT_DT_INT, TRUE);
st_node_requests = stats_tree_create_pivot(st, st_str_requests, st_node_packets);
- st_node_responses = stats_tree_create_node(st, st_str_responses, st_node_packets, TRUE);
- st_node_publish = stats_tree_create_node(st, st_str_publish, st_node_packets, TRUE);
- st_node_errors = stats_tree_create_node(st, st_str_errors, st_node_packets, TRUE);
+ st_node_responses = stats_tree_create_node(st, st_str_responses, st_node_packets, STAT_DT_INT, TRUE);
+ st_node_publish = stats_tree_create_node(st, st_str_publish, st_node_packets, STAT_DT_INT, TRUE);
+ st_node_errors = stats_tree_create_node(st, st_str_errors, st_node_packets, STAT_DT_INT, TRUE);
}
static int
static void hpfeeds_stats_tree_init(stats_tree* st)
{
- st_node_channels_payload = stats_tree_create_node(st, st_str_channels_payload, 0, TRUE);
+ st_node_channels_payload = stats_tree_create_node(st, st_str_channels_payload, 0, STAT_DT_INT, TRUE);
st_node_opcodes = stats_tree_create_pivot(st, st_str_opcodes, 0);
channels_list = wmem_list_new(wmem_epan_scope());
ch_node = (struct channel_node*)wmem_alloc0(wmem_file_scope(), sizeof(struct channel_node));
ch_node->channel = wmem_strdup(wmem_file_scope(), pi->channel);
ch_node->st_node_channel_payload = stats_tree_create_node(st, ch_node->channel,
- st_node_channels_payload, FALSE);
+ st_node_channels_payload, STAT_DT_INT, FALSE);
wmem_list_append(channels_list, ch_node);
}
- avg_stat_node_add_value(st, st_str_channels_payload, 0, FALSE, pi->payload_size);
- avg_stat_node_add_value(st, ch_node->channel, 0, FALSE, pi->payload_size);
+ avg_stat_node_add_value_int(st, st_str_channels_payload, 0, FALSE, pi->payload_size);
+ avg_stat_node_add_value_int(st, ch_node->channel, 0, FALSE, pi->payload_size);
}
stats_tree_tick_pivot(st, st_node_opcodes,
static void
http_reqs_stats_tree_init(stats_tree* st)
{
- st_node_reqs = stats_tree_create_node(st, st_str_reqs, 0, TRUE);
- st_node_reqs_by_srv_addr = stats_tree_create_node(st, st_str_reqs_by_srv_addr, st_node_reqs, TRUE);
- st_node_reqs_by_http_host = stats_tree_create_node(st, st_str_reqs_by_http_host, st_node_reqs, TRUE);
- st_node_resps_by_srv_addr = stats_tree_create_node(st, st_str_resps_by_srv_addr, 0, TRUE);
+ st_node_reqs = stats_tree_create_node(st, st_str_reqs, 0, STAT_DT_INT, TRUE);
+ st_node_reqs_by_srv_addr = stats_tree_create_node(st, st_str_reqs_by_srv_addr, st_node_reqs, STAT_DT_INT, TRUE);
+ st_node_reqs_by_http_host = stats_tree_create_node(st, st_str_reqs_by_http_host, st_node_reqs, STAT_DT_INT, TRUE);
+ st_node_resps_by_srv_addr = stats_tree_create_node(st, st_str_resps_by_srv_addr, 0, STAT_DT_INT, TRUE);
}
/* HTTP/Load Distribution stats packet function */
static void
http_req_stats_tree_init(stats_tree* st)
{
- st_node_requests_by_host = stats_tree_create_node(st, st_str_requests_by_host, 0, TRUE);
+ st_node_requests_by_host = stats_tree_create_node(st, st_str_requests_by_host, 0, STAT_DT_INT, TRUE);
}
/* HTTP/Requests stats packet function */
static void
http_stats_tree_init(stats_tree* st)
{
- st_node_packets = stats_tree_create_node(st, st_str_packets, 0, TRUE);
+ st_node_packets = stats_tree_create_node(st, st_str_packets, 0, STAT_DT_INT, TRUE);
st_node_requests = stats_tree_create_pivot(st, st_str_requests, st_node_packets);
- st_node_responses = stats_tree_create_node(st, st_str_responses, st_node_packets, TRUE);
- st_node_resp_broken = stats_tree_create_node(st, st_str_resp_broken, st_node_responses, TRUE);
- st_node_resp_100 = stats_tree_create_node(st, st_str_resp_100, st_node_responses, TRUE);
- st_node_resp_200 = stats_tree_create_node(st, st_str_resp_200, st_node_responses, TRUE);
- st_node_resp_300 = stats_tree_create_node(st, st_str_resp_300, st_node_responses, TRUE);
- st_node_resp_400 = stats_tree_create_node(st, st_str_resp_400, st_node_responses, TRUE);
- st_node_resp_500 = stats_tree_create_node(st, st_str_resp_500, st_node_responses, TRUE);
- st_node_other = stats_tree_create_node(st, st_str_other, st_node_packets,FALSE);
+ st_node_responses = stats_tree_create_node(st, st_str_responses, st_node_packets, STAT_DT_INT, TRUE);
+ st_node_resp_broken = stats_tree_create_node(st, st_str_resp_broken, st_node_responses, STAT_DT_INT, TRUE);
+ st_node_resp_100 = stats_tree_create_node(st, st_str_resp_100, st_node_responses, STAT_DT_INT, TRUE);
+ st_node_resp_200 = stats_tree_create_node(st, st_str_resp_200, st_node_responses, STAT_DT_INT, TRUE);
+ st_node_resp_300 = stats_tree_create_node(st, st_str_resp_300, st_node_responses, STAT_DT_INT, TRUE);
+ st_node_resp_400 = stats_tree_create_node(st, st_str_resp_400, st_node_responses, STAT_DT_INT, TRUE);
+ st_node_resp_500 = stats_tree_create_node(st, st_str_resp_500, st_node_responses, STAT_DT_INT, TRUE);
+ st_node_other = stats_tree_create_node(st, st_str_other, st_node_packets, STAT_DT_INT, FALSE);
}
/* HTTP/Packet Counter stats packet function */
refstats_uri_to_node_id_hash = wmem_map_new(wmem_file_scope(), wmem_str_hash, g_str_equal);
/* Add the root node and its mappings */
- st_node_requests_by_referer = stats_tree_create_node(st, st_str_request_sequences, root_node_id, TRUE);
+ st_node_requests_by_referer = stats_tree_create_node(st, st_str_request_sequences, root_node_id, STAT_DT_INT, TRUE);
node_id_p = GINT_TO_POINTER(st_node_requests_by_referer);
uri = wmem_strdup(wmem_file_scope(), st_str_request_sequences);
static void http2_stats_tree_init(stats_tree* st)
{
- st_node_http2 = stats_tree_create_node(st, st_str_http2, 0, TRUE);
+ st_node_http2 = stats_tree_create_node(st, st_str_http2, 0, STAT_DT_INT, TRUE);
st_node_http2_type = stats_tree_create_pivot(st, st_str_http2_type, st_node_http2);
}
static void
msg_stats_tree_init(stats_tree *st)
{
- st_node_msg = stats_tree_create_node(st, "Messages by Type", 0, TRUE);
- st_node_dir = stats_tree_create_node(st, "Messages by Direction", 0, TRUE);
+ st_node_msg = stats_tree_create_node(st, "Messages by Type", 0, STAT_DT_INT, TRUE);
+ st_node_dir = stats_tree_create_node(st, "Messages by Direction", 0, STAT_DT_INT, TRUE);
}
static int
static void lbmr_topic_ads_topic_stats_tree_init(stats_tree * tree)
{
- lbmr_stats_tree_handle_topic_ads_topic = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_ads_topic, 0, TRUE);
+ lbmr_stats_tree_handle_topic_ads_topic = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_ads_topic, 0, STAT_DT_INT, TRUE);
}
static int lbmr_topic_ads_topic_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data)
static void lbmr_topic_ads_source_stats_tree_init(stats_tree * tree)
{
- lbmr_stats_tree_handle_topic_ads_source = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_ads_source, 0, TRUE);
+ lbmr_stats_tree_handle_topic_ads_source = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_ads_source, 0, STAT_DT_INT, TRUE);
}
static int lbmr_topic_ads_source_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data)
static void lbmr_topic_ads_transport_stats_tree_init(stats_tree * tree)
{
- lbmr_stats_tree_handle_topic_ads_transport = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_ads_transport, 0, TRUE);
+ lbmr_stats_tree_handle_topic_ads_transport = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_ads_transport, 0, STAT_DT_INT, TRUE);
}
static int lbmr_topic_ads_transport_stats_tree_packet(stats_tree * tree, packet_info * pinfo _U_, epan_dissect_t * edt _U_, const void * data)
static void lbmr_topic_queries_topic_stats_tree_init(stats_tree * tree)
{
- lbmr_stats_tree_handle_topic_queries_topic = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_queries_topic, 0, TRUE);
+ lbmr_stats_tree_handle_topic_queries_topic = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_queries_topic, 0, STAT_DT_INT, TRUE);
}
static int lbmr_topic_queries_topic_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data)
static void lbmr_topic_queries_receiver_stats_tree_init(stats_tree * tree)
{
- lbmr_stats_tree_handle_topic_queries_receiver = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_queries_receiver, 0, TRUE);
+ lbmr_stats_tree_handle_topic_queries_receiver = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_queries_receiver, 0, STAT_DT_INT, TRUE);
}
static int lbmr_topic_queries_receiver_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data)
static void lbmr_topic_queries_pattern_stats_tree_init(stats_tree * tree)
{
- lbmr_stats_tree_handle_topic_queries_pattern = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_queries_pattern, 0, TRUE);
+ lbmr_stats_tree_handle_topic_queries_pattern = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_queries_pattern, 0, STAT_DT_INT, TRUE);
}
static int lbmr_topic_queries_pattern_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data)
static void lbmr_topic_queries_pattern_receiver_stats_tree_init(stats_tree * tree)
{
- lbmr_stats_tree_handle_topic_queries_pattern_receiver = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_queries_pattern_receiver, 0, TRUE);
+ lbmr_stats_tree_handle_topic_queries_pattern_receiver = stats_tree_create_node(tree, lbmr_stat_tree_name_topic_queries_pattern_receiver, 0, STAT_DT_INT, TRUE);
}
static int lbmr_topic_queries_pattern_receiver_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data)
static void lbmr_queue_ads_queue_stats_tree_init(stats_tree * tree)
{
- lbmr_stats_tree_handle_queue_ads_queue = stats_tree_create_node(tree, lbmr_stat_tree_name_queue_ads_queue, 0, TRUE);
+ lbmr_stats_tree_handle_queue_ads_queue = stats_tree_create_node(tree, lbmr_stat_tree_name_queue_ads_queue, 0, STAT_DT_INT, TRUE);
}
static int lbmr_queue_ads_queue_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data)
static void lbmr_queue_ads_source_stats_tree_init(stats_tree * tree)
{
- lbmr_stats_tree_handle_queue_ads_source = stats_tree_create_node(tree, lbmr_stat_tree_name_queue_ads_source, 0, TRUE);
+ lbmr_stats_tree_handle_queue_ads_source = stats_tree_create_node(tree, lbmr_stat_tree_name_queue_ads_source, 0, STAT_DT_INT, TRUE);
}
static int lbmr_queue_ads_source_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data)
static void lbmr_queue_queries_queue_stats_tree_init(stats_tree * tree)
{
- lbmr_stats_tree_handle_queue_queries_queue = stats_tree_create_node(tree, lbmr_stat_tree_name_queue_queries_queue, 0, TRUE);
+ lbmr_stats_tree_handle_queue_queries_queue = stats_tree_create_node(tree, lbmr_stat_tree_name_queue_queries_queue, 0, STAT_DT_INT, TRUE);
}
static int lbmr_queue_queries_queue_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data)
static void lbmr_queue_queries_receiver_stats_tree_init(stats_tree * tree)
{
- lbmr_stats_tree_handle_queue_queries_receiver = stats_tree_create_node(tree, lbmr_stat_tree_name_queue_queries_receiver, 0, TRUE);
+ lbmr_stats_tree_handle_queue_queries_receiver = stats_tree_create_node(tree, lbmr_stat_tree_name_queue_queries_receiver, 0, STAT_DT_INT, TRUE);
}
static int lbmr_queue_queries_receiver_stats_tree_packet(stats_tree * tree, packet_info * pinfo, epan_dissect_t * edt _U_, const void * data)
static void
rtsp_stats_tree_init(stats_tree* st)
{
- st_node_packets = stats_tree_create_node(st, st_str_packets, 0, TRUE);
+ st_node_packets = stats_tree_create_node(st, st_str_packets, 0, STAT_DT_INT, TRUE);
st_node_requests = stats_tree_create_pivot(st, st_str_requests, st_node_packets);
- st_node_responses = stats_tree_create_node(st, st_str_responses, st_node_packets, TRUE);
- st_node_resp_broken = stats_tree_create_node(st, st_str_resp_broken, st_node_responses, TRUE);
- st_node_resp_100 = stats_tree_create_node(st, st_str_resp_100, st_node_responses, TRUE);
- st_node_resp_200 = stats_tree_create_node(st, st_str_resp_200, st_node_responses, TRUE);
- st_node_resp_300 = stats_tree_create_node(st, st_str_resp_300, st_node_responses, TRUE);
- st_node_resp_400 = stats_tree_create_node(st, st_str_resp_400, st_node_responses, TRUE);
- st_node_resp_500 = stats_tree_create_node(st, st_str_resp_500, st_node_responses, TRUE);
- st_node_other = stats_tree_create_node(st, st_str_other, st_node_packets, FALSE);
+ st_node_responses = stats_tree_create_node(st, st_str_responses, st_node_packets, STAT_DT_INT, TRUE);
+ st_node_resp_broken = stats_tree_create_node(st, st_str_resp_broken, st_node_responses, STAT_DT_INT, TRUE);
+ st_node_resp_100 = stats_tree_create_node(st, st_str_resp_100, st_node_responses, STAT_DT_INT, TRUE);
+ st_node_resp_200 = stats_tree_create_node(st, st_str_resp_200, st_node_responses, STAT_DT_INT, TRUE);
+ st_node_resp_300 = stats_tree_create_node(st, st_str_resp_300, st_node_responses, STAT_DT_INT, TRUE);
+ st_node_resp_400 = stats_tree_create_node(st, st_str_resp_400, st_node_responses, STAT_DT_INT, TRUE);
+ st_node_resp_500 = stats_tree_create_node(st, st_str_resp_500, st_node_responses, STAT_DT_INT, TRUE);
+ st_node_other = stats_tree_create_node(st, st_str_other, st_node_packets, STAT_DT_INT, FALSE);
}
/* RTSP/Packet Counter stats packet function */
static void
sametime_stats_tree_init(stats_tree* st)
{
- st_node_packet = stats_tree_create_node(st, st_str_packet, 0, TRUE);
+ st_node_packet = stats_tree_create_node(st, st_str_packet, 0, STAT_DT_INT, TRUE);
st_node_message_type = stats_tree_create_pivot(st, st_str_message_type, st_node_packet);
st_node_send_type = stats_tree_create_pivot(st, st_str_send_type, st_node_packet);
st_node_user_status = stats_tree_create_pivot(st, st_str_user_status, st_node_packet);
static void
smpp_stats_tree_init(stats_tree* st)
{
- st_smpp_ops = stats_tree_create_node(st, "SMPP Operations", 0, TRUE);
- st_smpp_req = stats_tree_create_node(st, "SMPP Requests", st_smpp_ops, TRUE);
- st_smpp_res = stats_tree_create_node(st, "SMPP Responses", st_smpp_ops, TRUE);
- st_smpp_res_status = stats_tree_create_node(st, "SMPP Response Status", 0, TRUE);
+ st_smpp_ops = stats_tree_create_node(st, "SMPP Operations", 0, STAT_DT_INT, TRUE);
+ st_smpp_req = stats_tree_create_node(st, "SMPP Requests", st_smpp_ops, STAT_DT_INT, TRUE);
+ st_smpp_res = stats_tree_create_node(st, "SMPP Responses", st_smpp_ops, STAT_DT_INT, TRUE);
+ st_smpp_res_status = stats_tree_create_node(st, "SMPP Response Status", 0, STAT_DT_INT, TRUE);
}
static void
ucp_stats_tree_init(stats_tree* st)
{
- st_ucp_messages = stats_tree_create_node(st, st_str_ucp, 0, TRUE);
- st_ucp_ops = stats_tree_create_node(st, st_str_ops, st_ucp_messages, TRUE);
- st_ucp_res = stats_tree_create_node(st, st_str_res, st_ucp_messages, TRUE);
- st_ucp_results = stats_tree_create_node(st, st_str_ucp_res, 0, TRUE);
- st_ucp_results_pos = stats_tree_create_node(st, st_str_pos, st_ucp_results, TRUE);
- st_ucp_results_neg = stats_tree_create_node(st, st_str_neg, st_ucp_results, TRUE);
+ st_ucp_messages = stats_tree_create_node(st, st_str_ucp, 0, STAT_DT_INT, TRUE);
+ st_ucp_ops = stats_tree_create_node(st, st_str_ops, st_ucp_messages, STAT_DT_INT, TRUE);
+ st_ucp_res = stats_tree_create_node(st, st_str_res, st_ucp_messages, STAT_DT_INT, TRUE);
+ st_ucp_results = stats_tree_create_node(st, st_str_ucp_res, 0, STAT_DT_INT, TRUE);
+ st_ucp_results_pos = stats_tree_create_node(st, st_str_pos, st_ucp_results, STAT_DT_INT, TRUE);
+ st_ucp_results_neg = stats_tree_create_node(st, st_str_neg, st_ucp_results, STAT_DT_INT, TRUE);
}
static int
burst_bucket *bucket;
node->counter = 0;
- node->total = 0;
- node->minvalue = G_MAXINT;
- node->maxvalue = G_MININT;
+ switch (node->datatype)
+ {
+ case STAT_DT_INT:
+ node->total.int_total = 0;
+ node->minvalue.int_min = G_MAXINT;
+ node->maxvalue.int_max = G_MININT;
+ break;
+ case STAT_DT_FLOAT:
+ node->total.float_total = 0;
+ node->minvalue.float_min = G_MAXFLOAT;
+ node->maxvalue.float_max = G_MINFLOAT;
+ break;
+ }
node->st_flags = 0;
while (node->bh) {
st->root.children = NULL;
st->root.counter = 0;
- st->root.total = 0;
- st->root.minvalue = G_MAXINT;
- st->root.maxvalue = G_MININT;
+ switch (st->root.datatype)
+ {
+ case STAT_DT_INT:
+ st->root.total.int_total = 0;
+ st->root.minvalue.int_min = G_MAXINT;
+ st->root.maxvalue.int_max = G_MININT;
+ break;
+ case STAT_DT_FLOAT:
+ st->root.total.float_total = 0;
+ st->root.minvalue.float_min = G_MAXFLOAT;
+ st->root.maxvalue.float_max = G_MINFLOAT;
+ break;
+ }
st->root.st_flags = 0;
st->root.bh = (burst_bucket*)g_malloc0(sizeof(burst_bucket));
st->start = -1.0;
st->elapsed = 0.0;
- st->root.minvalue = G_MAXINT;
- st->root.maxvalue = G_MININT;
+ switch (st->root.datatype)
+ {
+ case STAT_DT_INT:
+ st->root.minvalue.int_min = G_MAXINT;
+ st->root.maxvalue.int_max = G_MININT;
+ break;
+ case STAT_DT_FLOAT:
+ st->root.minvalue.float_min = G_MAXFLOAT;
+ st->root.maxvalue.float_max = G_MINFLOAT;
+ break;
+ }
st->root.bh = (burst_bucket*)g_malloc0(sizeof(burst_bucket));
st->root.bt = st->root.bh;
* as_named_node: whether or not it has to be registered in the root namespace
*/
static stat_node*
-new_stat_node(stats_tree *st, const gchar *name, int parent_id,
+new_stat_node(stats_tree *st, const gchar *name, int parent_id, stat_node_datatype datatype,
gboolean with_hash, gboolean as_parent_node)
{
stat_node *node = (stat_node *)g_malloc0(sizeof(stat_node));
stat_node *last_chld = NULL;
- node->minvalue = G_MAXINT;
- node->maxvalue = G_MININT;
+ node->datatype = datatype;
+ switch (datatype)
+ {
+ case STAT_DT_INT:
+ node->minvalue.int_min = G_MAXINT;
+ node->maxvalue.int_max = G_MININT;
+ break;
+ case STAT_DT_FLOAT:
+ node->minvalue.float_min = G_MAXFLOAT;
+ node->maxvalue.float_max = G_MINFLOAT;
+ break;
+ }
node->st_flags = parent_id?0:ST_FLG_ROOTCHILD;
node->bh = (burst_bucket*)g_malloc0(sizeof(burst_bucket));
/***/
extern int
-stats_tree_create_node(stats_tree *st, const gchar *name, int parent_id, gboolean with_hash)
+stats_tree_create_node(stats_tree *st, const gchar *name, int parent_id, stat_node_datatype datatype, gboolean with_hash)
{
- stat_node *node = new_stat_node(st,name,parent_id,with_hash,TRUE);
+ stat_node *node = new_stat_node(st,name,parent_id,datatype,with_hash,TRUE);
if (node)
return node->id;
/* XXX: should this be a macro? */
extern int
stats_tree_create_node_by_pname(stats_tree *st, const gchar *name,
- const gchar *parent_name, gboolean with_children)
+ const gchar *parent_name, stat_node_datatype datatype, gboolean with_children)
{
- return stats_tree_create_node(st,name,stats_tree_parent_id_by_name(st,parent_name),with_children);
+ return stats_tree_create_node(st,name,stats_tree_parent_id_by_name(st,parent_name),datatype,with_children);
}
/* Internal function to update the burst calculation data - add entry to bucket */
* using parent_name as parent node.
* with_hash=TRUE to indicate that the created node will have a parent
*/
-extern int
-stats_tree_manip_node(manip_node_mode mode, stats_tree *st, const char *name,
+int
+stats_tree_manip_node_int(manip_node_mode mode, stats_tree *st, const char *name,
int parent_id, gboolean with_hash, gint value)
{
stat_node *node = NULL;
}
if ( node == NULL )
- node = new_stat_node(st,name,parent_id,with_hash,with_hash);
+ node = new_stat_node(st,name,parent_id,STAT_DT_INT,with_hash,with_hash);
switch (mode) {
case MN_INCREASE:
node->counter += value;
update_burst_calc(node, value);
break;
- case MN_SET: node->counter = value; break;
+ case MN_SET:
+ node->counter = value;
+ break;
case MN_AVERAGE:
node->counter++;
update_burst_calc(node, 1);
/* fall through */ /*to average code */
case MN_AVERAGE_NOTICK:
- node->total += value;
- if (node->minvalue > value) {
- node->minvalue = value;
+ node->total.int_total += value;
+ if (node->minvalue.int_min > value) {
+ node->minvalue.int_min = value;
}
- if (node->maxvalue < value) {
- node->maxvalue = value;
+ if (node->maxvalue.int_max < value) {
+ node->maxvalue.int_max = value;
}
node->st_flags |= ST_FLG_AVERAGE;
break;
return -1;
}
+/*
+* Increases by delta the counter of the node whose name is given
+* if the node does not exist yet it's created (with counter=1)
+* using parent_name as parent node.
+* with_hash=TRUE to indicate that the created node will have a parent
+*/
+int
+stats_tree_manip_node_float(manip_node_mode mode, stats_tree *st, const char *name,
+ int parent_id, gboolean with_hash, gfloat value)
+{
+ stat_node *node = NULL;
+ stat_node *parent = NULL;
+
+ g_assert(parent_id >= 0 && parent_id < (int)st->parents->len);
+
+ parent = (stat_node *)g_ptr_array_index(st->parents, parent_id);
+
+ if (parent->hash) {
+ node = (stat_node *)g_hash_table_lookup(parent->hash, name);
+ }
+ else {
+ node = (stat_node *)g_hash_table_lookup(st->names, name);
+ }
+
+ if (node == NULL)
+ node = new_stat_node(st, name, parent_id, STAT_DT_FLOAT, with_hash, with_hash);
+
+ switch (mode) {
+ case MN_AVERAGE:
+ node->counter++;
+ update_burst_calc(node, 1);
+ /* fall through */ /*to average code */
+ case MN_AVERAGE_NOTICK:
+ node->total.float_total += value;
+ if (node->minvalue.float_min > value) {
+ node->minvalue.float_min = value;
+ }
+ if (node->maxvalue.float_max < value) {
+ node->maxvalue.float_max = value;
+ }
+ node->st_flags |= ST_FLG_AVERAGE;
+ break;
+ default:
+ //only average is currently supported
+ g_assert_not_reached();
+ break;
+ }
+
+ if (node)
+ return node->id;
+ else
+ return -1;
+}
extern char*
stats_tree_get_abbr(const char *opt_arg)
{
va_list list;
gchar *curr_range;
- stat_node *rng_root = new_stat_node(st, name, parent_id, FALSE, TRUE);
+ stat_node *rng_root = new_stat_node(st, name, parent_id, STAT_DT_INT, FALSE, TRUE);
stat_node *range_node = NULL;
va_start( list, parent_id );
while (( curr_range = va_arg(list, gchar*) )) {
- range_node = new_stat_node(st, curr_range, rng_root->id, FALSE, FALSE);
+ range_node = new_stat_node(st, curr_range, rng_root->id, STAT_DT_INT, FALSE, FALSE);
range_node->rng = get_range(curr_range);
}
va_end( list );
gchar** str_ranges)
{
int i;
- stat_node *rng_root = new_stat_node(st, name, parent_id, FALSE, TRUE);
+ stat_node *rng_root = new_stat_node(st, name, parent_id, STAT_DT_INT, FALSE, TRUE);
stat_node *range_node = NULL;
for (i = 0; i < num_str_ranges - 1; i++) {
- range_node = new_stat_node(st, str_ranges[i], rng_root->id, FALSE, FALSE);
+ range_node = new_stat_node(st, str_ranges[i], rng_root->id, STAT_DT_INT, FALSE, FALSE);
range_node->rng = get_range(str_ranges[i]);
}
- range_node = new_stat_node(st, str_ranges[i], rng_root->id, FALSE, FALSE);
+ range_node = new_stat_node(st, str_ranges[i], rng_root->id, STAT_DT_INT, FALSE, FALSE);
range_node->rng = get_range(str_ranges[i]);
if (range_node->rng->floor == range_node->rng->ceil) {
range_node->rng->ceil = G_MAXINT;
gchar *curr_range;
stat_node *range_node = NULL;
int parent_id = stats_tree_parent_id_by_name(st,parent_name);
- stat_node *rng_root = new_stat_node(st, name, parent_id, FALSE, TRUE);
+ stat_node *rng_root = new_stat_node(st, name, parent_id, STAT_DT_INT, FALSE, TRUE);
va_start( list, parent_name );
while (( curr_range = va_arg(list, gchar*) )) {
- range_node = new_stat_node(st, curr_range, rng_root->id, FALSE, FALSE);
+ range_node = new_stat_node(st, curr_range, rng_root->id, STAT_DT_INT, FALSE, FALSE);
range_node->rng = get_range(curr_range);
}
va_end( list );
g_assert_not_reached();
/* update stats for container node. counter should already be ticked so we only update total and min/max */
- node->total += value_in_range;
- if (node->minvalue > value_in_range) {
- node->minvalue = value_in_range;
+ node->total.int_total += value_in_range;
+ if (node->minvalue.int_min > value_in_range) {
+ node->minvalue.int_min = value_in_range;
}
- if (node->maxvalue < value_in_range) {
- node->maxvalue = value_in_range;
+ if (node->maxvalue.int_max < value_in_range) {
+ node->maxvalue.int_max = value_in_range;
}
node->st_flags |= ST_FLG_AVERAGE;
if ( value_in_range >= stat_floor && value_in_range <= stat_ceil ) {
child->counter++;
- child->total += value_in_range;
- if (child->minvalue > value_in_range) {
- child->minvalue = value_in_range;
+ child->total.int_total += value_in_range;
+ if (child->minvalue.int_min > value_in_range) {
+ child->minvalue.int_min = value_in_range;
}
- if (child->maxvalue < value_in_range) {
- child->maxvalue = value_in_range;
+ if (child->maxvalue.int_max < value_in_range) {
+ child->maxvalue.int_max = value_in_range;
}
child->st_flags |= ST_FLG_AVERAGE;
update_burst_calc(child, 1);
extern int
stats_tree_create_pivot(stats_tree *st, const gchar *name, int parent_id)
{
- stat_node *node = new_stat_node(st,name,parent_id,TRUE,TRUE);
+ stat_node *node = new_stat_node(st,name,parent_id,STAT_DT_INT,TRUE,TRUE);
if (node)
return node->id;
int parent_id = stats_tree_parent_id_by_name(st,parent_name);
stat_node *node;
- node = new_stat_node(st,name,parent_id,TRUE,TRUE);
+ node = new_stat_node(st,name,parent_id,STAT_DT_INT,TRUE,TRUE);
if (node)
return node->id;
parent->counter++;
update_burst_calc(parent, 1);
- stats_tree_manip_node( MN_INCREASE, st, pivot_value, pivot_id, FALSE, 1);
+ stats_tree_manip_node_int( MN_INCREASE, st, pivot_value, pivot_id, FALSE, 1);
return pivot_id;
}
values[COL_NAME] = (node->st_flags&ST_FLG_ROOTCHILD)?stats_tree_get_displayname(node->name):g_strdup(node->name);
values[COL_COUNT] = g_strdup_printf("%u",node->counter);
- values[COL_AVERAGE] = ((node->st_flags&ST_FLG_AVERAGE)||node->rng)?
- (node->counter?g_strdup_printf("%.2f",((float)node->total)/node->counter):g_strdup("-")):
- g_strdup("");
- values[COL_MIN] = ((node->st_flags&ST_FLG_AVERAGE)||node->rng)?
- (node->counter?g_strdup_printf("%u",node->minvalue):g_strdup("-")):
- g_strdup("");
- values[COL_MAX] = ((node->st_flags&ST_FLG_AVERAGE)||node->rng)?
- (node->counter?g_strdup_printf("%u",node->maxvalue):g_strdup("-")):
- g_strdup("");
+ if (((node->st_flags&ST_FLG_AVERAGE) || node->rng)) {
+ if (node->counter) {
+ switch (node->datatype)
+ {
+ case STAT_DT_INT:
+ values[COL_AVERAGE] = g_strdup_printf("%.2f", ((float)node->total.int_total) / node->counter);
+ break;
+ case STAT_DT_FLOAT:
+ values[COL_AVERAGE] = g_strdup_printf("%.2f", node->total.float_total / node->counter);
+ break;
+ }
+ } else {
+ values[COL_AVERAGE] = g_strdup("-");
+ }
+ } else {
+ values[COL_AVERAGE] = g_strdup("");
+ }
+
+ if (((node->st_flags&ST_FLG_AVERAGE) || node->rng)) {
+ if (node->counter) {
+ switch (node->datatype)
+ {
+ case STAT_DT_INT:
+ values[COL_MIN] = g_strdup_printf("%u", node->minvalue.int_min);
+ break;
+ case STAT_DT_FLOAT:
+ values[COL_MIN] = g_strdup_printf("%f", node->minvalue.float_min);
+ break;
+ }
+ }
+ else {
+ values[COL_MIN] = g_strdup("-");
+ }
+ }
+ else {
+ values[COL_MIN] = g_strdup("");
+ }
+
+ if (((node->st_flags&ST_FLG_AVERAGE) || node->rng)) {
+ if (node->counter) {
+ switch (node->datatype)
+ {
+ case STAT_DT_INT:
+ values[COL_MAX] = g_strdup_printf("%u", node->maxvalue.int_max);
+ break;
+ case STAT_DT_FLOAT:
+ values[COL_MAX] = g_strdup_printf("%f", node->maxvalue.float_max);
+ break;
+ }
+ }
+ else {
+ values[COL_MAX] = g_strdup("-");
+ }
+ }
+ else {
+ values[COL_MAX] = g_strdup("");
+ }
+
values[COL_RATE] = (node->st->elapsed)?g_strdup_printf("%.4f",((float)node->counter)/node->st->elapsed):g_strdup("");
values[COL_PERCENT] = ((node->parent)&&(node->parent->counter))?
g_strdup_printf("%.2f%%",(node->counter*100.0)/node->parent->counter):
gboolean sort_descending)
{
int result = 0;
- float avg_a, avg_b;
+ float avg_a = 0, avg_b = 0;
if (prefs.st_sort_rng_nameonly&&(a->rng&&b->rng)) {
/* always sort ranges by range name */
break;
case COL_AVERAGE:
- avg_a = a->counter ? ((float)a->total)/a->counter : 0;
- avg_b = b->counter ? ((float)b->total)/b->counter : 0;
+ switch (a->datatype)
+ {
+ case STAT_DT_INT:
+ avg_a = a->counter ? ((float)a->total.int_total)/a->counter : 0;
+ avg_b = b->counter ? ((float)b->total.int_total)/b->counter : 0;
+ break;
+ case STAT_DT_FLOAT:
+ avg_a = a->counter ? ((float)a->total.float_total) / a->counter : 0;
+ avg_b = b->counter ? ((float)b->total.float_total) / b->counter : 0;
+ break;
+ }
result = (avg_a>avg_b) ? 1 : ( (avg_a<avg_b) ? -1 : 0);
break;
case COL_MIN:
- result = a->minvalue - b->minvalue;
+ switch (a->datatype)
+ {
+ case STAT_DT_INT:
+ result = a->minvalue.int_min - b->minvalue.int_min;
+ break;
+ case STAT_DT_FLOAT:
+ result = (a->minvalue.float_min>b->minvalue.int_min) ? 1 : ((a->minvalue.float_min<b->minvalue.int_min) ? -1 : 0);
+ break;
+ }
break;
case COL_MAX:
- result = a->maxvalue - b->maxvalue;
+ switch (a->datatype)
+ {
+ case STAT_DT_INT:
+ result = a->maxvalue.int_max - b->maxvalue.int_max;
+ break;
+ case STAT_DT_FLOAT:
+ result = (a->maxvalue.float_max>b->maxvalue.float_max) ? 1 : ((a->maxvalue.float_max<b->maxvalue.float_max) ? -1 : 0);
+ break;
+ }
break;
case COL_BURSTRATE:
/* stats_tree cleanup callback */
typedef void (*stat_tree_cleanup_cb)(stats_tree *);
+typedef enum _stat_node_datatype {
+ STAT_DT_INT,
+ STAT_DT_FLOAT
+} stat_node_datatype;
+
/* registers a new stats tree with default group REGISTER_STAT_GROUP_UNSORTED
* abbr: protocol abbr
* name: protocol display name
* st: the stats_tree in which to create it
* name: the name of the new node
* parent_name: the name of the parent_node (NULL for root)
+ * datatype: datatype used for the value of the node
* with_children: TRUE if this node will have "dynamically created" children
*/
WS_DLL_PUBLIC int stats_tree_create_node(stats_tree *st,
const gchar *name,
int parent_id,
+ stat_node_datatype datatype,
gboolean with_children);
/* creates a node using its parent's tree name */
WS_DLL_PUBLIC int stats_tree_create_node_by_pname(stats_tree *st,
const gchar *name,
const gchar *parent_name,
+ stat_node_datatype datatype,
gboolean with_children);
/* creates a node in the tree, that will contain a ranges list.
MN_SET_FLAGS,
MN_CLEAR_FLAGS
} manip_node_mode;
-WS_DLL_PUBLIC int stats_tree_manip_node(manip_node_mode mode,
+WS_DLL_PUBLIC int stats_tree_manip_node_int(manip_node_mode mode,
stats_tree *st,
const gchar *name,
int parent_id,
gboolean with_children,
gint value);
+WS_DLL_PUBLIC int stats_tree_manip_node_float(manip_node_mode mode,
+ stats_tree *st,
+ const gchar *name,
+ int parent_id,
+ gboolean with_children,
+ gfloat value);
+
#define increase_stat_node(st,name,parent_id,with_children,value) \
- (stats_tree_manip_node(MN_INCREASE,(st),(name),(parent_id),(with_children),(value)))
+ (stats_tree_manip_node_int(MN_INCREASE,(st),(name),(parent_id),(with_children),(value)))
#define tick_stat_node(st,name,parent_id,with_children) \
- (stats_tree_manip_node(MN_INCREASE,(st),(name),(parent_id),(with_children),1))
+ (stats_tree_manip_node_int(MN_INCREASE,(st),(name),(parent_id),(with_children),1))
#define set_stat_node(st,name,parent_id,with_children,value) \
- (stats_tree_manip_node(MN_SET,(st),(name),(parent_id),(with_children),value))
+ (stats_tree_manip_node_int(MN_SET,(st),(name),(parent_id),(with_children),value))
#define zero_stat_node(st,name,parent_id,with_children) \
- (stats_tree_manip_node(MN_SET,(st),(name),(parent_id),(with_children),0))
+ (stats_tree_manip_node_int(MN_SET,(st),(name),(parent_id),(with_children),0))
/*
* Add value to average calculation WITHOUT ticking node. Node MUST be ticked separately!
* least show a count instead of 0.
*/
#define avg_stat_node_add_value_notick(st,name,parent_id,with_children,value) \
- (stats_tree_manip_node(MN_AVERAGE_NOTICK,(st),(name),(parent_id),(with_children),value))
+ (stats_tree_manip_node_int(MN_AVERAGE_NOTICK,(st),(name),(parent_id),(with_children),value))
/* Tick node and add a new value to the average calculation for this stats node. */
-#define avg_stat_node_add_value(st,name,parent_id,with_children,value) \
- (stats_tree_manip_node(MN_AVERAGE,(st),(name),(parent_id),(with_children),value))
+#define avg_stat_node_add_value_int(st,name,parent_id,with_children,value) \
+ (stats_tree_manip_node_int(MN_AVERAGE,(st),(name),(parent_id),(with_children),value))
+
+#define avg_stat_node_add_value_float(st,name,parent_id,with_children,value) \
+ (stats_tree_manip_node_float(MN_AVERAGE,(st),(name),(parent_id),(with_children),value))
/* Set flags for this node. Node created if it does not yet exist. */
#define stat_node_set_flags(st,name,parent_id,with_children,flags) \
- (stats_tree_manip_node(MN_SET_FLAGS,(st),(name),(parent_id),(with_children),flags))
+ (stats_tree_manip_node_int(MN_SET_FLAGS,(st),(name),(parent_id),(with_children),flags))
/* Clear flags for this node. Node created if it does not yet exist. */
#define stat_node_clear_flags(st,name,parent_id,with_children,flags) \
- (stats_tree_manip_node(MN_CLEAR_FLAGS,(st),(name),(parent_id),(with_children),flags))
+ (stats_tree_manip_node_int(MN_CLEAR_FLAGS,(st),(name),(parent_id),(with_children),flags))
#ifdef __cplusplus
}
};
struct _stat_node {
- gchar* name;
- int id;
+ gchar* name;
+ int id;
+ stat_node_datatype datatype;
/** the counter it keeps */
gint counter;
/** total of all values submitted - for computing averages */
- gint64 total;
- gint minvalue;
- gint maxvalue;
- int st_flags;
+ union {
+ gint64 int_total;
+ gdouble float_total;
+ } total;
+ union {
+ gint int_min;
+ gfloat float_min;
+ } minvalue;
+ union {
+ gint int_max;
+ gfloat float_max;
+ } maxvalue;
+
+ gint st_flags;
/** fields for burst rate calculation */
gint bcount;
static const gchar *st_str_ipv6 = "IPv6 Statistics/All Addresses";
static void ipv4_hosts_stats_tree_init(stats_tree *st) {
- st_node_ipv4 = stats_tree_create_node(st, st_str_ipv4, 0, TRUE);
+ st_node_ipv4 = stats_tree_create_node(st, st_str_ipv4, 0, STAT_DT_INT, TRUE);
}
static void ipv6_hosts_stats_tree_init(stats_tree *st) {
- st_node_ipv6 = stats_tree_create_node(st, st_str_ipv6, 0, TRUE);
+ st_node_ipv6 = stats_tree_create_node(st, st_str_ipv6, 0, STAT_DT_INT, TRUE);
}
static int ip_hosts_stats_tree_packet(stats_tree *st, packet_info *pinfo, int st_node, const gchar *st_str) {
const gchar *st_str_src, int *st_node_src_ptr,
const gchar *st_str_dst, int *st_node_dst_ptr) {
/* create one tree branch for source */
- *st_node_src_ptr = stats_tree_create_node(st, st_str_src, 0, TRUE);
+ *st_node_src_ptr = stats_tree_create_node(st, st_str_src, 0, STAT_DT_INT, TRUE);
/* set flag so this branch will always be sorted to top of tree */
stat_node_set_flags(st, st_str_src, 0, FALSE, ST_FLG_SORT_TOP);
/* creat another top level node for destination branch */
- *st_node_dst_ptr = stats_tree_create_node(st, st_str_dst, 0, TRUE);
+ *st_node_dst_ptr = stats_tree_create_node(st, st_str_dst, 0, STAT_DT_INT, TRUE);
/* set flag so this branch will not be expanded by default */
stat_node_set_flags(st, st_str_dst, 0, FALSE, ST_FLG_DEF_NOEXPAND);
}
static const gchar *st_str_ipv6_dsts = "IPv6 Statistics/Destinations and Ports";
static void ipv4_dsts_stats_tree_init(stats_tree *st) {
- st_node_ipv4_dsts = stats_tree_create_node(st, st_str_ipv4_dsts, 0, TRUE);
+ st_node_ipv4_dsts = stats_tree_create_node(st, st_str_ipv4_dsts, 0, STAT_DT_INT, TRUE);
}
static void ipv6_dsts_stats_tree_init(stats_tree *st) {
- st_node_ipv6_dsts = stats_tree_create_node(st, st_str_ipv6_dsts, 0, TRUE);
+ st_node_ipv6_dsts = stats_tree_create_node(st, st_str_ipv6_dsts, 0, STAT_DT_INT, TRUE);
}
static int dsts_stats_tree_packet(stats_tree *st, packet_info *pinfo, int st_node, const gchar *st_str) {
sharkd_json_value_anyf(TRUE, "count", "%d", node->counter);
if (node->counter && ((node->st_flags & ST_FLG_AVERAGE) || node->rng))
{
- sharkd_json_value_anyf(TRUE, "avg", "%.2f", ((float)node->total) / node->counter);
- sharkd_json_value_anyf(TRUE, "min", "%d", node->minvalue);
- sharkd_json_value_anyf(TRUE, "max", "%d", node->maxvalue);
+ switch(node->datatype)
+ {
+ case STAT_DT_INT:
+ sharkd_json_value_anyf(TRUE, "avg", "%.2f", ((float)node->total.int_total) / node->counter);
+ sharkd_json_value_anyf(TRUE, "min", "%d", node->minvalue.int_min);
+ sharkd_json_value_anyf(TRUE, "max", "%d", node->maxvalue.int_max);
+ break;
+ case STAT_DT_FLOAT:
+ sharkd_json_value_anyf(TRUE, "avg", "%.2f", node->total.float_total / node->counter);
+ sharkd_json_value_anyf(TRUE, "min", "%f", node->minvalue.float_min);
+ sharkd_json_value_anyf(TRUE, "max", "%f", node->maxvalue.float_max);
+ break;
+ }
}
if (node->st->elapsed)
git.samba.org / metze / wireshark / wip.git / commitdiff