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