ui/gtk/radius_stat.c

   1 /* radius_stat.c
   2  * radius-statistics for Wireshark
   3  * Copyright 2006 Alejandro Vaquero <alejandrovaquero@yahoo.com>
   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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  24  */
  25
  26 #include "config.h"
  27
  28 #include <string.h>
  29
  30 #include <gtk/gtk.h>
  31
  32 #include <epan/packet_info.h>
  33 #include <epan/epan.h>
  34 #include <epan/value_string.h>
  35 #include <epan/tap.h>
  36 #include <epan/dissectors/packet-radius.h>
  37
  38 #include "epan/timestats.h"
  39 #include "ui/simple_dialog.h"
  40 #include "../file.h"
  41 #include "../stat_menu.h"
  42
  43 #include "ui/gtk/gui_stat_util.h"
  44 #include "ui/gtk/dlg_utils.h"
  45 #include "ui/gtk/tap_param_dlg.h"
  46 #include "ui/gtk/gui_utils.h"
  47 #include "ui/gtk/main.h"
  48
  49 #include "ui/gtk/old-gtk-compat.h"
  50
  51 #define NUM_COLUMNS 11
  52
  53 typedef enum _radius_category {
  54         RADIUS_CAT_OVERALL = 0,
  55         RADIUS_CAT_ACCESS,
  56         RADIUS_CAT_ACCOUNTING,
  57         RADIUS_CAT_PASSWORD,
  58         RADIUS_CAT_RESOURCE_FREE,
  59         RADIUS_CAT_RESOURCE_QUERY,
  60         RADIUS_CAT_NAS_REBOOT,
  61         RADIUS_CAT_EVENT,
  62         RADIUS_CAT_DISCONNECT,
  63         RADIUS_CAT_COA,
  64         RADIUS_CAT_OTHERS,
  65         RADIUS_CAT_NUM_TIMESTATS
  66 } radius_category;
  67
  68 /* Summary of response-time calculations*/
  69 typedef struct _radius_rtd_t {
  70         guint32 open_req_num;
  71         guint32 disc_rsp_num;
  72         guint32 req_dup_num;
  73         guint32 rsp_dup_num;
  74         timestat_t stats;
  75 } radius_rtd_t;
  76
  77 /* used to keep track of the statistics for an entire program interface */
  78 typedef struct _radiusstat_t {
  79         GtkWidget *win;
  80         GtkWidget *vbox;
  81         char *filter;
  82         GtkWidget *scrolled_window;
  83         GtkTreeView *table;
  84         radius_rtd_t radius_rtd[RADIUS_CAT_NUM_TIMESTATS];
  85 } radiusstat_t;
  86
  87 static const value_string radius_message_code[] = {
  88         {  RADIUS_CAT_OVERALL,        "Overall"},
  89         {  RADIUS_CAT_ACCESS,         "Access"},
  90         {  RADIUS_CAT_ACCOUNTING,     "Accounting"},
  91         {  RADIUS_CAT_PASSWORD,       "Password"},
  92         {  RADIUS_CAT_RESOURCE_FREE,  "Resource Free"},
  93         {  RADIUS_CAT_RESOURCE_QUERY, "Resource Query"},
  94         {  RADIUS_CAT_NAS_REBOOT,     "NAS Reboot"},
  95         {  RADIUS_CAT_EVENT,          "Event"},
  96         {  RADIUS_CAT_DISCONNECT,     "Disconnect"},
  97         {  RADIUS_CAT_COA,            "CoA"},
  98         {  RADIUS_CAT_OTHERS,         "Other"},
  99         {  0, NULL}
 100 };
 101
 102 static void
 103 radiusstat_reset(void *prs)
 104 {
 105         radiusstat_t *rs=(radiusstat_t *)prs;
 106         int i;
 107
 108
 109         for(i=0; i<RADIUS_CAT_NUM_TIMESTATS; i++) {
 110                 rs->radius_rtd[i].stats.num=0;
 111                 rs->radius_rtd[i].stats.min_num=0;
 112                 rs->radius_rtd[i].stats.max_num=0;
 113                 rs->radius_rtd[i].stats.min.secs=0;
 114                 rs->radius_rtd[i].stats.min.nsecs=0;
 115                 rs->radius_rtd[i].stats.max.secs=0;
 116                 rs->radius_rtd[i].stats.max.nsecs=0;
 117                 rs->radius_rtd[i].stats.tot.secs=0;
 118                 rs->radius_rtd[i].stats.tot.nsecs=0;
 119                 rs->radius_rtd[i].open_req_num = 0;
 120                 rs->radius_rtd[i].disc_rsp_num = 0;
 121                 rs->radius_rtd[i].req_dup_num = 0;
 122                 rs->radius_rtd[i].rsp_dup_num = 0;
 123         }
 124
 125 }
 126
 127
 128 static int
 129 radiusstat_packet(void *prs, packet_info *pinfo, epan_dissect_t *edt _U_, const void *pri)
 130 {
 131         radiusstat_t *rs=(radiusstat_t *)prs;
 132         const radius_info_t *ri=(radius_info_t *)pri;
 133         nstime_t delta;
 134         radius_category radius_cat = RADIUS_CAT_OTHERS;
 135         int ret = 0;
 136
 137         switch (ri->code) {
 138                 case RADIUS_PKT_TYPE_ACCESS_REQUEST:
 139                 case RADIUS_PKT_TYPE_ACCESS_ACCEPT:
 140                 case RADIUS_PKT_TYPE_ACCESS_REJECT:
 141                         radius_cat = RADIUS_CAT_ACCESS;
 142                         break;
 143                 case RADIUS_PKT_TYPE_ACCOUNTING_REQUEST:
 144                 case RADIUS_PKT_TYPE_ACCOUNTING_RESPONSE:
 145                         radius_cat = RADIUS_CAT_ACCOUNTING;
 146                         break;
 147                 case RADIUS_PKT_TYPE_PASSWORD_REQUEST:
 148                 case RADIUS_PKT_TYPE_PASSWORD_ACK:
 149                 case RADIUS_PKT_TYPE_PASSWORD_REJECT:
 150                         radius_cat = RADIUS_CAT_PASSWORD;
 151                         break;
 152                 case RADIUS_PKT_TYPE_RESOURCE_FREE_REQUEST:
 153                 case RADIUS_PKT_TYPE_RESOURCE_FREE_RESPONSE:
 154                         radius_cat = RADIUS_CAT_RESOURCE_FREE;
 155                         break;
 156                 case RADIUS_PKT_TYPE_RESOURCE_QUERY_REQUEST:
 157                 case RADIUS_PKT_TYPE_RESOURCE_QUERY_RESPONSE:
 158                         radius_cat = RADIUS_CAT_RESOURCE_QUERY;
 159                         break;
 160                 case RADIUS_PKT_TYPE_NAS_REBOOT_REQUEST:
 161                 case RADIUS_PKT_TYPE_NAS_REBOOT_RESPONSE:
 162                         radius_cat = RADIUS_CAT_NAS_REBOOT;
 163                         break;
 164                 case RADIUS_PKT_TYPE_EVENT_REQUEST:
 165                 case RADIUS_PKT_TYPE_EVENT_RESPONSE:
 166                         radius_cat = RADIUS_CAT_EVENT;
 167                         break;
 168                 case RADIUS_PKT_TYPE_DISCONNECT_REQUEST:
 169                 case RADIUS_PKT_TYPE_DISCONNECT_ACK:
 170                 case RADIUS_PKT_TYPE_DISCONNECT_NAK:
 171                         radius_cat = RADIUS_CAT_DISCONNECT;
 172                         break;
 173                 case RADIUS_PKT_TYPE_COA_REQUEST:
 174                 case RADIUS_PKT_TYPE_COA_ACK:
 175                 case RADIUS_PKT_TYPE_COA_NAK:
 176                         radius_cat = RADIUS_CAT_COA;
 177                         break;
 178         }
 179
 180         switch (ri->code) {
 181
 182         case RADIUS_PKT_TYPE_ACCESS_REQUEST:
 183         case RADIUS_PKT_TYPE_ACCOUNTING_REQUEST:
 184         case RADIUS_PKT_TYPE_PASSWORD_REQUEST:
 185         case RADIUS_PKT_TYPE_EVENT_REQUEST:
 186         case RADIUS_PKT_TYPE_DISCONNECT_REQUEST:
 187         case RADIUS_PKT_TYPE_COA_REQUEST:
 188                 if(ri->is_duplicate){
 189                         /* Duplicate is ignored */
 190                         rs->radius_rtd[RADIUS_CAT_OVERALL].req_dup_num++;
 191                         rs->radius_rtd[radius_cat].req_dup_num++;
 192                 }
 193                 else {
 194                         rs->radius_rtd[RADIUS_CAT_OVERALL].open_req_num++;
 195                         rs->radius_rtd[radius_cat].open_req_num++;
 196                 }
 197                 break;
 198
 199         case RADIUS_PKT_TYPE_ACCESS_ACCEPT:
 200         case RADIUS_PKT_TYPE_ACCESS_REJECT:
 201         case RADIUS_PKT_TYPE_ACCOUNTING_RESPONSE:
 202         case RADIUS_PKT_TYPE_PASSWORD_ACK:
 203         case RADIUS_PKT_TYPE_PASSWORD_REJECT:
 204         case RADIUS_PKT_TYPE_EVENT_RESPONSE:
 205         case RADIUS_PKT_TYPE_DISCONNECT_ACK:
 206         case RADIUS_PKT_TYPE_DISCONNECT_NAK:
 207         case RADIUS_PKT_TYPE_COA_ACK:
 208         case RADIUS_PKT_TYPE_COA_NAK:
 209                 if(ri->is_duplicate){
 210                         /* Duplicate is ignored */
 211                         rs->radius_rtd[RADIUS_CAT_OVERALL].rsp_dup_num++;
 212                         rs->radius_rtd[radius_cat].rsp_dup_num++;
 213                 }
 214                 else if (!ri->request_available) {
 215                         /* no request was seen */
 216                         rs->radius_rtd[RADIUS_CAT_OVERALL].disc_rsp_num++;
 217                         rs->radius_rtd[radius_cat].disc_rsp_num++;
 218                 }
 219                 else {
 220                         rs->radius_rtd[RADIUS_CAT_OVERALL].open_req_num--;
 221                         rs->radius_rtd[radius_cat].open_req_num--;
 222                         /* calculate time delta between request and response */
 223                         nstime_delta(&delta, &pinfo->fd->abs_ts, &ri->req_time);
 224
 225                         time_stat_update(&(rs->radius_rtd[RADIUS_CAT_OVERALL].stats),&delta, pinfo);
 226                         time_stat_update(&(rs->radius_rtd[radius_cat].stats),&delta, pinfo);
 227
 228                         ret = 1;
 229                 }
 230                 break;
 231
 232         default:
 233                 break;
 234         }
 235
 236         return ret;
 237 }
 238
 239 static void
 240 radiusstat_draw(void *prs)
 241 {
 242         radiusstat_t *rs=(radiusstat_t *)prs;
 243         int i;
 244         char str[5][256];
 245         GtkListStore *store;
 246         GtkTreeIter iter;
 247
 248         /* clear list before printing */
 249         store = GTK_LIST_STORE(gtk_tree_view_get_model(rs->table));
 250         gtk_list_store_clear(store);
 251
 252         for(i=0; i<RADIUS_CAT_NUM_TIMESTATS; i++) {
 253                 /* nothing seen, nothing to do */
 254                 if(rs->radius_rtd[i].stats.num==0){
 255                         continue;
 256                 }
 257                 g_snprintf(str[0], 256, "%8.2f msec", nstime_to_msec(&(rs->radius_rtd[i].stats.min)));
 258                 g_snprintf(str[1], 256, "%8.2f msec", nstime_to_msec(&(rs->radius_rtd[i].stats.max)));
 259                 g_snprintf(str[2], 256, "%8.2f msec", get_average(&(rs->radius_rtd[i].stats.tot), rs->radius_rtd[i].stats.num));
 260                 g_snprintf(str[3], 256, "%4u (%4.2f%%)", rs->radius_rtd[i].req_dup_num,
 261                         rs->radius_rtd[i].stats.num?((double)rs->radius_rtd[i].req_dup_num*100)/(double)rs->radius_rtd[i].stats.num:0);
 262                 g_snprintf(str[4], 256, "%4u (%4.2f%%)", rs->radius_rtd[i].rsp_dup_num,
 263                         rs->radius_rtd[i].stats.num?((double)rs->radius_rtd[i].rsp_dup_num*100)/(double)rs->radius_rtd[i].stats.num:0);
 264
 265                 gtk_list_store_append(store, &iter);
 266                 gtk_list_store_set(store, &iter,
 267                         0, val_to_str(i, radius_message_code,"Other"),
 268                         1, rs->radius_rtd[i].stats.num,
 269                         2, str[0],
 270                         3, str[1],
 271                         4, str[2],
 272                         5, rs->radius_rtd[i].stats.min_num,
 273                         6, rs->radius_rtd[i].stats.max_num,
 274                         7, rs->radius_rtd[i].open_req_num,
 275                         8, rs->radius_rtd[i].disc_rsp_num,
 276                         9, str[3],
 277                         10, str[4],
 278                         -1);
 279         }
 280 }
 281
 282 static void
 283 win_destroy_cb(GtkWindow *win _U_, gpointer data)
 284 {
 285         radiusstat_t *rs=(radiusstat_t *)data;
 286
 287         remove_tap_listener(rs);
 288
 289         if(rs->filter){
 290                 g_free(rs->filter);
 291                 rs->filter=NULL;
 292         }
 293         g_free(rs);
 294 }
 295
 296 static const stat_column titles[]={
 297         {G_TYPE_STRING, LEFT,  "Type" },
 298         {G_TYPE_UINT, RIGHT,   "Messages" },
 299         {G_TYPE_STRING, RIGHT, "Min SRT" },
 300         {G_TYPE_STRING, RIGHT, "Max SRT" },
 301         {G_TYPE_STRING, RIGHT, "Avg SRT" },
 302         {G_TYPE_UINT, RIGHT,   "Min in Frame" },
 303         {G_TYPE_UINT, RIGHT,   "Max in Frame" },
 304         {G_TYPE_UINT, RIGHT,   "Open Requests" },
 305         {G_TYPE_UINT, RIGHT,   "Discarded Responses" },
 306         {G_TYPE_STRING, RIGHT, "Repeated Requests" },
 307         {G_TYPE_STRING, RIGHT, "Repeated Responses"}
 308 };
 309
 310 static void
 311 gtk_radiusstat_init(const char *opt_arg, void *userdata _U_)
 312 {
 313         radiusstat_t *rs;
 314         GString *error_string;
 315         GtkWidget *bt_close;
 316         GtkWidget *bbox;
 317
 318         rs=(radiusstat_t *)g_malloc(sizeof(radiusstat_t));
 319
 320         if(strncmp(opt_arg,"radius,srt,",11) == 0){
 321                 rs->filter=g_strdup(opt_arg+11);
 322         } else {
 323                 rs->filter=NULL;
 324         }
 325
 326         radiusstat_reset(rs);
 327
 328         rs->win = dlg_window_new("RADIUS SRT");  /* transient_for top_level */
 329         gtk_window_set_destroy_with_parent (GTK_WINDOW(rs->win), TRUE);
 330         gtk_window_set_default_size(GTK_WINDOW(rs->win), 600, 150);
 331
 332         rs->vbox=ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
 333
 334         init_main_stat_window(rs->win, rs->vbox, "RADIUS Service Response Time (SRT) Statistics", rs->filter);
 335
 336         /* init a scrolled window*/
 337         rs->scrolled_window = scrolled_window_new(NULL, NULL);
 338
 339         rs->table = create_stat_table(rs->scrolled_window, rs->vbox, NUM_COLUMNS, titles);
 340
 341         error_string=register_tap_listener("radius", rs, rs->filter, 0, radiusstat_reset, radiusstat_packet, radiusstat_draw);
 342         if(error_string){
 343                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
 344                 g_string_free(error_string, TRUE);
 345                 g_free(rs->filter);
 346                 g_free(rs);
 347                 return;
 348         }
 349
 350         /* Button row. */
 351         bbox = dlg_button_row_new(GTK_STOCK_CLOSE, NULL);
 352         gtk_box_pack_start(GTK_BOX(rs->vbox), bbox, FALSE, FALSE, 0);
 353
 354         bt_close = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
 355         window_set_cancel_button(rs->win, bt_close, window_cancel_button_cb);
 356
 357         g_signal_connect(rs->win, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
 358         g_signal_connect(rs->win, "destroy", G_CALLBACK(win_destroy_cb), rs);
 359
 360         gtk_widget_show_all(rs->win);
 361         window_present(rs->win);
 362
 363         cf_retap_packets(&cfile);
 364         gdk_window_raise(gtk_widget_get_window(rs->win));
 365 }
 366
 367 static tap_param radius_stat_params[] = {
 368         { PARAM_FILTER, "Filter", NULL }
 369 };
 370
 371 static tap_param_dlg radius_srt_dlg = {
 372         "RADIUS Service Response Time (SRT) Statistics",
 373         "radius,srt",
 374         gtk_radiusstat_init,
 375         -1,
 376         G_N_ELEMENTS(radius_stat_params),
 377         radius_stat_params
 378 };
 379
 380 void
 381 register_tap_listener_gtkradiusstat(void)
 382 {
 383         register_param_stat(&radius_srt_dlg, "RADIUS",
 384                     REGISTER_STAT_GROUP_RESPONSE_TIME);
 385 }