Update some links.
[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 <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 }