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