proto_hier_stats.c

   1 /* proto_hier_stats.c
   2  * Routines for calculating statistics based on protocol.
   3  *
   4  * $Id: proto_hier_stats.c,v 1.13 2002/03/31 20:37:48 guy Exp $
   5  *
   6  * Ethereal - Network traffic analyzer
   7  * By Gerald Combs <gerald@ethereal.com>
   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 "globals.h"
  30 #include "proto_hier_stats.h"
  31 #include "progress_dlg.h"
  32 #include <epan/epan_dissect.h>
  33 #include <wtap.h>
  34
  35 #include <stdio.h>
  36 #include <glib.h>
  37
  38 /* Update the progress bar this many times when scanning the packet list. */
  39 #define N_PROGBAR_UPDATES       100
  40
  41 #define STAT_NODE_STATS(n)   ((ph_stats_node_t*)(n)->data)
  42 #define STAT_NODE_HFINFO(n)  (STAT_NODE_STATS(n)->hfinfo)
  43
  44 static GNode*
  45 find_stat_node(GNode *parent_stat_node, header_field_info *needle_hfinfo)
  46 {
  47         GNode                   *needle_stat_node;
  48         header_field_info       *hfinfo;
  49         ph_stats_node_t         *stats;
  50
  51         needle_stat_node = g_node_first_child(parent_stat_node);
  52
  53         while (needle_stat_node) {
  54                 hfinfo = STAT_NODE_HFINFO(needle_stat_node);
  55                 if (hfinfo &&  hfinfo->id == needle_hfinfo->id) {
  56                         return needle_stat_node;
  57                 }
  58                 needle_stat_node = g_node_next_sibling(needle_stat_node);
  59         }
  60
  61         /* None found. Create one. */
  62         stats = g_new(ph_stats_node_t, 1);
  63
  64         /* Intialize counters */
  65         stats->hfinfo = needle_hfinfo;
  66         stats->num_pkts_total = 0;
  67         stats->num_pkts_last = 0;
  68         stats->num_bytes_total = 0;
  69         stats->num_bytes_last = 0;
  70
  71         needle_stat_node = g_node_new(stats);
  72         g_node_append(parent_stat_node, needle_stat_node);
  73         return needle_stat_node;
  74 }
  75
  76
  77 static void
  78 process_node(proto_item *ptree_node, GNode *parent_stat_node, ph_stats_t *ps, guint pkt_len)
  79 {
  80         field_info              *finfo;
  81         ph_stats_node_t *stats;
  82         proto_item              *proto_sibling_node;
  83         GNode                   *stat_node;
  84
  85         finfo = PITEM_FINFO(ptree_node);
  86         g_assert(finfo);
  87
  88         stat_node = find_stat_node(parent_stat_node, finfo->hfinfo);
  89
  90         /* Assert that the finfo is related to a protocol, not a field. */
  91         g_assert(finfo->hfinfo->parent == -1);
  92
  93         stats = STAT_NODE_STATS(stat_node);
  94         stats->num_pkts_total++;
  95         stats->num_bytes_total += pkt_len;
  96
  97         proto_sibling_node = g_node_next_sibling(ptree_node);
  98
  99         if (proto_sibling_node) {
 100                 process_node(proto_sibling_node, stat_node, ps, pkt_len);
 101         }
 102         else {
 103                 stats->num_pkts_last++;
 104                 stats->num_bytes_last += pkt_len;
 105         }
 106 }
 107
 108
 109
 110 static void
 111 process_tree(proto_tree *protocol_tree, ph_stats_t* ps, guint pkt_len)
 112 {
 113         proto_item      *ptree_node;
 114
 115         ptree_node = g_node_first_child(protocol_tree);
 116         if (!ptree_node) {
 117                 return;
 118         }
 119
 120         process_node(ptree_node, ps->stats_tree, ps, pkt_len);
 121 }
 122
 123 static void
 124 process_frame(frame_data *frame, column_info *cinfo, ph_stats_t* ps)
 125 {
 126         epan_dissect_t                  *edt;
 127         union wtap_pseudo_header        phdr;
 128         guint8                          pd[WTAP_MAX_PACKET_SIZE];
 129         int                             err;
 130
 131         /* Load the frame from the capture file */
 132         /* XX - do something with "err" */
 133         wtap_seek_read(cfile.wth, frame->file_off, &phdr,
 134                         pd, frame->cap_len, &err);
 135
 136         /* Dissect the frame */
 137         edt = epan_dissect_new(TRUE, FALSE);
 138         epan_dissect_run(edt, &phdr, pd, frame, cinfo);
 139
 140         /* Get stats from this protocol tree */
 141         process_tree(edt->tree, ps, frame->pkt_len);
 142
 143         /* Free our memory. */
 144         epan_dissect_free(edt);
 145 }
 146
 147
 148
 149 ph_stats_t*
 150 ph_stats_new(void)
 151 {
 152         ph_stats_t      *ps;
 153         frame_data      *frame;
 154         guint           tot_packets, tot_bytes;
 155         progdlg_t       *progbar;
 156         gboolean        stop_flag;
 157         guint32         progbar_quantum;
 158         guint32         progbar_nextstep;
 159         unsigned int    count;
 160
 161         /* Initialize the data */
 162         ps = g_new(ph_stats_t, 1);
 163         ps->tot_packets = 0;
 164         ps->tot_bytes = 0;
 165         ps->stats_tree = g_node_new(NULL);
 166
 167         /* Update the progress bar when it gets to this value. */
 168         progbar_nextstep = 0;
 169         /* When we reach the value that triggers a progress bar update,
 170            bump that value by this amount. */
 171         progbar_quantum = cfile.count/N_PROGBAR_UPDATES;
 172         /* Count of packets at which we've looked. */
 173         count = 0;
 174
 175         stop_flag = FALSE;
 176         progbar = create_progress_dlg("Computing protocol statistics", "Stop",
 177             &stop_flag);
 178
 179         tot_packets = 0;
 180         tot_bytes = 0;
 181
 182         for (frame = cfile.plist; frame != NULL; frame = frame->next) {
 183                 /* Update the progress bar, but do it only N_PROGBAR_UPDATES
 184                    times; when we update it, we have to run the GTK+ main
 185                    loop to get it to repaint what's pending, and doing so
 186                    may involve an "ioctl()" to see if there's any pending
 187                    input from an X server, and doing that for every packet
 188                    can be costly, especially on a big file. */
 189                 if (count >= progbar_nextstep) {
 190                         /* let's not divide by zero. I should never be started
 191                          * with count == 0, so let's assert that
 192                          */
 193                         g_assert(cfile.count > 0);
 194
 195                         update_progress_dlg(progbar,
 196                             (gfloat) count / cfile.count);
 197
 198                         progbar_nextstep += progbar_quantum;
 199                 }
 200
 201                 if (stop_flag) {
 202                         /* Well, the user decided to abort the statistics.
 203                            computation process  Just stop. */
 204                         break;
 205                 }
 206
 207                 /* Skip frames that are hidden due to the display filter.
 208                    XXX - should the progress bar count only packets that
 209                    passed the display filter?  If so, it should
 210                    probably do so for other loops (see "file.c") that
 211                    look only at those packets. */
 212                 if (frame->flags.passed_dfilter) {
 213                         process_frame(frame, &cfile.cinfo, ps);
 214
 215                         tot_packets++;
 216                         tot_bytes += frame->pkt_len;
 217                 }
 218
 219                 count++;
 220         }
 221
 222         /* We're done calculating the statistics; destroy the progress bar. */
 223         destroy_progress_dlg(progbar);
 224
 225         if (stop_flag) {
 226                 /*
 227                  * We quit in the middle; throw away the statistics
 228                  * and return NULL, so our caller doesn't pop up a
 229                  * window with the incomplete statistics.
 230                  */
 231                 ph_stats_free(ps);
 232                 return NULL;
 233         }
 234
 235         ps->tot_packets = tot_packets;
 236         ps->tot_bytes = tot_bytes;
 237
 238         return ps;
 239 }
 240
 241 static gboolean
 242 stat_node_free(GNode *node, gpointer data _U_)
 243 {
 244         ph_stats_node_t *stats = node->data;
 245
 246         if (stats) {
 247                 g_free(stats);
 248         }
 249         return FALSE;
 250 }
 251
 252 void
 253 ph_stats_free(ph_stats_t *ps)
 254 {
 255
 256         if (ps->stats_tree) {
 257                 g_node_traverse(ps->stats_tree, G_IN_ORDER,
 258                                 G_TRAVERSE_ALL, -1,
 259                                 stat_node_free, NULL);
 260                 g_node_destroy(ps->stats_tree);
 261         }
 262
 263         g_free(ps);
 264 }