ui/cli/tap-rtspstat.c

   1 /* tap-rtspstat.c
   2  * tap-rtspstat   March 2011
   3  *
   4  * Stephane GORSE (Orange Labs / France Telecom)
   5  * Copied from Jean-Michel FAYARD's works (HTTP)
   6  *
   7  * Wireshark - Network traffic analyzer
   8  * By Gerald Combs <gerald@wireshark.org>
   9  * Copyright 1998 Gerald Combs
  10  *
  11  * SPDX-License-Identifier: GPL-2.0-or-later
  12  */
  13
  14 #include "config.h"
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19
  20 #include <glib.h>
  21
  22 #include <epan/packet_info.h>
  23 #include <epan/value_string.h>
  24 #include <epan/tap.h>
  25 #include <epan/stat_tap_ui.h>
  26 #include <epan/dissectors/packet-rtsp.h>
  27
  28 #include <wsutil/wslog.h>
  29
  30 #include <wsutil/cmdarg_err.h>
  31
  32 void register_tap_listener_rtspstat(void);
  33
  34 /* used to keep track of the statictics for an entire program interface */
  35 typedef struct _rtsp_stats_t {
  36         char            *filter;
  37         GHashTable      *hash_responses;
  38         GHashTable      *hash_requests;
  39 } rtspstat_t;
  40
  41 /* used to keep track of the stats for a specific response code
  42  * for example it can be { 3, 404, "Not Found" ,...}
  43  * which means we captured 3 reply rtsp/1.1 404 Not Found */
  44 typedef struct _rtsp_response_code_t {
  45         uint32_t         packets;               /* 3 */
  46         unsigned                 response_code; /* 404 */
  47         const char      *name;                  /* Not Found */
  48         rtspstat_t      *sp;
  49 } rtsp_response_code_t;
  50
  51 /* used to keep track of the stats for a specific request string */
  52 typedef struct _rtsp_request_methode_t {
  53         char            *response;      /* eg. : SETUP */
  54         uint32_t                 packets;
  55         rtspstat_t      *sp;
  56 } rtsp_request_methode_t;
  57
  58
  59 /* insert some entries */
  60 static void
  61 rtsp_init_hash( rtspstat_t *sp)
  62 {
  63         int i;
  64
  65         sp->hash_responses = g_hash_table_new(g_direct_hash, g_direct_equal);
  66
  67         for (i=0 ; rtsp_status_code_vals[i].strptr ; i++ )
  68         {
  69                 rtsp_response_code_t *sc = g_new (rtsp_response_code_t, 1);
  70                 sc->packets = 0;
  71                 sc->response_code = rtsp_status_code_vals[i].value;
  72                 sc->name = rtsp_status_code_vals[i].strptr;
  73                 sc->sp = sp;
  74                 g_hash_table_insert( sc->sp->hash_responses, GINT_TO_POINTER(rtsp_status_code_vals[i].value), sc);
  75         }
  76         sp->hash_requests = g_hash_table_new( g_str_hash, g_str_equal);
  77 }
  78 static void
  79 rtsp_draw_hash_requests( char *key _U_ , rtsp_request_methode_t *data, char * format)
  80 {
  81         if (data->packets == 0)
  82                 return;
  83         printf( format, data->response, data->packets);
  84 }
  85
  86 static void
  87 rtsp_draw_hash_responses( void ** key _U_ , rtsp_response_code_t *data, char * format)
  88 {
  89         if (data == NULL) {
  90                 ws_warning("No data available, key=%d\n", GPOINTER_TO_INT(key));
  91                 exit(EXIT_FAILURE);
  92         }
  93         if (data->packets == 0)
  94                 return;
  95         /* "     RTSP %3d %-35s %9d packets", */
  96         printf(format,  data->response_code, data->name, data->packets );
  97 }
  98
  99
 100
 101 /* NOT USED at this moment */
 102 /*
 103 static void
 104 rtsp_free_hash( void *key, void *value, void *user_data _U_ )
 105 {
 106         g_free(key);
 107         g_free(value);
 108 }
 109 */
 110 static void
 111 rtsp_reset_hash_responses(char *key _U_ , rtsp_response_code_t *data, void *ptr _U_ )
 112 {
 113         data->packets = 0;
 114 }
 115 static void
 116 rtsp_reset_hash_requests(char *key _U_ , rtsp_request_methode_t *data, void *ptr _U_ )
 117 {
 118         data->packets = 0;
 119 }
 120
 121 static void
 122 rtspstat_reset(void *psp  )
 123 {
 124         rtspstat_t *sp = (rtspstat_t *)psp;
 125
 126         g_hash_table_foreach( sp->hash_responses, (GHFunc)rtsp_reset_hash_responses, NULL);
 127         g_hash_table_foreach( sp->hash_requests, (GHFunc)rtsp_reset_hash_requests, NULL);
 128
 129 }
 130
 131 static tap_packet_status
 132 rtspstat_packet(void *psp , packet_info *pinfo _U_, epan_dissect_t *edt _U_, const void *pri, tap_flags_t flags _U_)
 133 {
 134         const rtsp_info_value_t *value = (const rtsp_info_value_t *)pri;
 135         rtspstat_t *sp = (rtspstat_t *) psp;
 136
 137         /* We are only interested in reply packets with a status code */
 138         /* Request or reply packets ? */
 139         if (value->response_code != 0) {
 140                 rtsp_response_code_t *sc;
 141
 142                 sc =  (rtsp_response_code_t *)g_hash_table_lookup(
 143                                 sp->hash_responses,
 144                                 GINT_TO_POINTER(value->response_code));
 145                 if (sc == NULL) {
 146                         int key;
 147                         /* non standard status code ; we classify it as others
 148                          * in the relevant category (Informational,Success,Redirection,Client Error,Server Error)
 149                          */
 150                         int i = value->response_code;
 151                         if ((i < 100) || (i >= 600)) {
 152                                 return TAP_PACKET_DONT_REDRAW;
 153                         }
 154                         else if (i < 200) {
 155                                 key = 199;      /* Hopefully, this status code will never be used */
 156                         }
 157                         else if (i < 300) {
 158                                 key = 299;
 159                         }
 160                         else if (i < 400) {
 161                                 key = 399;
 162                         }
 163                         else if (i < 500) {
 164                                 key = 499;
 165                         }
 166                         else {
 167                                 key = 599;
 168                         }
 169                         sc =  (rtsp_response_code_t *)g_hash_table_lookup(
 170                                 sp->hash_responses,
 171                                 GINT_TO_POINTER(key));
 172                         if (sc == NULL)
 173                                 return TAP_PACKET_DONT_REDRAW;
 174                 }
 175                 sc->packets++;
 176         }
 177         else if (value->request_method) {
 178                 rtsp_request_methode_t *sc;
 179
 180                 sc =  (rtsp_request_methode_t *)g_hash_table_lookup(
 181                                 sp->hash_requests,
 182                                 value->request_method);
 183                 if (sc == NULL) {
 184                         sc = g_new(rtsp_request_methode_t, 1);
 185                         sc->response = g_strdup( value->request_method );
 186                         sc->packets = 1;
 187                         sc->sp = sp;
 188                         g_hash_table_insert( sp->hash_requests, sc->response, sc);
 189                 } else {
 190                         sc->packets++;
 191                 }
 192         } else {
 193                 return TAP_PACKET_DONT_REDRAW;
 194         }
 195         return TAP_PACKET_REDRAW;
 196 }
 197
 198
 199 static void
 200 rtspstat_draw(void *psp  )
 201 {
 202         rtspstat_t *sp = (rtspstat_t *)psp;
 203         printf("\n");
 204         printf("===================================================================\n");
 205         if (!sp->filter || !sp->filter[0])
 206                 printf("RTSP Statistics\n");
 207         else
 208                 printf("RTSP Statistics with filter %s\n", sp->filter);
 209
 210         printf("* RTSP Response Status Codes                Packets\n");
 211         g_hash_table_foreach( sp->hash_responses, (GHFunc)rtsp_draw_hash_responses,
 212                 (void *)"  %3d %-35s %9d\n");
 213         printf("* RTSP Request Methods                      Packets\n");
 214         g_hash_table_foreach( sp->hash_requests,  (GHFunc)rtsp_draw_hash_requests,
 215                 (void *)"  %-39s %9d\n");
 216         printf("===================================================================\n");
 217 }
 218
 219
 220
 221 /* When called, this function will create a new instance of rtspstat.
 222  */
 223 static void
 224 rtspstat_init(const char *opt_arg, void *userdata _U_)
 225 {
 226         rtspstat_t *sp;
 227         const char *filter = NULL;
 228         GString *error_string;
 229
 230         if (!strncmp (opt_arg, "rtsp,stat,", 10)) {
 231                 filter = opt_arg+10;
 232         } else {
 233                 filter = NULL;
 234         }
 235
 236         sp = g_new(rtspstat_t, 1);
 237         sp->filter = g_strdup(filter);
 238         /*g_hash_table_foreach( rtsp_status, (GHFunc)rtsp_reset_hash_responses, NULL);*/
 239
 240
 241         error_string = register_tap_listener(
 242                         "rtsp",
 243                         sp,
 244                         filter,
 245                         0,
 246                         rtspstat_reset,
 247                         rtspstat_packet,
 248                         rtspstat_draw,
 249                         NULL);
 250         if (error_string) {
 251                 /* error, we failed to attach to the tap. clean up */
 252                 g_free(sp->filter);
 253                 g_free(sp);
 254                 cmdarg_err("Couldn't register rtsp,stat tap: %s",
 255                                 error_string->str);
 256                 g_string_free(error_string, TRUE);
 257                 exit(1);
 258         }
 259
 260         rtsp_init_hash(sp);
 261 }
 262
 263 static stat_tap_ui rtspstat_ui = {
 264         REGISTER_STAT_GROUP_GENERIC,
 265         NULL,
 266         "rtsp,stat",
 267         rtspstat_init,
 268         0,
 269         NULL
 270 };
 271
 272 void
 273 register_tap_listener_rtspstat(void)
 274 {
 275         register_stat_tap_ui(&rtspstat_ui, NULL);
 276 }
 277
 278 /*
 279  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 280  *
 281  * Local variables:
 282  * c-basic-offset: 8
 283  * tab-width: 8
 284  * indent-tabs-mode: t
 285  * End:
 286  *
 287  * vi: set shiftwidth=8 tabstop=8 noexpandtab:
 288  * :indentSize=8:tabSize=8:noTabs=false:
 289  */