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