proto_hier_stats.c

   1 /* proto_hier_stats.c
   2  * Routines for calculating statistics based on protocol.
   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 #include "globals.h"
  32 #include "proto_hier_stats.h"
  33 #include "progress_dlg.h"
  34 #include <epan/epan_dissect.h>
  35 #include <wtap.h>
  36
  37 #include <stdio.h>
  38 #include <string.h>
  39 #include <glib.h>
  40
  41 /* Update the progress bar this many times when scanning the packet list. */
  42 #define N_PROGBAR_UPDATES       100
  43
  44 #define STAT_NODE_STATS(n)   ((ph_stats_node_t*)(n)->data)
  45 #define STAT_NODE_HFINFO(n)  (STAT_NODE_STATS(n)->hfinfo)
  46
  47
  48 static GNode*
  49 find_stat_node(GNode *parent_stat_node, header_field_info *needle_hfinfo)
  50 {
  51         GNode                   *needle_stat_node;
  52         header_field_info       *hfinfo;
  53         ph_stats_node_t         *stats;
  54
  55         needle_stat_node = g_node_first_child(parent_stat_node);
  56
  57         while (needle_stat_node) {
  58                 hfinfo = STAT_NODE_HFINFO(needle_stat_node);
  59                 if (hfinfo &&  hfinfo->id == needle_hfinfo->id) {
  60                         return needle_stat_node;
  61                 }
  62                 needle_stat_node = g_node_next_sibling(needle_stat_node);
  63         }
  64
  65         /* None found. Create one. */
  66         stats = g_new(ph_stats_node_t, 1);
  67
  68         /* Intialize counters */
  69         stats->hfinfo = needle_hfinfo;
  70         stats->num_pkts_total = 0;
  71         stats->num_pkts_last = 0;
  72         stats->num_bytes_total = 0;
  73         stats->num_bytes_last = 0;
  74
  75         needle_stat_node = g_node_new(stats);
  76         g_node_append(parent_stat_node, needle_stat_node);
  77         return needle_stat_node;
  78 }
  79
  80
  81 static void
  82 process_node(proto_node *ptree_node, GNode *parent_stat_node, ph_stats_t *ps, guint pkt_len)
  83 {
  84         field_info              *finfo;
  85         ph_stats_node_t         *stats;
  86         proto_node              *proto_sibling_node;
  87         GNode                   *stat_node;
  88
  89         finfo = PNODE_FINFO(ptree_node);
  90         /* We don't fake protocol nodes we expect them to have a field_info */
  91         g_assert(finfo && "dissection with faked proto tree?");
  92
  93         /* If the field info isn't related to a protocol but to a field,
  94          * don't count them, as they don't belong to any protocol.
  95          * (happens e.g. for toplevel tree item of desegmentation "[Reassembled TCP Segments]") */
  96         if (finfo->hfinfo->parent != -1) {
  97                 /* Skip this element, use parent status node */
  98                 stat_node = parent_stat_node;
  99                 stats = STAT_NODE_STATS(stat_node);
 100         } else {
 101                 stat_node = find_stat_node(parent_stat_node, finfo->hfinfo);
 102
 103                 stats = STAT_NODE_STATS(stat_node);
 104                 stats->num_pkts_total++;
 105                 stats->num_bytes_total += pkt_len;
 106         }
 107
 108         proto_sibling_node = ptree_node->next;
 109
 110         if (proto_sibling_node) {
 111                 /* If the name does not exist for this proto_sibling_node, then it is
 112                  * not a normal protocol in the top-level tree.  It was instead
 113                  * added as a normal tree such as IPv6's Hop-by-hop Option Header and
 114                  * should be skipped when creating the protocol hierarchy display. */
 115                 if(strlen(PNODE_FINFO(proto_sibling_node)->hfinfo->name) == 0 && ptree_node->next)
 116                         proto_sibling_node = proto_sibling_node->next;
 117
 118                 process_node(proto_sibling_node, stat_node, ps, pkt_len);
 119         } else {
 120                 stats->num_pkts_last++;
 121                 stats->num_bytes_last += pkt_len;
 122         }
 123 }
 124
 125
 126
 127 static void
 128 process_tree(proto_tree *protocol_tree, ph_stats_t* ps, guint pkt_len)
 129 {
 130         proto_node      *ptree_node;
 131
 132         ptree_node = ((proto_node *)protocol_tree)->first_child;
 133         if (!ptree_node) {
 134                 return;
 135         }
 136
 137         process_node(ptree_node, ps->stats_tree, ps, pkt_len);
 138 }
 139
 140 static gboolean
 141 process_frame(frame_data *frame, column_info *cinfo, ph_stats_t* ps)
 142 {
 143         epan_dissect_t                  edt;
 144         union wtap_pseudo_header        phdr;
 145         guint8                          pd[WTAP_MAX_PACKET_SIZE];
 146         double                          cur_time;
 147
 148         /* Load the frame from the capture file */
 149         if (!cf_read_frame_r(&cfile, frame, &phdr, pd))
 150                 return FALSE;   /* failure */
 151
 152         /* Dissect the frame   tree  not visible */
 153         epan_dissect_init(&edt, TRUE, FALSE);
 154         /* Don't fake protocols. We need them for the protocol hierarchy */
 155         epan_dissect_fake_protocols(&edt, FALSE);
 156         epan_dissect_run(&edt, &phdr, pd, frame, cinfo);
 157
 158         /* Get stats from this protocol tree */
 159         process_tree(edt.tree, ps, frame->pkt_len);
 160
 161         /* Update times */
 162         cur_time = nstime_to_sec(&frame->abs_ts);
 163         if (cur_time < ps->first_time) {
 164           ps->first_time = cur_time;
 165         }
 166         if (cur_time > ps->last_time){
 167           ps->last_time = cur_time;
 168         }
 169
 170         /* Free our memory. */
 171         epan_dissect_cleanup(&edt);
 172
 173         return TRUE;    /* success */
 174 }
 175
 176 ph_stats_t*
 177 ph_stats_new(void)
 178 {
 179         ph_stats_t      *ps;
 180         frame_data      *frame;
 181         guint           tot_packets, tot_bytes;
 182         progdlg_t       *progbar = NULL;
 183         gboolean        stop_flag;
 184         int             count;
 185         float           progbar_val;
 186         GTimeVal        start_time;
 187         gchar           status_str[100];
 188         int             progbar_nextstep;
 189         int             progbar_quantum;
 190
 191         /* Initialize the data */
 192         ps = g_new(ph_stats_t, 1);
 193         ps->tot_packets = 0;
 194         ps->tot_bytes = 0;
 195         ps->stats_tree = g_node_new(NULL);
 196         ps->first_time = 0.0;
 197         ps->last_time = 0.0;
 198
 199         /* Update the progress bar when it gets to this value. */
 200         progbar_nextstep = 0;
 201         /* When we reach the value that triggers a progress bar update,
 202            bump that value by this amount. */
 203         progbar_quantum = cfile.count/N_PROGBAR_UPDATES;
 204         /* Count of packets at which we've looked. */
 205         count = 0;
 206         /* Progress so far. */
 207         progbar_val = 0.0f;
 208
 209         stop_flag = FALSE;
 210         g_get_current_time(&start_time);
 211
 212         tot_packets = 0;
 213         tot_bytes = 0;
 214
 215         for (frame = cfile.plist_start; frame != NULL; frame = frame->next) {
 216                 /* Create the progress bar if necessary.
 217                    We check on every iteration of the loop, so that
 218                    it takes no longer than the standard time to create
 219                    it (otherwise, for a large file, we might take
 220                    considerably longer than that standard time in order
 221                    to get to the next progress bar step). */
 222                 if (progbar == NULL)
 223                         progbar = delayed_create_progress_dlg(
 224                             "Computing", "protocol hierarchy statistics",
 225                             TRUE, &stop_flag, &start_time, progbar_val);
 226
 227                 /* Update the progress bar, but do it only N_PROGBAR_UPDATES
 228                    times; when we update it, we have to run the GTK+ main
 229                    loop to get it to repaint what's pending, and doing so
 230                    may involve an "ioctl()" to see if there's any pending
 231                    input from an X server, and doing that for every packet
 232                    can be costly, especially on a big file. */
 233                 if (count >= progbar_nextstep) {
 234                         /* let's not divide by zero. I should never be started
 235                          * with count == 0, so let's assert that
 236                          */
 237                         g_assert(cfile.count > 0);
 238
 239                         progbar_val = (gfloat) count / cfile.count;
 240
 241                         if (progbar != NULL) {
 242                                 g_snprintf(status_str, sizeof(status_str),
 243                                         "%4u of %u frames", count, cfile.count);
 244                                 update_progress_dlg(progbar, progbar_val, status_str);
 245                         }
 246
 247                         progbar_nextstep += progbar_quantum;
 248                 }
 249
 250                 if (stop_flag) {
 251                         /* Well, the user decided to abort the statistics.
 252                            computation process  Just stop. */
 253                         break;
 254                 }
 255
 256                 /* Skip frames that are hidden due to the display filter.
 257                    XXX - should the progress bar count only packets that
 258                    passed the display filter?  If so, it should
 259                    probably do so for other loops (see "file.c") that
 260                    look only at those packets. */
 261                 if (frame->flags.passed_dfilter) {
 262
 263                         if (tot_packets == 0) {
 264                                 double cur_time = nstime_to_sec(&frame->abs_ts);
 265                                 ps->first_time = cur_time;
 266                                 ps->last_time = cur_time;
 267                         }
 268
 269                         /* we don't care about colinfo */
 270                         if (!process_frame(frame, NULL, ps)) {
 271                                 /*
 272                                  * Give up, and set "stop_flag" so we
 273                                  * just abort rather than popping up
 274                                  * the statistics window.
 275                                  */
 276                                 stop_flag = TRUE;
 277                                 break;
 278                         }
 279
 280                         tot_packets++;
 281                         tot_bytes += frame->pkt_len;
 282                 }
 283
 284                 count++;
 285         }
 286
 287         /* We're done calculating the statistics; destroy the progress bar
 288            if it was created. */
 289         if (progbar != NULL)
 290                 destroy_progress_dlg(progbar);
 291
 292         if (stop_flag) {
 293                 /*
 294                  * We quit in the middle; throw away the statistics
 295                  * and return NULL, so our caller doesn't pop up a
 296                  * window with the incomplete statistics.
 297                  */
 298                 ph_stats_free(ps);
 299                 return NULL;
 300         }
 301
 302         ps->tot_packets = tot_packets;
 303         ps->tot_bytes = tot_bytes;
 304
 305         return ps;
 306 }
 307
 308 static gboolean
 309 stat_node_free(GNode *node, gpointer data _U_)
 310 {
 311         ph_stats_node_t *stats = (ph_stats_node_t *)node->data;
 312
 313         if (stats) {
 314                 g_free(stats);
 315         }
 316         return FALSE;
 317 }
 318
 319 void
 320 ph_stats_free(ph_stats_t *ps)
 321 {
 322
 323         if (ps->stats_tree) {
 324                 g_node_traverse(ps->stats_tree, G_IN_ORDER,
 325                                 G_TRAVERSE_ALL, -1,
 326                                 stat_node_free, NULL);
 327                 g_node_destroy(ps->stats_tree);
 328         }
 329
 330         g_free(ps);
 331 }