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