Drop support of Visual Studio 2005
[metze/wireshark/wip.git] / ui / gtk / summary_dlg.c
1 /* summary_dlg.c
2  * Routines for capture file summary window
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23  */
24
25 #include "config.h"
26
27 #include <string.h>
28 #include <time.h>
29
30 #include <gtk/gtk.h>
31
32 #include <epan/strutil.h>
33
34 #include <wiretap/wtap.h>
35
36 #include "../globals.h"
37 #include "../file.h"
38 #include "../summary.h"
39 #include "../capture-pcap-util.h"
40 #include "../version_info.h"
41
42 #ifdef HAVE_LIBPCAP
43 #include "../capture.h"
44 #include "ui/capture_globals.h"
45 #endif
46 #include "ui/main_statusbar.h"
47 #include "ui/gtk/main.h"
48 #include "ui/gtk/summary_dlg.h"
49 #include "ui/gtk/dlg_utils.h"
50 #include "ui/gtk/gui_utils.h"
51 #include "ui/gtk/help_dlg.h"
52 #include "ui/gtk/packet_list.h"
53
54 #define SUM_STR_MAX      1024
55 #define FILTER_SNIP_LEN    50
56 #define SHB_STR_SNIP_LEN   50
57
58 static GtkWidget *summary_dlg = NULL;
59 static GtkWidget *view_capture_and_pkt_comments_dlg = NULL;
60
61
62 static void
63 add_string_to_grid_sensitive(GtkWidget *grid, guint *row, const gchar *title, const gchar *value, gboolean sensitive)
64 {
65     GtkWidget *label;
66     gchar     *indent;
67
68     if(strlen(value) != 0) {
69         indent = g_strdup_printf("   %s", title);
70     } else {
71         indent = g_strdup(title);
72     }
73     label = gtk_label_new(indent);
74     if (strlen(value) == 0) {
75       gchar *message = g_strdup_printf("<span weight=\"bold\">%s</span>", title);
76       gtk_label_set_markup(GTK_LABEL(label), message);
77       g_free (message);
78     }
79     g_free(indent);
80     gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
81     gtk_widget_set_sensitive(label, sensitive);
82     ws_gtk_grid_attach_defaults(GTK_GRID(grid), label, 0, *row, 1, 1);
83
84     label = gtk_label_new(value);
85     gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
86     gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
87     gtk_widget_set_sensitive(label, sensitive);
88     ws_gtk_grid_attach_defaults(GTK_GRID(grid), label, 1, *row, 1, 1);
89
90     *row = *row + 1;
91 }
92
93 static void
94 add_string_to_grid(GtkWidget *grid, guint *row, const gchar *title, const gchar *value)
95 {
96     add_string_to_grid_sensitive(grid, row, title, value, TRUE);
97 }
98
99
100 static void
101 add_string_to_list(GtkWidget *list, const gchar *title, gchar *captured,
102                    gchar *displayed, gchar *pct_displayed, gchar *marked,
103                    gchar *pct_marked)
104 {
105     simple_list_append(list,
106                        0, title,
107                        1, captured,
108                        2, displayed,
109                        3, pct_displayed,
110                        4, marked,
111                        5, pct_marked,
112                        -1);
113 }
114
115 static void
116 time_to_string(char *string_buff, gulong string_buff_size, time_t ti_time)
117 {
118   struct tm *ti_tm;
119
120   ti_tm = localtime(&ti_time);
121   if (ti_tm == NULL) {
122     g_snprintf(string_buff, string_buff_size, "Not representable");
123     return;
124   }
125   g_snprintf(string_buff, string_buff_size,
126              "%04d-%02d-%02d %02d:%02d:%02d",
127              ti_tm->tm_year + 1900,
128              ti_tm->tm_mon + 1,
129              ti_tm->tm_mday,
130              ti_tm->tm_hour,
131              ti_tm->tm_min,
132              ti_tm->tm_sec);
133 }
134
135 static void
136 summary_ok_cb(GtkWidget *w _U_, GtkWidget *view)
137 {
138   GtkTextBuffer *buffer;
139   GtkTextIter start_iter;
140   GtkTextIter end_iter;
141   gchar *new_comment = NULL;
142
143   if (view != NULL) {
144     buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
145     gtk_text_buffer_get_start_iter (buffer, &start_iter);
146     gtk_text_buffer_get_end_iter (buffer, &end_iter);
147
148     new_comment = gtk_text_buffer_get_text (buffer, &start_iter, &end_iter, FALSE /* whether to include invisible text */);
149
150     cf_update_capture_comment(&cfile, new_comment);
151
152     /* Update the main window */
153     main_update_for_unsaved_changes(&cfile);
154
155     status_capture_comment_update();
156   }
157
158   window_destroy(summary_dlg);
159 }
160
161 static void
162 summary_destroy_cb(GtkWidget *win _U_, gpointer user_data _U_)
163 {
164   /* Note that we no longer have a Summary dialog box. */
165   summary_dlg = NULL;
166 }
167
168 void
169 summary_open_cb(GtkWidget *w _U_, gpointer d _U_)
170 {
171   summary_tally      summary;
172   GtkWidget         *main_vb, *bbox, *cancel_bt, *ok_bt, *help_bt;
173   GtkWidget         *grid, *scrolled_window;
174   GtkWidget         *list, *treeview;
175   GtkWidget         *comment_view = NULL, *comment_frame, *comment_vbox;
176   GtkTextBuffer     *buffer = NULL;
177   gchar             *buf_str;
178   GtkListStore      *store;
179   GtkTreeIter        iter;
180   GtkCellRenderer   *renderer;
181   GtkTreeViewColumn *column;
182   static const char *titles[] = {
183     "Traffic", "Captured", "Displayed", "Displayed %", "Marked", "Marked %" };
184
185   gchar         string_buff[SUM_STR_MAX];
186   gchar         string_buff2[SUM_STR_MAX];
187   gchar         string_buff3[SUM_STR_MAX];
188   gchar         string_buff4[SUM_STR_MAX];
189   gchar         string_buff5[SUM_STR_MAX];
190
191   double        seconds;
192   double        disp_seconds;
193   double        marked_seconds;
194   guint         row;
195
196   unsigned int  elapsed_time;
197   iface_options iface;
198   unsigned int  i;
199
200   if (summary_dlg != NULL) {
201     /* There's already a Summary dialog box; reactivate it. */
202     reactivate_window(summary_dlg);
203     return;
204   }
205
206   /* initial computations */
207   summary_fill_in(&cfile, &summary);
208 #ifdef HAVE_LIBPCAP
209   summary_fill_in_capture(&cfile, &global_capture_opts, &summary);
210 #endif
211   /*
212    * Note: the start and stop times are initialized to 0, so if we
213    * have zero or one packets of the type in question that have
214    * time stamps, the elapsed times will be zero, just as if we
215    * have both start and stop time stamps but they're the same.
216    * That means we can avoid some checks for whether we have more
217    * than one packet of the type in question with time stamps.
218    */
219   seconds = summary.stop_time - summary.start_time;
220   disp_seconds = summary.filtered_stop - summary.filtered_start;
221   marked_seconds = summary.marked_stop - summary.marked_start;
222
223   summary_dlg = window_new(GTK_WINDOW_TOPLEVEL, "Wireshark: Summary");
224   gtk_window_set_default_size(GTK_WINDOW(summary_dlg), 400, 750);
225
226   /* Scrolled Window to hold them all */
227   scrolled_window = gtk_scrolled_window_new(NULL, NULL);
228   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
229   gtk_container_add(GTK_CONTAINER(summary_dlg), scrolled_window);
230
231   /* Container for each row of widgets */
232   main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 12, FALSE);
233   gtk_container_set_border_width(GTK_CONTAINER(main_vb), 12);
234 #if ! GTK_CHECK_VERSION(3,8,0)
235   gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), main_vb);
236 #else
237   gtk_container_add(GTK_CONTAINER(scrolled_window), main_vb);
238 #endif
239
240   /* grid */
241   grid = ws_gtk_grid_new();
242   ws_gtk_grid_set_column_spacing(GTK_GRID(grid), 6);
243   ws_gtk_grid_set_row_spacing(GTK_GRID(grid), 3);
244   gtk_box_pack_start(GTK_BOX(main_vb), grid, TRUE, TRUE, 0);
245   row = 0;
246
247   /* File */
248   add_string_to_grid(grid, &row, "File", "");
249
250   /* filename */
251   g_snprintf(string_buff, SUM_STR_MAX, "%s", summary.filename);
252   add_string_to_grid(grid, &row, "Name:", string_buff);
253
254   /* length */
255   g_snprintf(string_buff, SUM_STR_MAX, "%" G_GINT64_MODIFIER "d bytes",
256              summary.file_length);
257   add_string_to_grid(grid, &row, "Length:", string_buff);
258
259   /* format */
260   g_snprintf(string_buff, SUM_STR_MAX, "%s%s",
261              wtap_file_type_subtype_string(summary.file_type),
262              summary.iscompressed? " (gzip compressed)" : "");
263   add_string_to_grid(grid, &row, "Format:", string_buff);
264
265   /* encapsulation */
266   if (summary.file_encap_type == WTAP_ENCAP_PER_PACKET) {
267     for (i = 0; i < summary.packet_encap_types->len; i++) {
268       g_snprintf(string_buff, SUM_STR_MAX, "%s",
269                  wtap_encap_string(g_array_index(summary.packet_encap_types, int, i)));
270       add_string_to_grid(grid, &row, (i == 0) ? "Encapsulation:" : "",
271                           string_buff);
272     }
273   } else {
274     g_snprintf(string_buff, SUM_STR_MAX, "%s", wtap_encap_string(summary.file_encap_type));
275     add_string_to_grid(grid, &row, "Encapsulation:", string_buff);
276   }
277   if (summary.has_snap) {
278     /* snapshot length */
279     g_snprintf(string_buff, SUM_STR_MAX, "%u bytes", summary.snap);
280     add_string_to_grid(grid, &row, "Packet size limit:", string_buff);
281   }
282
283   /* Capture file comment area */
284   if (wtap_dump_can_write(cfile.linktypes, WTAP_COMMENT_PER_SECTION)) {
285     comment_frame = gtk_frame_new("Capture file comments");
286     gtk_frame_set_shadow_type(GTK_FRAME(comment_frame), GTK_SHADOW_ETCHED_IN);
287     gtk_box_pack_start(GTK_BOX(main_vb), comment_frame, TRUE, TRUE, 0);
288     gtk_widget_show(comment_frame);
289
290     comment_vbox = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
291     gtk_container_add(GTK_CONTAINER(comment_frame), comment_vbox);
292     gtk_widget_show(comment_vbox);
293
294     comment_view = gtk_text_view_new();
295     gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(comment_view), GTK_WRAP_WORD);
296     buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (comment_view));
297     if(summary.opt_comment == NULL) {
298       gtk_text_buffer_set_text (buffer, "", -1);
299     } else {
300       buf_str = g_strdup_printf("%s", summary.opt_comment);
301       gtk_text_buffer_set_text (buffer, buf_str, -1);
302       g_free(buf_str);
303     }
304     gtk_box_pack_start(GTK_BOX(comment_vbox), comment_view, TRUE, TRUE, 0);
305     gtk_widget_show (comment_view);
306   }
307
308   /*
309    * We must have no un-time-stamped packets (i.e., the number of
310    * time-stamped packets must be the same as the number of packets),
311    * and at least one time-stamped packet, in order for the start
312    * and stop times to be valid.
313    */
314   if (summary.packet_count_ts == summary.packet_count &&
315       summary.packet_count >= 1) {
316     /* Time */
317     add_string_to_grid(grid, &row, "", "");
318     add_string_to_grid(grid, &row, "Time", "");
319
320     /* start time */
321     time_to_string(string_buff, SUM_STR_MAX, (time_t)summary.start_time);
322     add_string_to_grid(grid, &row, "First packet:", string_buff);
323
324     /* stop time */
325     time_to_string(string_buff, SUM_STR_MAX, (time_t)summary.stop_time);
326     add_string_to_grid(grid, &row, "Last packet:", string_buff);
327
328     /*
329      * We must have at least two time-stamped packets for the elapsed time
330      * to be valid.
331      */
332     if (summary.packet_count_ts >= 2) {
333       /* elapsed seconds */
334       elapsed_time = (unsigned int)summary.elapsed_time;
335       if(elapsed_time/86400) {
336           g_snprintf(string_buff, SUM_STR_MAX, "%02u days %02u:%02u:%02u",
337             elapsed_time/86400, elapsed_time%86400/3600, elapsed_time%3600/60, elapsed_time%60);
338       } else {
339           g_snprintf(string_buff, SUM_STR_MAX, "%02u:%02u:%02u",
340             elapsed_time%86400/3600, elapsed_time%3600/60, elapsed_time%60);
341       }
342       add_string_to_grid(grid, &row, "Elapsed:", string_buff);
343     }
344   }
345
346   /* Capture */
347   add_string_to_grid(grid, &row, "", "");
348   add_string_to_grid_sensitive(grid, &row, "Capture", "", (summary.ifaces->len > 0));
349   if(summary.shb_hardware){
350     /* truncate the string to a reasonable length */
351     g_snprintf(string_buff, SHB_STR_SNIP_LEN, "%s",summary.shb_hardware);
352     add_string_to_grid(grid, &row, "Capture HW:",string_buff);
353   }
354   if(summary.shb_os){
355     /* truncate the strings to a reasonable length */
356     g_snprintf(string_buff, SHB_STR_SNIP_LEN, "%s",summary.shb_os);
357     add_string_to_grid(grid, &row, "OS:", string_buff);
358   }
359   if(summary.shb_user_appl){
360     /* truncate the string to a reasonable length */
361     g_snprintf(string_buff, SHB_STR_SNIP_LEN, "%s",summary.shb_user_appl);
362     add_string_to_grid(grid, &row, "Capture application:", string_buff);
363   }
364   scrolled_window = gtk_scrolled_window_new (NULL, NULL);
365   gtk_container_set_border_width (GTK_CONTAINER (scrolled_window), 5);
366   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
367                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
368   gtk_widget_set_size_request(scrolled_window, -1, 120);
369
370   treeview = gtk_tree_view_new();
371   renderer = gtk_cell_renderer_text_new();
372   column = gtk_tree_view_column_new_with_attributes("Interface", renderer, "text", 0, NULL);
373   gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
374   renderer = gtk_cell_renderer_text_new();
375   column = gtk_tree_view_column_new_with_attributes("Dropped Packets", renderer, "text", 1, NULL);
376   gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
377   renderer = gtk_cell_renderer_text_new();
378   column = gtk_tree_view_column_new_with_attributes("Capture Filter", renderer, "text", 2, NULL);
379   gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
380   renderer = gtk_cell_renderer_text_new();
381   column = gtk_tree_view_column_new_with_attributes("Link type", renderer, "text", 3, NULL);
382   gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
383   renderer = gtk_cell_renderer_text_new();
384   column = gtk_tree_view_column_new_with_attributes("Packet size limit", renderer, "text", 4, NULL);
385   gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
386
387   store = gtk_list_store_new(5, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
388   for (i = 0; i < summary.ifaces->len; i++) {
389     iface = g_array_index(summary.ifaces, iface_options, i);
390     /* interface */
391     if (iface.descr) {
392       g_snprintf(string_buff, SUM_STR_MAX, "%s", iface.descr);
393     } else if (iface.name) {
394       g_snprintf(string_buff, SUM_STR_MAX, "%s", iface.name);
395     } else {
396       g_snprintf(string_buff, SUM_STR_MAX, "unknown");
397     }
398     /* Dropped count */
399     if (iface.drops_known) {
400       g_snprintf(string_buff2, SUM_STR_MAX, "%" G_GINT64_MODIFIER "u (%.3f%%)",
401                  iface.drops, summary.packet_count ? (100.0 * iface.drops)/summary.packet_count : 0.0);
402     } else {
403       g_snprintf(string_buff2, SUM_STR_MAX, "unknown");
404     }
405     /* Capture filter */
406     if (iface.cfilter && iface.cfilter[0] != '\0') {
407       g_snprintf(string_buff3, SUM_STR_MAX, "%s", iface.cfilter);
408     } else {
409       if (iface.name) {
410         g_snprintf(string_buff3, SUM_STR_MAX, "none");
411       } else {
412         g_snprintf(string_buff3, SUM_STR_MAX, "unknown");
413       }
414     }
415     g_snprintf(string_buff4, SUM_STR_MAX, "%s", wtap_encap_string(iface.encap_type));
416     g_snprintf(string_buff5, SUM_STR_MAX, "%u bytes", iface.snap);
417     gtk_list_store_append(store, &iter);
418     gtk_list_store_set(store, &iter, 0, string_buff, 1, string_buff2, 2, string_buff3, 3, string_buff4, 4, string_buff5,-1);
419   }
420   gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(store));
421   g_object_unref (store);
422   gtk_container_add(GTK_CONTAINER(scrolled_window), treeview);
423   gtk_box_pack_start(GTK_BOX(main_vb), scrolled_window, TRUE, TRUE, 0);
424   gtk_widget_show_all(scrolled_window);
425   grid = ws_gtk_grid_new();
426   ws_gtk_grid_set_column_spacing(GTK_GRID(grid), 6);
427   ws_gtk_grid_set_row_spacing(GTK_GRID(grid), 3);
428   gtk_box_pack_start(GTK_BOX(main_vb), grid, TRUE, TRUE, 0);
429   row = 0;
430
431
432   /* Data */
433   add_string_to_grid(grid, &row, "", "");
434   add_string_to_grid(grid, &row, "Display", "");
435
436   if (summary.dfilter) {
437     /* Display filter */
438     add_string_to_grid(grid, &row, "Display filter:", summary.dfilter);
439   } else {
440     /* Display filter */
441     add_string_to_grid(grid, &row, "Display filter:", "none");
442   }
443
444   /* Ignored packet count */
445   g_snprintf(string_buff, SUM_STR_MAX, "%i (%.3f%%)", summary.ignored_count,
446              summary.packet_count ? (100.0 * summary.ignored_count)/summary.packet_count : 0.0);
447   add_string_to_grid(grid, &row, "Ignored packets:", string_buff);
448
449   /* Traffic */
450   list = simple_list_new(6, titles);
451   gtk_box_pack_start(GTK_BOX(main_vb), list, TRUE, TRUE, 0);
452
453 #define cap_buf         string_buff
454 #define disp_buf        string_buff2
455 #define disp_pct_buf    string_buff3
456 #define mark_buf        string_buff4
457 #define mark_pct_buf    string_buff5
458
459   /* Packet count */
460   g_snprintf(cap_buf, SUM_STR_MAX, "%i", summary.packet_count);
461   if (summary.dfilter) {
462     g_snprintf(disp_buf, SUM_STR_MAX, "%i", summary.filtered_count);
463     g_snprintf(disp_pct_buf, SUM_STR_MAX, "%.3f%%", summary.packet_count ?
464                (100.0 * summary.filtered_count)/summary.packet_count : 0.0);
465   } else {
466     g_strlcpy(disp_buf, cap_buf, SUM_STR_MAX);
467     g_strlcpy(disp_pct_buf, "100.000%", SUM_STR_MAX);
468   }
469   g_snprintf(mark_buf, SUM_STR_MAX, "%i", summary.marked_count);
470   g_snprintf(mark_pct_buf, SUM_STR_MAX, "%.3f%%", summary.packet_count ?
471              (100.0 * summary.marked_count)/summary.packet_count : 0.0);
472   add_string_to_list(list, "Packets", cap_buf,
473                      disp_buf, disp_pct_buf, mark_buf, mark_pct_buf);
474
475   /* Time between first and last */
476   if (seconds > 0) {
477     g_snprintf(cap_buf, SUM_STR_MAX, "%.3f sec", seconds);
478   } else {
479     cap_buf[0] = '\0';
480   }
481   if (summary.dfilter && disp_seconds > 0) {
482     g_snprintf(disp_buf, SUM_STR_MAX, "%.3f sec", disp_seconds);
483   } else {
484     disp_buf[0] = '\0';
485   }
486   disp_pct_buf[0] = '\0';
487   if (summary.marked_count && marked_seconds > 0) {
488     g_snprintf(mark_buf, SUM_STR_MAX, "%.3f sec", marked_seconds);
489   } else {
490     mark_buf[0] = '\0';
491   }
492   mark_pct_buf[0] = '\0';
493   if (cap_buf[0] != '\0' || disp_buf[0] != '\0' || mark_buf[0] != '\0') {
494     add_string_to_list(list, "Between first and last packet", cap_buf,
495                        disp_buf, disp_pct_buf, mark_buf, mark_pct_buf);
496   }
497
498   /* Average packets per second */
499   if (seconds > 0) {
500     g_snprintf(cap_buf, SUM_STR_MAX, "%.3f", summary.packet_count/seconds);
501   } else {
502     cap_buf[0] = '\0';
503   }
504   if(summary.dfilter && disp_seconds > 0) {
505     g_snprintf(disp_buf, SUM_STR_MAX, "%.3f", summary.filtered_count/disp_seconds);
506   } else {
507     disp_buf[0] = '\0';
508   }
509   disp_pct_buf[0] = '\0';
510   if(summary.marked_count && marked_seconds > 0) {
511     g_snprintf(mark_buf, SUM_STR_MAX, "%.3f", summary.marked_count/marked_seconds);
512   } else {
513     mark_buf[0] = '\0';
514   }
515   mark_pct_buf[0] = '\0';
516   if (cap_buf[0] != '\0' || disp_buf[0] != '\0' || mark_buf[0] != '\0') {
517     add_string_to_list(list, "Avg. packets/sec", cap_buf,
518                        disp_buf, disp_pct_buf, mark_buf, mark_pct_buf);
519   }
520
521   /* Average packet size */
522   if (summary.packet_count > 1) {
523     g_snprintf(cap_buf, SUM_STR_MAX, "%.3f bytes",
524                /* MSVC cannot convert from unsigned __int64 to float, so first convert to signed __int64 */
525                (float) ((gint64) summary.bytes)/summary.packet_count);
526   } else {
527     cap_buf[0] = '\0';
528   }
529   if (summary.dfilter && summary.filtered_count > 1) {
530     g_snprintf(disp_buf, SUM_STR_MAX, "%.3f bytes",
531                /* MSVC cannot convert from unsigned __int64 to float, so first convert to signed __int64 */
532                (float) ((gint64) summary.filtered_bytes)/summary.filtered_count);
533   } else {
534     disp_buf[0] = '\0';
535   }
536   disp_pct_buf[0] = '\0';
537   if (summary.marked_count > 1) {
538     g_snprintf(mark_buf, SUM_STR_MAX, "%.3f bytes",
539                /* MSVC cannot convert from unsigned __int64 to float, so first convert to signed __int64 */
540                (float) ((gint64) summary.marked_bytes)/summary.marked_count);
541   } else {
542     mark_buf[0] = '\0';
543   }
544   mark_pct_buf[0] = '\0';
545   if (cap_buf[0] != '\0' || disp_buf[0] != '\0' || mark_buf[0] != '\0') {
546     add_string_to_list(list, "Avg. packet size", cap_buf,
547                        disp_buf, disp_pct_buf, mark_buf, mark_pct_buf);
548   }
549
550   /* Byte count */
551   g_snprintf(cap_buf, SUM_STR_MAX, "%" G_GINT64_MODIFIER "u", summary.bytes);
552   if (summary.dfilter) {
553     g_snprintf(disp_buf, SUM_STR_MAX, "%" G_GINT64_MODIFIER "u", summary.filtered_bytes);
554     g_snprintf(disp_pct_buf, SUM_STR_MAX, "%.3f%%", summary.bytes ?
555                /* MSVC cannot convert from unsigned __int64 to float, so first convert to signed __int64 */
556                (100.0 * (gint64) summary.filtered_bytes)/summary.bytes : 0.0);
557   } else {
558     g_strlcpy(disp_buf, cap_buf, SUM_STR_MAX);
559     g_strlcpy(disp_pct_buf, "100.000%", SUM_STR_MAX);
560   }
561   if (summary.marked_count) {
562     g_snprintf(mark_buf, SUM_STR_MAX, "%" G_GINT64_MODIFIER "u", summary.marked_bytes);
563     g_snprintf(mark_pct_buf, SUM_STR_MAX, "%.3f%%", summary.bytes ?
564                /* MSVC cannot convert from unsigned __int64 to float, so first convert to signed __int64 */
565                (100.0 * (gint64) summary.marked_bytes)/summary.bytes : 0.0);
566   } else {
567     g_strlcpy(mark_buf, "0", SUM_STR_MAX);
568     g_strlcpy(mark_pct_buf, "0.000%", SUM_STR_MAX);
569   }
570   if (cap_buf[0] != '\0' || disp_buf[0] != '\0' || mark_buf[0] != '\0') {
571     add_string_to_list(list, "Bytes", cap_buf,
572                        disp_buf, disp_pct_buf, mark_buf, mark_pct_buf);
573   }
574
575   /* Bytes per second */
576   if (seconds > 0){
577     /* MSVC cannot convert from unsigned __int64 to float, so first convert to signed __int64 */
578     g_snprintf(cap_buf, SUM_STR_MAX, "%.3f", ((gint64) summary.bytes)/seconds);
579   } else {
580     cap_buf[0] = '\0';
581   }
582   if (summary.dfilter && disp_seconds > 0) {
583     /* MSVC cannot convert from unsigned __int64 to float, so first convert to signed __int64 */
584     g_snprintf(disp_buf, SUM_STR_MAX, "%.3f", ((gint64) summary.filtered_bytes)/disp_seconds);
585   } else {
586     disp_buf[0] = '\0';
587   }
588   disp_pct_buf[0] = '\0';
589   if (summary.marked_count && marked_seconds > 0) {
590     /* MSVC cannot convert from unsigned __int64 to float, so first convert to signed __int64 */
591     g_snprintf(mark_buf, SUM_STR_MAX, "%.3f", ((gint64) summary.marked_bytes)/marked_seconds);
592   } else {
593     mark_buf[0] = '\0';
594   }
595   mark_pct_buf[0] = '\0';
596   if (cap_buf[0] != '\0' || disp_buf[0] != '\0' || mark_buf[0] != '\0') {
597     add_string_to_list(list, "Avg. bytes/sec", cap_buf,
598                        disp_buf, disp_pct_buf, mark_buf, mark_pct_buf);
599   }
600
601   /* MBit per second */
602   if (seconds > 0) {
603     g_snprintf(cap_buf, SUM_STR_MAX, "%.3f",
604                /* MSVC cannot convert from unsigned __int64 to float, so first convert to signed __int64 */
605                ((gint64) summary.bytes) * 8.0 / (seconds * 1000.0 * 1000.0));
606   } else {
607     cap_buf[0] = '\0';
608   }
609   if (summary.dfilter && disp_seconds > 0) {
610     g_snprintf(disp_buf, SUM_STR_MAX, "%.3f",
611                /* MSVC cannot convert from unsigned __int64 to float, so first convert to signed __int64 */
612                ((gint64) summary.filtered_bytes) * 8.0 / (disp_seconds * 1000.0 * 1000.0));
613   } else {
614     disp_buf[0] = '\0';
615   }
616   disp_pct_buf[0] = '\0';
617   if (summary.marked_count && marked_seconds > 0) {
618     g_snprintf(mark_buf, SUM_STR_MAX, "%.3f",
619                /* MSVC cannot convert from unsigned __int64 to float, so first convert to signed __int64 */
620                ((gint64) summary.marked_bytes) * 8.0 / (marked_seconds * 1000.0 * 1000.0));
621   } else {
622     mark_buf[0] = '\0';
623   }
624   mark_pct_buf[0] = '\0';
625   if (cap_buf[0] != '\0' || disp_buf[0] != '\0' || mark_buf[0] != '\0') {
626     add_string_to_list(list, "Avg. MBit/sec", cap_buf,
627                        disp_buf, disp_pct_buf, mark_buf, mark_pct_buf);
628   }
629
630
631   /* Button row. */
632   bbox = dlg_button_row_new(GTK_STOCK_CANCEL, GTK_STOCK_OK, GTK_STOCK_HELP, NULL);
633   gtk_box_pack_start(GTK_BOX(main_vb), bbox, TRUE, TRUE, 0);
634
635   cancel_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
636   window_set_cancel_button(summary_dlg, cancel_bt, window_cancel_button_cb);
637
638   ok_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
639   g_signal_connect (ok_bt, "clicked",
640                     G_CALLBACK(summary_ok_cb), comment_view);
641   gtk_widget_grab_focus(ok_bt);
642
643   help_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);
644   g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_STATS_SUMMARY_DIALOG);
645
646
647   g_signal_connect(summary_dlg, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
648   g_signal_connect(summary_dlg, "destroy", G_CALLBACK(summary_destroy_cb), NULL);
649
650   gtk_widget_show_all(summary_dlg);
651   window_present(summary_dlg);
652 }
653
654 #define INDENT "   "
655 void
656 summary_to_texbuff(GtkTextBuffer *buffer)
657 {
658   summary_tally summary;
659   gchar         string_buff[SUM_STR_MAX];
660   gchar         tmp_buff[SUM_STR_MAX];
661   gchar *buf_str;
662   unsigned int  i;
663   unsigned int  elapsed_time;
664   iface_options iface;
665   double seconds;
666
667   /* initial computations */
668   summary_fill_in(&cfile, &summary);
669 #ifdef HAVE_LIBPCAP
670   summary_fill_in_capture(&cfile, &global_capture_opts, &summary);
671 #endif
672
673   /* Add Wireshark version*/
674   g_snprintf(string_buff, SUM_STR_MAX, "Summary created by Wireshark %s\n\n", wireshark_svnversion);
675   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
676
677   /* Info about file */
678   g_snprintf(string_buff, SUM_STR_MAX, "File: \n");
679   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
680
681   /* Filename */
682   g_snprintf(string_buff, SUM_STR_MAX, INDENT "Name: %s\n", summary.filename);
683   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
684
685   /* length */
686   g_snprintf(string_buff, SUM_STR_MAX, INDENT "Length: %" G_GINT64_MODIFIER "d bytes\n",
687              summary.file_length);
688   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
689
690   /* format */
691   g_snprintf(string_buff, SUM_STR_MAX, INDENT "Format: %s%s",
692              wtap_file_type_subtype_string(summary.file_type),
693              summary.iscompressed? " (gzip compressed)\n" : "\n");
694   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
695
696   /* encapsulation */
697   if (summary.file_encap_type == WTAP_ENCAP_PER_PACKET) {
698     for (i = 0; i < summary.packet_encap_types->len; i++) {
699       g_snprintf(string_buff, SUM_STR_MAX, INDENT "Encapsulation: %s\n",
700                  wtap_encap_string(g_array_index(summary.packet_encap_types, int, i)));
701       gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
702     }
703   } else {
704     g_snprintf(string_buff, SUM_STR_MAX, INDENT "Encapsulation: %s\n", wtap_encap_string(summary.file_encap_type));
705     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
706   }
707   if (summary.has_snap) {
708     /* snapshot length */
709     g_snprintf(string_buff, SUM_STR_MAX, INDENT "Packet size limit: %u bytes\n", summary.snap);
710     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
711   }
712
713   /* Add two empty lines */
714   g_snprintf(string_buff, SUM_STR_MAX, "\n\n");
715   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
716
717   /* Time Section */
718   if (summary.packet_count_ts == summary.packet_count &&
719       summary.packet_count >= 1) {
720     /* Add heading Time */
721     g_snprintf(string_buff, SUM_STR_MAX, "Time:\n");
722     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
723
724     /* start time */
725     time_to_string(tmp_buff, SUM_STR_MAX, (time_t)summary.start_time);
726     g_snprintf(string_buff, SUM_STR_MAX, INDENT "First packet: %s\n",tmp_buff);
727     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
728
729     /* stop time */
730     time_to_string(tmp_buff, SUM_STR_MAX, (time_t)summary.stop_time);
731     g_snprintf(string_buff, SUM_STR_MAX, INDENT "Last packet: %s\n", tmp_buff);
732     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
733
734     /*
735      * We must have at least two time-stamped packets for the elapsed time
736      * to be valid.
737      */
738     if (summary.packet_count_ts >= 2) {
739       /* elapsed seconds */
740       elapsed_time = (unsigned int)summary.elapsed_time;
741       if(elapsed_time/86400) {
742           g_snprintf(tmp_buff, SUM_STR_MAX, "%02u days %02u:%02u:%02u",
743             elapsed_time/86400, elapsed_time%86400/3600, elapsed_time%3600/60, elapsed_time%60);
744       } else {
745           g_snprintf(tmp_buff, SUM_STR_MAX, "%02u:%02u:%02u",
746             elapsed_time%86400/3600, elapsed_time%3600/60, elapsed_time%60);
747       }
748       g_snprintf(string_buff, SUM_STR_MAX, INDENT "Elapsed: %s\n", tmp_buff);
749       gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
750     }
751   }
752
753   /* Add two empty lines */
754   g_snprintf(string_buff, SUM_STR_MAX, "\n\n");
755   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
756
757   g_snprintf(string_buff, SUM_STR_MAX, "Capture:\n");
758   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
759
760   if(summary.shb_hardware){
761     /* truncate the string to a reasonable length */
762     g_snprintf(string_buff, SUM_STR_MAX, INDENT "Capture HW: %s\n",summary.shb_hardware);
763     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
764   }
765   if(summary.shb_os){
766     /* truncate the strings to a reasonable length */
767     g_snprintf(string_buff, SUM_STR_MAX, INDENT "OS: %s\n",summary.shb_os);
768     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
769   }
770   if(summary.shb_user_appl){
771     /* truncate the string to a reasonable length */
772     g_snprintf(string_buff, SUM_STR_MAX, INDENT "Capture application: %s\n",summary.shb_user_appl);
773     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
774   }
775
776   /* Add empty line */
777   g_snprintf(string_buff, SUM_STR_MAX, "\n");
778   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
779
780   /* Interface info */
781   for (i = 0; i < summary.ifaces->len; i++) {
782     iface = g_array_index(summary.ifaces, iface_options, i);
783     /* interface */
784     if (iface.descr) {
785       g_snprintf(string_buff, SUM_STR_MAX, INDENT "%s:\n", iface.descr);
786     } else if (iface.name) {
787       g_snprintf(string_buff, SUM_STR_MAX, INDENT "%s:\n", iface.name);
788     } else {
789       g_snprintf(string_buff, SUM_STR_MAX, INDENT "Unknown interface:\n");
790     }
791     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
792
793     /* Dropped count */
794     if (iface.drops_known) {
795       g_snprintf(string_buff, SUM_STR_MAX, INDENT INDENT "Dropped packets: %" G_GINT64_MODIFIER "u (%.3f%%)\n",
796                  iface.drops, summary.packet_count ? (100.0 * iface.drops)/summary.packet_count : 0.0);
797     } else {
798       g_snprintf(string_buff, SUM_STR_MAX, INDENT INDENT "Dropped packets: unknown\n");
799     }
800     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
801
802     /* Capture filter */
803     if (iface.cfilter && iface.cfilter[0] != '\0') {
804       g_snprintf(string_buff, SUM_STR_MAX, INDENT INDENT "Capture filter: %s\n", iface.cfilter);
805     } else {
806       if (iface.name) {
807         g_snprintf(string_buff, SUM_STR_MAX, INDENT INDENT "Capture filter: none\n");
808       } else {
809         g_snprintf(string_buff, SUM_STR_MAX, INDENT INDENT "Capture filter: unknown\n");
810       }
811     }
812     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
813
814     g_snprintf(string_buff, SUM_STR_MAX, INDENT INDENT "Link type: %s\n", wtap_encap_string(iface.encap_type));
815     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
816
817     g_snprintf(string_buff, SUM_STR_MAX, INDENT INDENT "Packet size limit %u bytes\n", iface.snap);
818     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
819
820   }
821
822   /* Add empty line */
823   g_snprintf(string_buff, SUM_STR_MAX, "\n");
824   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
825
826   /* Statistics */
827   g_snprintf(string_buff, SUM_STR_MAX, "Statistics:\n");
828   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
829
830   /* Packet count */
831   g_snprintf(cap_buf, SUM_STR_MAX, INDENT "Packets: %i\n", summary.packet_count);
832   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
833
834   /*
835    * Note: the start and stop times are initialized to 0, so if we
836    * have zero or one packets of the type in question that have
837    * time stamps, the elapsed times will be zero, just as if we
838    * have both start and stop time stamps but they're the same.
839    * That means we can avoid some checks for whether we have more
840    * than one packet of the type in question with time stamps.
841    */
842   seconds = summary.stop_time - summary.start_time;
843   /* Time between first and last */
844   if (seconds > 0) {
845     g_snprintf(string_buff, SUM_STR_MAX, INDENT "Between first and last packet:%.3f sec\n", seconds);
846     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
847   }
848
849   /* Average packets per second */
850   if (seconds > 0) {
851     g_snprintf(string_buff, SUM_STR_MAX, INDENT "Avg. packets/sec: %.3f\n", summary.packet_count/seconds);
852     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
853   }
854
855   /* Average packet size */
856   if (summary.packet_count > 1) {
857     g_snprintf(string_buff, SUM_STR_MAX, INDENT "Avg packet size: %.3f bytes\n",
858                /* MSVC cannot convert from unsigned __int64 to float, so first convert to signed __int64 */
859                (float) ((gint64) summary.bytes)/summary.packet_count);
860     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
861   }
862
863   /* Byte count */
864   g_snprintf(string_buff, SUM_STR_MAX, INDENT "Bytes: %" G_GINT64_MODIFIER "u\n", summary.bytes);
865   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
866
867   /* Bytes per second */
868   if (seconds > 0){
869     /* MSVC cannot convert from unsigned __int64 to float, so first convert to signed __int64 */
870     g_snprintf(string_buff, SUM_STR_MAX, INDENT "Avg bytes/sec: %.3f\n", ((gint64) summary.bytes)/seconds);
871     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
872   }
873
874   /* MBit per second */
875   if (seconds > 0) {
876     g_snprintf(string_buff, SUM_STR_MAX, INDENT "Avg Mbit/sec: %.3f\n",
877                /* MSVC cannot convert from unsigned __int64 to float, so first convert to signed __int64 */
878                ((gint64) summary.bytes) * 8.0 / (seconds * 1000.0 * 1000.0));
879     gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
880   }
881
882   /* Add empty line */
883   g_snprintf(string_buff, SUM_STR_MAX, "\n");
884   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
885
886   /* Trace file comments from SHB */
887   if(summary.opt_comment != NULL) {
888     buf_str = g_strdup_printf("%s", summary.opt_comment);
889     gtk_text_buffer_insert_at_cursor(buffer, buf_str, -1);
890     g_free(buf_str);
891   }
892
893
894   g_snprintf(string_buff, SUM_STR_MAX, "\n\n");
895   gtk_text_buffer_insert_at_cursor (buffer, string_buff, -1);
896
897 }
898
899 static void
900 comment_summary_copy_to_clipboard_cb(GtkWidget *w _U_, GtkWidget *view)
901 {
902   GtkTextBuffer *buffer;
903   GtkTextIter start_iter, end_iter;
904   GtkClipboard *clipboard;
905
906   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
907
908   gtk_text_buffer_get_bounds(buffer, &start_iter, &end_iter);
909
910   gtk_text_buffer_select_range(buffer, &start_iter, &end_iter);
911
912   clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);     /* Get the default clipboard */
913   gtk_text_buffer_copy_clipboard (buffer, clipboard);
914
915   gtk_text_buffer_select_range(buffer, &end_iter, &end_iter);
916
917 }
918
919 void
920 show_packet_comment_summary_dlg (GtkAction *action _U_, gpointer data _U_)
921 {
922
923   GtkWidget *vbox;
924   GtkWidget *view;
925   GtkWidget *scroll;
926   GtkWidget *bbox;
927   GtkWidget *copy_bt, *cancel_bt, *help_bt;
928   GtkTextBuffer *buffer;
929
930   view_capture_and_pkt_comments_dlg = dlg_window_new ("Comments Summary");
931   gtk_widget_set_size_request (view_capture_and_pkt_comments_dlg, 700, 350);
932   gtk_window_set_resizable (GTK_WINDOW (view_capture_and_pkt_comments_dlg), TRUE);
933   gtk_container_set_border_width (GTK_CONTAINER (view_capture_and_pkt_comments_dlg), DLG_OUTER_MARGIN);
934
935   vbox = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, DLG_UNRELATED_SPACING, FALSE);
936   gtk_container_add (GTK_CONTAINER (view_capture_and_pkt_comments_dlg), vbox);
937   gtk_widget_show (vbox);
938
939   view = gtk_text_view_new ();
940   gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(view), GTK_WRAP_WORD);
941   buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
942   gtk_widget_show (view);
943
944   scroll = gtk_scrolled_window_new(NULL, NULL);
945   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
946                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
947   gtk_container_add(GTK_CONTAINER(scroll), view);
948   gtk_widget_show(scroll);
949   gtk_box_pack_start(GTK_BOX (vbox), scroll, TRUE, TRUE, 0);
950
951   /* Add capture summary information */
952   summary_to_texbuff(buffer);
953
954   /* Add all packet comments */
955   packet_list_return_all_comments(buffer);
956
957   /* Button row. */
958   bbox = dlg_button_row_new (GTK_STOCK_COPY, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL);
959   gtk_box_pack_end (GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
960
961   copy_bt = (GtkWidget *)g_object_get_data (G_OBJECT(bbox), GTK_STOCK_COPY);
962   g_signal_connect (copy_bt, "clicked", G_CALLBACK(comment_summary_copy_to_clipboard_cb), view);
963   gtk_widget_set_sensitive (copy_bt, TRUE);
964
965   cancel_bt = (GtkWidget *)g_object_get_data (G_OBJECT(bbox), GTK_STOCK_CANCEL);
966   window_set_cancel_button (view_capture_and_pkt_comments_dlg, cancel_bt, window_cancel_button_cb);
967
968   help_bt = (GtkWidget *)g_object_get_data (G_OBJECT(bbox), GTK_STOCK_HELP);
969 #if 0
970   g_signal_connect (help_bt, "clicked",/* G_CALLBACK(topic_cb)*/NULL, /*(gpointer)HELP_MANUAL_ADDR_RESOLVE_DIALOG*/NULL);
971 #endif
972   gtk_widget_set_sensitive (help_bt, FALSE);
973
974   gtk_widget_grab_default (copy_bt);
975
976
977   gtk_widget_show (view_capture_and_pkt_comments_dlg);
978 }
979
980 /*
981  * Editor modelines
982  *
983  * Local Variables:
984  * c-basic-offset: 2
985  * tab-width: 8
986  * indent-tabs-mode: nil
987  * End:
988  *
989  * ex: set shiftwidth=2 tabstop=8 expandtab:
990  * :indentSize=2:tabSize=8:noTabs=true:
991  */