f3610bb65e9a4ad7e548756d51a94b151998c544
[obnox/wireshark/wip.git] / gtk / gtp_stat.c
1 /* gtp_stat.c
2  * gtp_stat   2008 Kari Tiirikainen
3  * Largely based on ldap_stat by Ronnie Sahlberg, all mistakes added by KTi
4  *
5  * $Id$
6  *
7  * Wireshark - Network traffic analyzer
8  * By Gerald Combs <gerald@wireshark.org>
9  * Copyright 1998 Gerald Combs
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License
13  * as published by the Free Software Foundation; either version 2
14  * of the License, or (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
24  */
25
26 #ifdef HAVE_CONFIG_H
27 # include "config.h"
28 #endif
29
30 #ifdef HAVE_SYS_TYPES_H
31 # include <sys/types.h>
32 #endif
33
34 #include <string.h>
35
36 #include <gtk/gtk.h>
37
38 #include <epan/packet_info.h>
39 #include <epan/epan.h>
40 #include <epan/value_string.h>
41 #include <epan/tap.h>
42 #include <epan/dissectors/packet-gtp.h>
43
44 #include "../timestats.h"
45 #include "../simple_dialog.h"
46 #include "../file.h"
47 #include "../stat_menu.h"
48
49 #include "gtk/gui_utils.h"
50 #include "gtk/dlg_utils.h"
51 #include "gtk/filter_dlg.h"
52 #include "gtk/service_response_time_table.h"
53 #include "gtk/tap_dfilter_dlg.h"
54 #include "gtk/gtkglobals.h"
55 #include "gtk/main.h"
56
57 /* used to keep track of the statistics for an entire program interface */
58 typedef struct _gtpstat_t {
59         GtkWidget *win;
60         srt_stat_table gtp_srt_table;
61 } gtpstat_t;
62
63 static void
64 gtpstat_set_title(gtpstat_t *gtp)
65 {
66         char            *title;
67
68         title = g_strdup_printf("GTP Control Plane  Response Time statistics: %s",
69             cf_get_display_name(&cfile));
70         gtk_window_set_title(GTK_WINDOW(gtp->win), title);
71         g_free(title);
72 }
73
74 static void
75 gtpstat_reset(void *pgtp)
76 {
77         gtpstat_t *gtp=(gtpstat_t *)pgtp;
78
79         reset_srt_table_data(&gtp->gtp_srt_table);
80         gtpstat_set_title(gtp);
81 }
82
83 static int
84 gtpstat_packet(void *pgtp, packet_info *pinfo, epan_dissect_t *edt _U_, const void *psi)
85 {
86         const gtp_msg_hash_t *gtp=psi;
87         gtpstat_t *fs=(gtpstat_t *)pgtp;
88         int idx=0;
89
90         /* we are only interested in reply packets */
91         if(gtp->is_request){
92                 return 0;
93         }
94         /* if we have not seen the request, just ignore it */
95         if(!gtp->req_frame){
96                 return 0;
97         }
98
99         /* Only use the commands we know how to handle, this is not a comprehensive list */
100         /* Redoing the message indexing is bit reduntant,                    */
101         /*  but using message type as such would yield a long gtp_srt_table. */
102         /*  Only a fraction of the messages are matchable req/resp pairs,    */
103         /*  it just doesn't feel feasible.                                   */
104
105         switch(gtp->msgtype){
106         case GTP_MSG_ECHO_REQ: idx=0;
107                 break;
108         case GTP_MSG_CREATE_PDP_REQ: idx=1;
109                 break;
110         case GTP_MSG_UPDATE_PDP_REQ: idx=2;
111                 break;
112         case GTP_MSG_DELETE_PDP_REQ: idx=3;
113                 break;
114         default:
115                 return 0;
116         }
117
118         add_srt_table_data(&fs->gtp_srt_table, idx, &gtp->req_time, pinfo);
119
120         return 1;
121 }
122
123
124
125 static void
126 gtpstat_draw(void *pgtp)
127 {
128         gtpstat_t *gtp=(gtpstat_t *)pgtp;
129
130         draw_srt_table_data(&gtp->gtp_srt_table);
131 }
132
133
134 static void
135 win_destroy_cb(GtkWindow *win _U_, gpointer data)
136 {
137         gtpstat_t *gtp=(gtpstat_t *)data;
138
139         protect_thread_critical_region();
140         remove_tap_listener(gtp);
141         unprotect_thread_critical_region();
142
143         free_srt_table_data(&gtp->gtp_srt_table);
144         g_free(gtp);
145 }
146
147
148 static void
149 gtk_gtpstat_init(const char *optarg, void *userdata _U_)
150 {
151         gtpstat_t *gtp;
152         const char *filter=NULL;
153         GtkWidget *label;
154         char *filter_string;
155         GString *error_string;
156         GtkWidget *vbox;
157         GtkWidget *bbox;
158         GtkWidget *close_bt;
159
160         if(!strncmp(optarg,"gtp,",4)){
161                 filter=optarg+4;
162         } else {
163                 filter="gtp"; /*NULL doesn't work here like in LDAP. Too little time/lazy to find out why ?*/
164         }
165
166         gtp=g_malloc(sizeof(gtpstat_t));
167
168         gtp->win = dlg_window_new("gtp-stat");  /* transient_for top_level */
169         gtk_window_set_destroy_with_parent (GTK_WINDOW(gtp->win), TRUE);
170
171         gtk_window_set_default_size(GTK_WINDOW(gtp->win), 550, 400);
172         gtpstat_set_title(gtp);
173
174         vbox=gtk_vbox_new(FALSE, 3);
175         gtk_container_add(GTK_CONTAINER(gtp->win), vbox);
176         gtk_container_set_border_width(GTK_CONTAINER(vbox), 12);
177
178         label=gtk_label_new("GTP Service Response Time statistics");
179         gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
180
181         filter_string = g_strdup_printf("Filter: %s", filter ? filter : "");
182         label=gtk_label_new(filter_string);
183         g_free(filter_string);
184         gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
185         gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
186
187         label=gtk_label_new("GTP Requests");
188         gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
189
190         /* We must display TOP LEVEL Widget before calling init_srt_table() */
191         gtk_widget_show_all(gtp->win);
192
193         init_srt_table(&gtp->gtp_srt_table, 4, vbox, NULL);
194         init_srt_table_row(&gtp->gtp_srt_table, 0, "Echo");
195         init_srt_table_row(&gtp->gtp_srt_table, 1, "Create PDP context");
196         init_srt_table_row(&gtp->gtp_srt_table, 2, "Update PDP context");
197         init_srt_table_row(&gtp->gtp_srt_table, 3, "Delete PDP context");
198
199         error_string=register_tap_listener("gtp", gtp, filter, 0, gtpstat_reset, gtpstat_packet, gtpstat_draw);
200         if(error_string){
201                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
202                 g_string_free(error_string, TRUE);
203                 g_free(gtp);
204                 return;
205         }
206
207         /* Button row. */
208         bbox = dlg_button_row_new(GTK_STOCK_CLOSE, NULL);
209         gtk_box_pack_end(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
210
211         close_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
212         window_set_cancel_button(gtp->win, close_bt, window_cancel_button_cb);
213
214         g_signal_connect(gtp->win, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
215         g_signal_connect(gtp->win, "destroy", G_CALLBACK(win_destroy_cb), gtp);
216
217         gtk_widget_show_all(gtp->win);
218         window_present(gtp->win);
219
220         cf_retap_packets(&cfile);
221         gdk_window_raise(gtp->win->window);
222 }
223
224 static tap_param gtp_stat_params[] = {
225         { PARAM_FILTER, "Filter", NULL }
226 };
227
228 static tap_param_dlg gtp_stat_dlg = {
229         "GTP Control Plane Response Time Statistics",
230         "gtp",
231         gtk_gtpstat_init,
232         -1,
233         G_N_ELEMENTS(gtp_stat_params),
234         gtp_stat_params
235 };
236
237 void
238 register_tap_listener_gtkgtpstat(void)
239 {
240         register_dfilter_stat(&gtp_stat_dlg, "GTP",
241             REGISTER_STAT_GROUP_RESPONSE_TIME);
242 }