Refactor RTD stats.

Very similar to the refactoring of SRT stats, it provides more commonality of the stats for all GUI interfaces.  Currently implemented for TShark and GTK.  Affected dissectors: MEGACO, MGCP, Radius

Change-Id: Icb73a7e603dc3502b39bf696227fcaae37d4ed21
Reviewed-on: https://code.wireshark.org/review/8998
Petri-Dish: Michael Mann <mmann78@netscape.net>
Tested-by: Petri Dish Buildbot <buildbot-no-reply@wireshark.org>
Reviewed-by: Anders Broman <a.broman58@gmail.com>

3 files changed, 458 insertions, 0 deletions

diff --git a/epan/dissectors/packet-megaco.c b/epan/dissectors/packet-megaco.c
index ac6e23ae1d..e822245059 100644
--- a/epan/dissectors/packet-megaco.c
+++ b/epan/dissectors/packet-megaco.c
@@ -46,6 +46,8 @@
 #include <epan/exceptions.h>
 #include <epan/gcp.h>
 #include <epan/tap.h>
+#include <epan/rtd_table.h>
+#include <epan/prefs-int.h>
 #include "packet-tpkt.h"
 #include "packet-h245.h"
 #include "packet-ip.h"
@@ -201,6 +203,215 @@ static const value_string megaco_context_vals[] = {
 static gint megaco_tvb_skip_wsp(tvbuff_t *tvb, gint offset);
 static gint megaco_tvb_skip_wsp_return(tvbuff_t *tvb, gint offset);
 
+#define NUM_TIMESTATS 12
+
+static const value_string megaco_message_type[] = {
+    {  0, "ADD "},
+    {  1, "MOVE"},
+    {  2, "MDFY"},
+    {  3, "SUBT"},
+    {  4, "AUCP"},
+    {  5, "AUVL"},
+    {  6, "NTFY"},
+    {  7, "SVCC"},
+    {  8, "TOPO"},
+    {  9, "NONE"},
+    { 10, "ALL "},
+    {  0, NULL}
+};
+
+#define GCP_CMD_REPLY_CASE \
+    case GCP_CMD_ADD_REPLY: \
+    case GCP_CMD_MOVE_REPLY: \
+    case GCP_CMD_MOD_REPLY: \
+    case GCP_CMD_SUB_REPLY: \
+    case GCP_CMD_AUDITCAP_REPLY: \
+    case GCP_CMD_AUDITVAL_REPLY: \
+    case GCP_CMD_NOTIFY_REPLY: \
+    case GCP_CMD_SVCCHG_REPLY: \
+    case GCP_CMD_TOPOLOGY_REPLY: \
+    case GCP_CMD_REPLY:
+
+#define GCP_CMD_REQ_CASE \
+    case GCP_CMD_ADD_REQ: \
+    case GCP_CMD_MOVE_REQ: \
+    case GCP_CMD_MOD_REQ: \
+    case GCP_CMD_SUB_REQ: \
+    case GCP_CMD_AUDITCAP_REQ: \
+    case GCP_CMD_AUDITVAL_REQ: \
+    case GCP_CMD_NOTIFY_REQ: \
+    case GCP_CMD_SVCCHG_REQ: \
+    case GCP_CMD_TOPOLOGY_REQ: \
+    case GCP_CMD_CTX_ATTR_AUDIT_REQ: \
+    case GCP_CMD_OTHER_REQ:
+
+static gboolean
+megacostat_is_duplicate_reply(const gcp_cmd_t* cmd)
+{
+    switch (cmd->type) {
+
+    GCP_CMD_REPLY_CASE
+        {
+            gcp_cmd_msg_t *cmd_msg;
+            /* cycle through commands to find same command in the transaction */
+            for (cmd_msg = cmd->trx->cmds;
+                (cmd_msg != NULL) && (cmd_msg->cmd->msg->framenum != cmd->msg->framenum);
+                cmd_msg = cmd_msg->next) {
+                if (cmd_msg->cmd->type == cmd->type)
+                    return TRUE;
+            }
+
+            return FALSE;
+        }
+        break;
+	default:
+        return FALSE;
+        break;
+    }
+}
+
+static gboolean
+megacostat_had_request(const gcp_cmd_t* cmd)
+{
+    switch (cmd->type) {
+
+    GCP_CMD_REPLY_CASE
+        {
+            gcp_cmd_msg_t *cmd_msg;
+            /* cycle through commands to find a request in the transaction */
+            for (cmd_msg = cmd->trx->cmds;
+                    (cmd_msg != NULL) && (cmd_msg->cmd->msg->framenum != cmd->msg->framenum);
+                    cmd_msg = cmd_msg->next) {
+
+                    switch (cmd_msg->cmd->type) {
+
+                    GCP_CMD_REQ_CASE
+                        return TRUE;
+                        break;
+                    default:
+                        return FALSE;
+                        break;
+                    }
+            }
+
+            return FALSE;
+        }
+        break;
+    default:
+        return FALSE;
+        break;
+    }
+}
+
+static void
+megacostat_filtercheck(const char *opt_arg _U_, const char **filter _U_, char** err)
+{
+    pref_t *megaco_ctx_track, *h248_ctx_track;
+
+    megaco_ctx_track = prefs_find_preference(prefs_find_module("megaco"), "ctx_info");
+    h248_ctx_track = prefs_find_preference(prefs_find_module("h248"), "ctx_info");
+
+    if (!megaco_ctx_track || !h248_ctx_track) {
+        /* No such preferences */
+        return;
+    }
+
+    if (!*megaco_ctx_track->varp.boolp || !*h248_ctx_track->varp.boolp) {
+        *err = g_strdup_printf("Track Context option at Protocols -> MEGACO and Protocols -> H248 preferences\n"
+                                "has to be set to true to enable measurement of service response times.\n");
+    }
+}
+
+static int
+megacostat_packet(void *pms, packet_info *pinfo, epan_dissect_t *edt _U_, const void *pmi)
+{
+    rtd_data_t* rtd_data = (rtd_data_t*)pms;
+    rtd_stat_table* ms = &rtd_data->stat_table;
+    const gcp_cmd_t *mi=(const gcp_cmd_t*)pmi;
+    nstime_t delta;
+    int ret = 0;
+
+    switch (mi->type) {
+
+    GCP_CMD_REQ_CASE
+        if(!mi->trx->initial) {
+            /* Track Context is probably disabled, we cannot
+                * measure service response time */
+            return 0;
+        }
+
+        else if(mi->trx->initial->framenum != mi->msg->framenum){
+            /* Duplicate is ignored */
+            ms->time_stats[0].req_dup_num++;
+        }
+        else {
+            ms->time_stats[0].open_req_num++;
+        }
+        break;
+
+    GCP_CMD_REPLY_CASE
+        if(megacostat_is_duplicate_reply(mi)){
+            /* Duplicate is ignored */
+            ms->time_stats[0].rsp_dup_num++;
+        }
+        else if (!megacostat_had_request(mi)) {
+            /* no request was seen */
+            ms->time_stats[0].disc_rsp_num++;
+        }
+        else {
+            ms->time_stats[0].open_req_num--;
+            /* calculate time delta between request and response */
+            nstime_delta(&delta, &pinfo->fd->abs_ts, &mi->trx->initial->time);
+
+            switch(mi->type) {
+
+            case GCP_CMD_ADD_REPLY:
+                time_stat_update(&(ms->time_stats[0].rtd[0]),&delta, pinfo);
+                break;
+            case GCP_CMD_MOVE_REPLY:
+                time_stat_update(&(ms->time_stats[0].rtd[1]),&delta, pinfo);
+                break;
+            case GCP_CMD_MOD_REPLY:
+                time_stat_update(&(ms->time_stats[0].rtd[2]),&delta, pinfo);
+                break;
+            case GCP_CMD_SUB_REPLY:
+                time_stat_update(&(ms->time_stats[0].rtd[3]),&delta, pinfo);
+                break;
+            case GCP_CMD_AUDITCAP_REPLY:
+                time_stat_update(&(ms->time_stats[0].rtd[4]),&delta, pinfo);
+                break;
+            case GCP_CMD_AUDITVAL_REPLY:
+                time_stat_update(&(ms->time_stats[0].rtd[5]),&delta, pinfo);
+                break;
+            case GCP_CMD_NOTIFY_REPLY:
+                time_stat_update(&(ms->time_stats[0].rtd[6]),&delta, pinfo);
+                break;
+            case GCP_CMD_SVCCHG_REPLY:
+                time_stat_update(&(ms->time_stats[0].rtd[7]),&delta, pinfo);
+                break;
+            case GCP_CMD_TOPOLOGY_REPLY:
+                time_stat_update(&(ms->time_stats[0].rtd[8]),&delta, pinfo);
+                break;
+            case GCP_CMD_REPLY:
+                time_stat_update(&(ms->time_stats[0].rtd[9]),&delta, pinfo);
+                break;
+            default:
+                time_stat_update(&(ms->time_stats[0].rtd[11]),&delta, pinfo);
+            }
+
+            time_stat_update(&(ms->time_stats[0].rtd[10]),&delta, pinfo);
+            ret = 1;
+        }
+        break;
+
+    default:
+        break;
+    }
+
+    return ret;
+}
+
+
 /*
 * The various functions that either dissect some
 * subpart of MEGACO.  These aren't really proto dissectors but they
@@ -3575,6 +3786,7 @@ proto_register_megaco(void)
     ws_mempbrk_compile(&pbrk_whitespace, " \t\r\n");
     ws_mempbrk_compile(&pbrk_braces, "{}");
 
+    register_rtd_table(proto_megaco, NULL, 1, NUM_TIMESTATS, megaco_message_type, megacostat_packet, megacostat_filtercheck);
 }
 
 /* Register all the bits needed with the filtering engine */
diff --git a/epan/dissectors/packet-mgcp.c b/epan/dissectors/packet-mgcp.c
index aabe2a3915..21b5fdfdbb 100644
--- a/epan/dissectors/packet-mgcp.c
+++ b/epan/dissectors/packet-mgcp.c
@@ -42,6 +42,7 @@
 #include <epan/prefs.h>
 #include <epan/conversation.h>
 #include <epan/tap.h>
+#include <epan/rtd_table.h>
 #include "packet-mgcp.h"
 
 
@@ -279,6 +280,102 @@ static void dissect_mgcp_localconnectionoptions(proto_tree *parent_tree, tvbuff_
 
 static void mgcp_raw_text_add(tvbuff_t *tvb, proto_tree *tree);
 
+#define NUM_TIMESTATS 11
+
+static const value_string mgcp_mesage_type[] = {
+	{  0, "Overall"},
+	{  1, "EPCF   "},
+	{  2, "CRCX   "},
+	{  3, "MDCX   "},
+	{  4, "DLCX   "},
+	{  5, "RQNT   "},
+	{  6, "NTFY   "},
+	{  7, "AUEP   "},
+	{  8, "AUCX   "},
+	{  9, "RSIP   "},
+	{  0, NULL}
+};
+
+static int
+mgcpstat_packet(void *pms, packet_info *pinfo, epan_dissect_t *edt _U_, const void *pmi)
+{
+	rtd_data_t* rtd_data = (rtd_data_t*)pms;
+	rtd_stat_table* ms = &rtd_data->stat_table;
+	const mgcp_info_t *mi = (const mgcp_info_t *)pmi;
+	nstime_t delta;
+	int ret = 0;
+
+	switch (mi->mgcp_type) {
+
+	case MGCP_REQUEST:
+		if (mi->is_duplicate) {
+			/* Duplicate is ignored */
+			ms->time_stats[0].req_dup_num++;
+		}
+		else {
+			ms->time_stats[0].open_req_num++;
+		}
+		break;
+
+	case MGCP_RESPONSE:
+		if (mi->is_duplicate) {
+			/* Duplicate is ignored */
+			ms->time_stats[0].rsp_dup_num++;
+		}
+		else if (!mi->request_available) {
+			/* no request was seen */
+			ms->time_stats[0].disc_rsp_num++;
+		}
+		else {
+			ms->time_stats[0].open_req_num--;
+			/* calculate time delta between request and response */
+			nstime_delta(&delta, &pinfo->fd->abs_ts, &mi->req_time);
+
+			time_stat_update(&(ms->time_stats[0].rtd[0]), &delta, pinfo);
+
+			if (g_ascii_strncasecmp(mi->code, "EPCF", 4) == 0 ) {
+				time_stat_update(&(ms->time_stats[0].rtd[1]), &delta, pinfo);
+			}
+			else if (g_ascii_strncasecmp(mi->code, "CRCX", 4) == 0 ) {
+				time_stat_update(&(ms->time_stats[0].rtd[2]), &delta, pinfo);
+			}
+			else if (g_ascii_strncasecmp(mi->code, "MDCX", 4) == 0 ) {
+				time_stat_update(&(ms->time_stats[0].rtd[3]), &delta, pinfo);
+			}
+			else if (g_ascii_strncasecmp(mi->code, "DLCX", 4) == 0 ) {
+				time_stat_update(&(ms->time_stats[0].rtd[4]), &delta, pinfo);
+			}
+			else if (g_ascii_strncasecmp(mi->code, "RQNT", 4) == 0 ) {
+				time_stat_update(&(ms->time_stats[0].rtd[5]), &delta, pinfo);
+			}
+			else if (g_ascii_strncasecmp(mi->code, "NTFY", 4) == 0 ) {
+				time_stat_update(&(ms->time_stats[0].rtd[6]), &delta, pinfo);
+			}
+			else if (g_ascii_strncasecmp(mi->code, "AUEP", 4) == 0 ) {
+				time_stat_update(&(ms->time_stats[0].rtd[7]), &delta, pinfo);
+			}
+			else if (g_ascii_strncasecmp(mi->code, "AUCX", 4) == 0 ) {
+				time_stat_update(&(ms->time_stats[0].rtd[8]), &delta, pinfo);
+			}
+			else if (g_ascii_strncasecmp(mi->code, "RSIP", 4) == 0 ) {
+				time_stat_update(&(ms->time_stats[0].rtd[9]), &delta, pinfo);
+			}
+			else {
+				time_stat_update(&(ms->time_stats[0].rtd[10]), &delta, pinfo);
+			}
+
+			ret = 1;
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	return ret;
+}
+
+
 /*
  * Some functions which should be moved to a library
  * as I think that people may find them of general usefulness.
@@ -2258,6 +2355,8 @@ void proto_register_mgcp(void)
 				       &global_mgcp_message_count);
 
 	mgcp_tap = register_tap("mgcp");
+
+	register_rtd_table(proto_mgcp, NULL, 1, NUM_TIMESTATS, mgcp_mesage_type, mgcpstat_packet, NULL);
 }
 
 /* The registration hand-off routine */
diff --git a/epan/dissectors/packet-radius.c b/epan/dissectors/packet-radius.c
index 2f02fa4a09..dc5176ee46 100644
--- a/epan/dissectors/packet-radius.c
+++ b/epan/dissectors/packet-radius.c
@@ -63,6 +63,7 @@
 #include <epan/sminmpec.h>
 #include <epan/conversation.h>
 #include <epan/tap.h>
+#include <epan/rtd_table.h>
 #include <epan/addr_resolv.h>
 #include <wsutil/filesystem.h>
 #include <wsutil/report_err.h>
@@ -212,6 +213,150 @@ static const value_string radius_pkt_type_codes[] =
 };
 static value_string_ext radius_pkt_type_codes_ext = VALUE_STRING_EXT_INIT(radius_pkt_type_codes);
 
+typedef enum _radius_category {
+	RADIUS_CAT_OVERALL = 0,
+	RADIUS_CAT_ACCESS,
+	RADIUS_CAT_ACCOUNTING,
+	RADIUS_CAT_PASSWORD,
+	RADIUS_CAT_RESOURCE_FREE,
+	RADIUS_CAT_RESOURCE_QUERY,
+	RADIUS_CAT_NAS_REBOOT,
+	RADIUS_CAT_EVENT,
+	RADIUS_CAT_DISCONNECT,
+	RADIUS_CAT_COA,
+	RADIUS_CAT_OTHERS,
+	RADIUS_CAT_NUM_TIMESTATS
+} radius_category;
+
+static const value_string radius_message_code[] = {
+	{  RADIUS_CAT_OVERALL,        "Overall"},
+	{  RADIUS_CAT_ACCESS,         "Access"},
+	{  RADIUS_CAT_ACCOUNTING,     "Accounting"},
+	{  RADIUS_CAT_PASSWORD,       "Password"},
+	{  RADIUS_CAT_RESOURCE_FREE,  "Resource Free"},
+	{  RADIUS_CAT_RESOURCE_QUERY, "Resource Query"},
+	{  RADIUS_CAT_NAS_REBOOT,     "NAS Reboot"},
+	{  RADIUS_CAT_EVENT,          "Event"},
+	{  RADIUS_CAT_DISCONNECT,     "Disconnect"},
+	{  RADIUS_CAT_COA,            "CoA"},
+	{  RADIUS_CAT_OTHERS,         "Other"},
+	{  0, NULL}
+};
+
+static int
+radiusstat_packet(void *prs, packet_info *pinfo, epan_dissect_t *edt _U_, const void *pri)
+{
+	rtd_data_t* rtd_data = (rtd_data_t*)prs;
+	rtd_stat_table* rs = &rtd_data->stat_table;
+	const radius_info_t *ri=(radius_info_t *)pri;
+	nstime_t delta;
+	radius_category radius_cat = RADIUS_CAT_OTHERS;
+	int ret = 0;
+
+	switch (ri->code) {
+		case RADIUS_PKT_TYPE_ACCESS_REQUEST:
+		case RADIUS_PKT_TYPE_ACCESS_ACCEPT:
+		case RADIUS_PKT_TYPE_ACCESS_REJECT:
+			radius_cat = RADIUS_CAT_ACCESS;
+			break;
+		case RADIUS_PKT_TYPE_ACCOUNTING_REQUEST:
+		case RADIUS_PKT_TYPE_ACCOUNTING_RESPONSE:
+			radius_cat = RADIUS_CAT_ACCOUNTING;
+			break;
+		case RADIUS_PKT_TYPE_PASSWORD_REQUEST:
+		case RADIUS_PKT_TYPE_PASSWORD_ACK:
+		case RADIUS_PKT_TYPE_PASSWORD_REJECT:
+			radius_cat = RADIUS_CAT_PASSWORD;
+			break;
+		case RADIUS_PKT_TYPE_RESOURCE_FREE_REQUEST:
+		case RADIUS_PKT_TYPE_RESOURCE_FREE_RESPONSE:
+			radius_cat = RADIUS_CAT_RESOURCE_FREE;
+			break;
+		case RADIUS_PKT_TYPE_RESOURCE_QUERY_REQUEST:
+		case RADIUS_PKT_TYPE_RESOURCE_QUERY_RESPONSE:
+			radius_cat = RADIUS_CAT_RESOURCE_QUERY;
+			break;
+		case RADIUS_PKT_TYPE_NAS_REBOOT_REQUEST:
+		case RADIUS_PKT_TYPE_NAS_REBOOT_RESPONSE:
+			radius_cat = RADIUS_CAT_NAS_REBOOT;
+			break;
+		case RADIUS_PKT_TYPE_EVENT_REQUEST:
+		case RADIUS_PKT_TYPE_EVENT_RESPONSE:
+			radius_cat = RADIUS_CAT_EVENT;
+			break;
+		case RADIUS_PKT_TYPE_DISCONNECT_REQUEST:
+		case RADIUS_PKT_TYPE_DISCONNECT_ACK:
+		case RADIUS_PKT_TYPE_DISCONNECT_NAK:
+			radius_cat = RADIUS_CAT_DISCONNECT;
+			break;
+		case RADIUS_PKT_TYPE_COA_REQUEST:
+		case RADIUS_PKT_TYPE_COA_ACK:
+		case RADIUS_PKT_TYPE_COA_NAK:
+			radius_cat = RADIUS_CAT_COA;
+			break;
+	}
+
+	switch (ri->code) {
+
+	case RADIUS_PKT_TYPE_ACCESS_REQUEST:
+	case RADIUS_PKT_TYPE_ACCOUNTING_REQUEST:
+	case RADIUS_PKT_TYPE_PASSWORD_REQUEST:
+	case RADIUS_PKT_TYPE_EVENT_REQUEST:
+	case RADIUS_PKT_TYPE_DISCONNECT_REQUEST:
+	case RADIUS_PKT_TYPE_COA_REQUEST:
+		if(ri->is_duplicate){
+			/* Duplicate is ignored */
+			rs->time_stats[RADIUS_CAT_OVERALL].req_dup_num++;
+			rs->time_stats[radius_cat].req_dup_num++;
+		}
+		else {
+			rs->time_stats[RADIUS_CAT_OVERALL].open_req_num++;
+			rs->time_stats[radius_cat].open_req_num++;
+		}
+		break;
+
+	case RADIUS_PKT_TYPE_ACCESS_ACCEPT:
+	case RADIUS_PKT_TYPE_ACCESS_REJECT:
+	case RADIUS_PKT_TYPE_ACCOUNTING_RESPONSE:
+	case RADIUS_PKT_TYPE_PASSWORD_ACK:
+	case RADIUS_PKT_TYPE_PASSWORD_REJECT:
+	case RADIUS_PKT_TYPE_EVENT_RESPONSE:
+	case RADIUS_PKT_TYPE_DISCONNECT_ACK:
+	case RADIUS_PKT_TYPE_DISCONNECT_NAK:
+	case RADIUS_PKT_TYPE_COA_ACK:
+	case RADIUS_PKT_TYPE_COA_NAK:
+		if(ri->is_duplicate){
+			/* Duplicate is ignored */
+			rs->time_stats[RADIUS_CAT_OVERALL].rsp_dup_num++;
+			rs->time_stats[radius_cat].rsp_dup_num++;
+		}
+		else if (!ri->request_available) {
+			/* no request was seen */
+			rs->time_stats[RADIUS_CAT_OVERALL].disc_rsp_num++;
+			rs->time_stats[radius_cat].disc_rsp_num++;
+		}
+		else {
+			rs->time_stats[RADIUS_CAT_OVERALL].open_req_num--;
+			rs->time_stats[radius_cat].open_req_num--;
+			/* calculate time delta between request and response */
+			nstime_delta(&delta, &pinfo->fd->abs_ts, &ri->req_time);
+
+			time_stat_update(&(rs->time_stats[RADIUS_CAT_OVERALL].rtd[0]),&delta, pinfo);
+			time_stat_update(&(rs->time_stats[radius_cat].rtd[0]),&delta, pinfo);
+
+			ret = 1;
+		}
+		break;
+
+	default:
+		break;
+	}
+
+	return ret;
+}
+
+
+
 /*
  * Init Hash table stuff for conversation
  */
@@ -2130,6 +2275,8 @@ proto_register_radius(void)
 	dict->vendors_by_id   = g_hash_table_new(g_direct_hash,g_direct_equal);
 	dict->vendors_by_name = g_hash_table_new(g_str_hash,g_str_equal);
 	dict->tlvs_by_name    = g_hash_table_new(g_str_hash,g_str_equal);
+
+	register_rtd_table(proto_radius, NULL, RADIUS_CAT_NUM_TIMESTATS, 1, radius_message_code, radiusstat_packet, NULL);
 }
 
 void