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