ui/cli/tap-sipstat.c

   1 /* tap_sipstat.c
   2  * sip message counter for wireshark
   3  *
   4  * Copied from ui/gtk/sip_stat.c and tap-httpstat.c
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * SPDX-License-Identifier: GPL-2.0-or-later
  11  */
  12
  13 #include "config.h"
  14
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18
  19 #include <glib.h>
  20
  21 #include <epan/packet_info.h>
  22 #include <epan/tap.h>
  23 #include <epan/stat_tap_ui.h>
  24 #include <epan/value_string.h>
  25 #include <epan/dissectors/packet-sip.h>
  26
  27 #include <wsutil/wslog.h>
  28
  29 #include <wsutil/cmdarg_err.h>
  30
  31 void register_tap_listener_sipstat(void);
  32
  33 /* used to keep track of the statictics for an entire program interface */
  34 typedef struct _sip_stats_t {
  35         char        *filter;
  36         uint32_t             packets;    /* number of sip packets, including continuations */
  37         uint32_t             resent_packets;
  38         uint32_t             average_setup_time;
  39         uint32_t             max_setup_time;
  40         uint32_t             min_setup_time;
  41         uint32_t             no_of_completed_calls;
  42         uint64_t             total_setup_time;
  43         GHashTable  *hash_responses;
  44         GHashTable  *hash_requests;
  45 } sipstat_t;
  46
  47 /* used to keep track of the stats for a specific response code
  48  * for example it can be { 3, 404, "Not Found" ,...}
  49  * which means we captured 3 reply sip/1.1 404 Not Found */
  50 typedef struct _sip_response_code_t {
  51         uint32_t             packets;       /* 3 */
  52         unsigned             response_code; /* 404 */
  53         const char *name;           /* Not Found */
  54         sipstat_t   *sp;
  55 } sip_response_code_t;
  56
  57 /* used to keep track of the stats for a specific request string */
  58 typedef struct _sip_request_method_t {
  59         char        *response;  /* eg. : INVITE */
  60         uint32_t             packets;
  61         sipstat_t   *sp;
  62 } sip_request_method_t;
  63
  64
  65 /* Create tables for responses and requests */
  66 static void
  67 sip_init_hash(sipstat_t *sp)
  68 {
  69         int i;
  70
  71         /* Create responses table */
  72         sp->hash_responses = g_hash_table_new(g_int_hash, g_int_equal);
  73
  74         /* Add all response codes */
  75         for (i=0; sip_response_code_vals[i].strptr; i++)
  76         {
  77                 int *key = g_new (int, 1);
  78                 sip_response_code_t *sc = g_new (sip_response_code_t, 1);
  79                 *key = sip_response_code_vals[i].value;
  80                 sc->packets = 0;
  81                 sc->response_code =  *key;
  82                 sc->name = sip_response_code_vals[i].strptr;
  83                 sc->sp = sp;
  84                 g_hash_table_insert(sc->sp->hash_responses, key, sc);
  85         }
  86
  87         /* Create empty requests table */
  88         sp->hash_requests = g_hash_table_new(g_str_hash, g_str_equal);
  89 }
  90
  91 static void
  92 sip_draw_hash_requests( char *key _U_, sip_request_method_t *data, char *format)
  93 {
  94         if (data->packets == 0)
  95                 return;
  96         printf( format, data->response, data->packets);
  97 }
  98
  99 static void
 100 sip_draw_hash_responses( int *key _U_ , sip_response_code_t *data, char *format)
 101 {
 102         if (data == NULL) {
 103                 ws_warning("C'est quoi ce borderl key=%d\n", *key);
 104                 exit(EXIT_FAILURE);
 105         }
 106         if (data->packets == 0)
 107                 return;
 108         printf(format,  data->response_code, data->name, data->packets );
 109 }
 110
 111 /* NOT USED at this moment */
 112 /*
 113 static void
 114 sip_free_hash( void *key, void *value, void *user_data _U_ )
 115 {
 116         g_free(key);
 117         g_free(value);
 118 }
 119 */
 120
 121 static void
 122 sip_reset_hash_responses(char *key _U_ , sip_response_code_t *data, void *ptr _U_ )
 123 {
 124         data->packets = 0;
 125 }
 126 static void
 127 sip_reset_hash_requests(char *key _U_ , sip_request_method_t *data, void *ptr _U_ )
 128 {
 129         data->packets = 0;
 130 }
 131
 132 static void
 133 sipstat_reset(void *psp  )
 134 {
 135         sipstat_t *sp = (sipstat_t *)psp;
 136         if (sp) {
 137                 sp->packets = 0;
 138                 sp->resent_packets = 0;
 139                 sp->average_setup_time = 0;
 140                 sp->max_setup_time = 0;
 141                 sp->min_setup_time = 0;
 142                 sp->no_of_completed_calls = 0;
 143                 sp->total_setup_time = 0;
 144
 145                 g_hash_table_foreach( sp->hash_responses, (GHFunc)sip_reset_hash_responses, NULL);
 146                 g_hash_table_foreach( sp->hash_requests, (GHFunc)sip_reset_hash_requests, NULL);
 147         }
 148 }
 149
 150
 151 /* Main entry point to SIP tap */
 152 static tap_packet_status
 153 sipstat_packet(void *psp, packet_info *pinfo _U_, epan_dissect_t *edt _U_, const void *pri, tap_flags_t flags _U_)
 154 {
 155         const sip_info_value_t *value = (const sip_info_value_t *)pri;
 156         sipstat_t *sp = (sipstat_t *)psp;
 157
 158         /* Total number of packets, including continuation packets */
 159         sp->packets++;
 160
 161         /* Calculate average setup time */
 162         if (value->setup_time) {
 163                 sp->no_of_completed_calls++;
 164                 /* Check if it's the first value */
 165                 if ( sp->total_setup_time == 0 ) {
 166                         sp->average_setup_time = value->setup_time;
 167                         sp->total_setup_time = value->setup_time;
 168                         sp->max_setup_time = value->setup_time;
 169                         sp->min_setup_time = value->setup_time;
 170                 }else{
 171                         sp->total_setup_time = sp->total_setup_time + value->setup_time;
 172                         if (sp->max_setup_time < value->setup_time) {
 173                                 sp->max_setup_time = value->setup_time;
 174                         }
 175                         if (sp->min_setup_time > value->setup_time) {
 176                                 sp->min_setup_time = value->setup_time;
 177                         }
 178                         /* Calculate average */
 179                         sp->average_setup_time = (uint32_t)(sp->total_setup_time / sp->no_of_completed_calls);
 180                 }
 181         }
 182
 183         /* Update resent count if flag set */
 184         if (value->resend)
 185         {
 186                 sp->resent_packets++;
 187         }
 188
 189
 190         /* Looking at both requests and responses */
 191         if (value->response_code != 0)
 192         {
 193                 /* Responses */
 194                 unsigned key;
 195                 sip_response_code_t *sc;
 196
 197                 /* Look up response code in hash table */
 198                 key = value->response_code;
 199                 sc = (sip_response_code_t *)g_hash_table_lookup(sp->hash_responses, &key);
 200                 if (sc == NULL)
 201                 {
 202                         /* Non-standard status code ; we classify it as others
 203                          * in the relevant category
 204                          * (Informational,Success,Redirection,Client Error,Server Error,Global Failure)
 205                          */
 206                         int i = value->response_code;
 207                         if ((i < 100) || (i >= 700))
 208                         {
 209                                 /* Forget about crazy values */
 210                                 return TAP_PACKET_DONT_REDRAW;
 211                         }
 212                         else if (i < 200)
 213                         {
 214                                 key = 199;      /* Hopefully, this status code will never be used */
 215                         }
 216                         else if (i < 300)
 217                         {
 218                                 key = 299;
 219                         }
 220                         else if (i < 400)
 221                         {
 222                                 key = 399;
 223                         }
 224                         else if (i < 500)
 225                         {
 226                                 key = 499;
 227                         }
 228                         else if (i < 600)
 229                         {
 230                                 key = 599;
 231                         }
 232                         else
 233                         {
 234                                 key = 699;
 235                         }
 236
 237                         /* Now look up this fallback code to get its text description */
 238                         sc = (sip_response_code_t *)g_hash_table_lookup(sp->hash_responses, &key);
 239                         if (sc == NULL)
 240                         {
 241                                 return TAP_PACKET_DONT_REDRAW;
 242                         }
 243                 }
 244                 sc->packets++;
 245         }
 246         else if (value->request_method)
 247         {
 248                 /* Requests */
 249                 sip_request_method_t *sc;
 250
 251                 /* Look up the request method in the table */
 252                 sc = (sip_request_method_t *)g_hash_table_lookup(sp->hash_requests, value->request_method);
 253                 if (sc == NULL)
 254                 {
 255                         /* First of this type. Create structure and initialise */
 256                         sc = g_new(sip_request_method_t, 1);
 257                         sc->response = g_strdup(value->request_method);
 258                         sc->packets = 1;
 259                         sc->sp = sp;
 260                         /* Insert it into request table */
 261                         g_hash_table_insert(sp->hash_requests, sc->response, sc);
 262                 }
 263                 else
 264                 {
 265                         /* Already existed, just update count for that method */
 266                         sc->packets++;
 267                 }
 268                 /* g_free(value->request_method); */
 269         }
 270         else
 271         {
 272                 /* No request method set. Just ignore */
 273                 return TAP_PACKET_DONT_REDRAW;
 274         }
 275
 276         return TAP_PACKET_REDRAW;
 277 }
 278
 279 static void
 280 sipstat_draw(void *psp  )
 281 {
 282         sipstat_t *sp = (sipstat_t *)psp;
 283         printf("\n");
 284         printf("===================================================================\n");
 285         if (sp->filter == NULL)
 286                 printf("SIP Statistics\n");
 287         else
 288                 printf("SIP Statistics with filter %s\n", sp->filter);
 289
 290         printf("\nNumber of SIP messages: %u", sp->packets);
 291         printf("\nNumber of resent SIP messages: %u\n", sp->resent_packets);
 292         printf( "\n* SIP Status Codes in reply packets\n");
 293         g_hash_table_foreach(sp->hash_responses, (GHFunc)sip_draw_hash_responses,
 294                 (void *)"  SIP %3d %-15s : %5d Packets\n");
 295         printf("\n* List of SIP Request methods\n");
 296         g_hash_table_foreach(sp->hash_requests,  (GHFunc)sip_draw_hash_requests,
 297                 (void *)"  %-15s : %5d Packets\n");
 298         printf( "\n* Average setup time %u ms\n Min %u ms\n Max %u ms\n", sp->average_setup_time, sp->min_setup_time, sp->max_setup_time);
 299         printf("===================================================================\n");
 300 }
 301
 302 static void
 303 sipstat_init(const char *opt_arg, void *userdata _U_)
 304 {
 305         sipstat_t  *sp;
 306         const char *filter = NULL;
 307         GString    *error_string;
 308
 309         if (strncmp (opt_arg, "sip,stat,", 9) == 0) {
 310                 filter = opt_arg+9;
 311         } else {
 312                 filter = NULL;
 313         }
 314
 315         sp = g_new0(sipstat_t, 1);
 316         sp->filter = g_strdup(filter);
 317         /*g_hash_table_foreach( sip_status, (GHFunc)sip_reset_hash_responses, NULL);*/
 318
 319
 320         error_string = register_tap_listener(
 321                         "sip",
 322                         sp,
 323                         filter,
 324                         0,
 325                         sipstat_reset,
 326                         sipstat_packet,
 327                         sipstat_draw,
 328                         NULL);
 329         if (error_string) {
 330                 /* error, we failed to attach to the tap. clean up */
 331                 g_free(sp->filter);
 332                 g_free(sp);
 333                 cmdarg_err("Couldn't register sip,stat tap: %s",
 334                          error_string->str);
 335                 g_string_free(error_string, TRUE);
 336                 exit(1);
 337         }
 338
 339         sp->packets = 0;
 340         sp->resent_packets = 0;
 341         sip_init_hash(sp);
 342 }
 343
 344 static stat_tap_ui sipstat_ui = {
 345         REGISTER_STAT_GROUP_GENERIC,
 346         NULL,
 347         "sip,stat",
 348         sipstat_init,
 349         0,
 350         NULL
 351 };
 352
 353 void
 354 register_tap_listener_sipstat(void)
 355 {
 356         register_stat_tap_ui(&sipstat_ui, NULL);
 357 }
 358
 359 /*
 360  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 361  *
 362  * Local variables:
 363  * c-basic-offset: 8
 364  * tab-width: 8
 365  * indent-tabs-mode: t
 366  * End:
 367  *
 368  * vi: set shiftwidth=8 tabstop=8 noexpandtab:
 369  * :indentSize=8:tabSize=8:noTabs=false:
 370  */