967f9d9260bd71ac8b9b9b6e732f22561d5caee2
[obnox/wireshark/wip.git] / tap-mgcpstat.c
1 /* tap-mgcpstat.c
2  * mgcpstat   2003 Lars Roland
3  *
4  * $Id$
5  *
6  * Wireshark - Network traffic analyzer
7  * By Gerald Combs <gerald@wireshark.org>
8  * Copyright 1998 Gerald Combs
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  */
24
25 #ifdef HAVE_CONFIG_H
26 # include "config.h"
27 #endif
28
29 #include <stdio.h>
30
31 #ifdef HAVE_SYS_TYPES_H
32 # include <sys/types.h>
33 #endif
34
35 #include <string.h>
36 #include "epan/packet_info.h"
37 #include <epan/tap.h>
38 #include <epan/stat_cmd_args.h>
39 #include "epan/value_string.h"
40 #include "register.h"
41 #include "epan/dissectors/packet-mgcp.h"
42 #include "timestats.h"
43
44 #ifdef NEED_G_ASCII_STRCASECMP_H
45 #include "epan/g_ascii_strcasecmp.h"
46 #endif
47
48 #define NUM_TIMESTATS 11
49
50 /* used to keep track of the statistics for an entire program interface */
51 typedef struct _mgcpstat_t {
52         char *filter;
53         timestat_t rtd[NUM_TIMESTATS];
54         guint32 open_req_num;
55         guint32 disc_rsp_num;
56         guint32 req_dup_num;
57         guint32 rsp_dup_num;
58 } mgcpstat_t;
59
60 static const value_string mgcp_mesage_type[] = {
61   {  0, "Overall"},
62   {  1, "EPCF   "},
63   {  2, "CRCX   "},
64   {  3, "MDCX   "},
65   {  4, "DLCX   "},
66   {  5, "RQNT   "},
67   {  6, "NTFY   "},
68   {  7, "AUEP   "},
69   {  8, "AUCX   "},
70   {  9, "RSIP   "},
71 };
72
73 static int
74 mgcpstat_packet(void *pms, packet_info *pinfo, epan_dissect_t *edt _U_, const void *pmi)
75 {
76         mgcpstat_t *ms=(mgcpstat_t *)pms;
77         const mgcp_info_t *mi=pmi;
78         nstime_t delta;
79
80         switch (mi->mgcp_type) {
81
82         case MGCP_REQUEST:
83                 if(mi->is_duplicate){
84                         /* Duplicate is ignored */
85                         ms->req_dup_num++;
86                         return 0;
87                 }
88                 else {
89                         ms->open_req_num++;
90                         return 0;
91                 }
92         break;
93
94         case MGCP_RESPONSE:
95                 if(mi->is_duplicate){
96                         /* Duplicate is ignored */
97                         ms->rsp_dup_num++;
98                         return 0;
99                 }
100                 else if (!mi->request_available) {
101                         /* no request was seen */
102                         ms->disc_rsp_num++;
103                         return 0;
104                 }
105                 else {
106                         ms->open_req_num--;
107                         /* calculate time delta between request and response */
108                         nstime_delta(&delta, &pinfo->fd->abs_ts, &mi->req_time);
109
110                         time_stat_update(&(ms->rtd[0]),&delta, pinfo);
111
112                         if (g_ascii_strncasecmp(mi->code, "EPCF", 4) == 0 ) {
113                                 time_stat_update(&(ms->rtd[1]),&delta, pinfo);
114                         }
115                         else if (g_ascii_strncasecmp(mi->code, "CRCX", 4) == 0 ) {
116                                 time_stat_update(&(ms->rtd[2]),&delta, pinfo);
117                         }
118                         else if (g_ascii_strncasecmp(mi->code, "MDCX", 4) == 0 ) {
119                                 time_stat_update(&(ms->rtd[3]),&delta, pinfo);
120                         }
121                         else if (g_ascii_strncasecmp(mi->code, "DLCX", 4) == 0 ) {
122                                 time_stat_update(&(ms->rtd[4]),&delta, pinfo);
123                         }
124                         else if (g_ascii_strncasecmp(mi->code, "RQNT", 4) == 0 ) {
125                                 time_stat_update(&(ms->rtd[5]),&delta, pinfo);
126                         }
127                         else if (g_ascii_strncasecmp(mi->code, "NTFY", 4) == 0 ) {
128                                 time_stat_update(&(ms->rtd[6]),&delta, pinfo);
129                         }
130                         else if (g_ascii_strncasecmp(mi->code, "AUEP", 4) == 0 ) {
131                                 time_stat_update(&(ms->rtd[7]),&delta, pinfo);
132                         }
133                         else if (g_ascii_strncasecmp(mi->code, "AUCX", 4) == 0 ) {
134                                 time_stat_update(&(ms->rtd[8]),&delta, pinfo);
135                         }
136                         else if (g_ascii_strncasecmp(mi->code, "RSIP", 4) == 0 ) {
137                                 time_stat_update(&(ms->rtd[9]),&delta, pinfo);
138                         }
139                         else {
140                                 time_stat_update(&(ms->rtd[10]),&delta, pinfo);
141                         }
142
143                         return 1;
144                 }
145         break;
146
147         default:
148                 return 0;
149         break;
150         }
151 }
152
153 static void
154 mgcpstat_draw(void *pms)
155 {
156         mgcpstat_t *ms=(mgcpstat_t *)pms;
157         int i;
158
159         /* printing results */
160         printf("\n");
161         printf("=====================================================================================================\n");
162         printf("MGCP Response Time Delay (RTD) Statistics:\n");
163         printf("Filter for statistics: %s\n",ms->filter?ms->filter:"");
164         printf("Duplicate requests: %u\n",ms->req_dup_num);
165         printf("Duplicate responses: %u\n",ms->rsp_dup_num);
166         printf("Open requests: %u\n",ms->open_req_num);
167         printf("Discarded responses: %u\n",ms->disc_rsp_num);
168         printf("Type    | Messages   |    Min RTD    |    Max RTD    |    Avg RTD    | Min in Frame | Max in Frame |\n");
169         for(i=0;i<NUM_TIMESTATS;i++) {
170                 if(ms->rtd[i].num) {
171                         printf("%s | %7u    | %8.2f msec | %8.2f msec | %8.2f msec |  %10u  |  %10u  |\n",
172                                 val_to_str(i,mgcp_mesage_type,"Other  "),ms->rtd[i].num,
173                                 nstime_to_msec(&(ms->rtd[i].min)), nstime_to_msec(&(ms->rtd[i].max)),
174                                 get_average(&(ms->rtd[i].tot), ms->rtd[i].num),
175                                 ms->rtd[i].min_num, ms->rtd[i].max_num
176                         );
177                 }
178         }
179         printf("=====================================================================================================\n");
180 }
181
182
183 static void
184 mgcpstat_init(const char *optarg, void* userdata _U_)
185 {
186         mgcpstat_t *ms;
187         int i;
188         const char *filter=NULL;
189         GString *error_string;
190
191         if(!strncmp(optarg,"mgcp,rtd,",9)){
192                 filter=optarg+9;
193         } else {
194                 filter="";
195         }
196
197         ms=g_malloc(sizeof(mgcpstat_t));
198         ms->filter=g_strdup(filter);
199
200         for(i=0;i<NUM_TIMESTATS;i++) {
201                 ms->rtd[i].num=0;
202                 ms->rtd[i].min_num=0;
203                 ms->rtd[i].max_num=0;
204                 ms->rtd[i].min.secs=0;
205                 ms->rtd[i].min.nsecs=0;
206                 ms->rtd[i].max.secs=0;
207                 ms->rtd[i].max.nsecs=0;
208                 ms->rtd[i].tot.secs=0;
209                 ms->rtd[i].tot.nsecs=0;
210         }
211
212         ms->open_req_num=0;
213         ms->disc_rsp_num=0;
214         ms->req_dup_num=0;
215         ms->rsp_dup_num=0;
216
217         error_string=register_tap_listener("mgcp", ms, filter, NULL, mgcpstat_packet, mgcpstat_draw);
218         if(error_string){
219                 /* error, we failed to attach to the tap. clean up */
220                 g_free(ms->filter);
221                 g_free(ms);
222
223                 fprintf(stderr, "tshark: Couldn't register mgcp,rtd tap: %s\n",
224                     error_string->str);
225                 g_string_free(error_string, TRUE);
226                 exit(1);
227         }
228 }
229
230
231 void
232 register_tap_listener_mgcpstat(void)
233 {
234         /* We don't register this tap, if we don't have the mgcp plugin loaded.*/
235         if (find_tap_id("mgcp")) {
236                 register_stat_cmd_arg("mgcp,rtd", mgcpstat_init, NULL);
237         }
238 }
239