The "file types" we have are actually combinations of types and
[metze/wireshark/wip.git] / file.c
1 /* file.c
2  * File I/O routines
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 #ifdef HAVE_UNISTD_H
28 #include <unistd.h>
29 #endif
30
31 #include <time.h>
32
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <string.h>
36 #include <ctype.h>
37 #include <errno.h>
38 #include <signal.h>
39
40 #ifdef HAVE_FCNTL_H
41 #include <fcntl.h>
42 #endif
43
44 #include <wsutil/tempfile.h>
45 #include <wsutil/file_util.h>
46
47 #include <wiretap/merge.h>
48
49 #include <epan/epan-int.h>
50 #include <epan/epan.h>
51 #include <epan/column.h>
52 #include <epan/packet.h>
53 #include <epan/column-utils.h>
54 #include <epan/expert.h>
55 #include <epan/filesystem.h>
56 #include <epan/prefs.h>
57 #include <epan/dfilter/dfilter.h>
58 #include <epan/epan_dissect.h>
59 #include <epan/tap.h>
60 #include <epan/dissectors/packet-data.h>
61 #include <epan/dissectors/packet-ber.h>
62 #include <epan/timestamp.h>
63 #include <epan/dfilter/dfilter-macro.h>
64 #include <epan/strutil.h>
65 #include <epan/addr_resolv.h>
66
67 #include "color.h"
68 #include "color_filters.h"
69 #include "cfile.h"
70 #include "file.h"
71 #include "fileset.h"
72 #include "frame_tvbuff.h"
73
74 #include "ui/alert_box.h"
75 #include "ui/simple_dialog.h"
76 #include "ui/main_statusbar.h"
77 #include "ui/progress_dlg.h"
78 #include "ui/ui_util.h"
79
80 #include "version_info.h"
81
82 /* Needed for addrinfo */
83 #ifdef HAVE_SYS_TYPES_H
84 # include <sys/types.h>
85 #endif
86
87 #ifdef HAVE_SYS_SOCKET_H
88 #include <sys/socket.h>
89 #endif
90
91 #ifdef HAVE_NETINET_IN_H
92 # include <netinet/in.h>
93 #endif
94
95 #ifdef HAVE_NETDB_H
96 # include <netdb.h>
97 #endif
98
99 #ifdef HAVE_WINSOCK2_H
100 # include <winsock2.h>
101 #endif
102
103 #if defined(_WIN32) && defined(INET6)
104 # include <ws2tcpip.h>
105 #endif
106
107 #ifdef HAVE_LIBPCAP
108 gboolean auto_scroll_live;
109 #endif
110
111 static void cf_reset_state(capture_file *cf);
112
113 static int read_packet(capture_file *cf, dfilter_t *dfcode, epan_dissect_t *edt,
114     column_info *cinfo, gint64 offset);
115
116 static void rescan_packets(capture_file *cf, const char *action, const char *action_item, gboolean redissect);
117
118 typedef enum {
119   MR_NOTMATCHED,
120   MR_MATCHED,
121   MR_ERROR
122 } match_result;
123 static match_result match_protocol_tree(capture_file *cf, frame_data *fdata,
124     void *criterion);
125 static void match_subtree_text(proto_node *node, gpointer data);
126 static match_result match_summary_line(capture_file *cf, frame_data *fdata,
127     void *criterion);
128 static match_result match_narrow_and_wide(capture_file *cf, frame_data *fdata,
129     void *criterion);
130 static match_result match_narrow(capture_file *cf, frame_data *fdata,
131     void *criterion);
132 static match_result match_wide(capture_file *cf, frame_data *fdata,
133     void *criterion);
134 static match_result match_binary(capture_file *cf, frame_data *fdata,
135     void *criterion);
136 static match_result match_dfilter(capture_file *cf, frame_data *fdata,
137     void *criterion);
138 static match_result match_marked(capture_file *cf, frame_data *fdata,
139     void *criterion);
140 static match_result match_time_reference(capture_file *cf, frame_data *fdata,
141     void *criterion);
142 static gboolean find_packet(capture_file *cf,
143     match_result (*match_function)(capture_file *, frame_data *, void *),
144     void *criterion, search_direction dir);
145
146 static const char *cf_get_user_packet_comment(capture_file *cf, const frame_data *fd);
147
148 static void cf_open_failure_alert_box(const char *filename, int err,
149                       gchar *err_info, gboolean for_writing,
150                       int file_type);
151 static void cf_rename_failure_alert_box(const char *filename, int err);
152 static void cf_close_failure_alert_box(const char *filename, int err);
153 static void ref_time_packets(capture_file *cf);
154 /* Update the progress bar this many times when reading a file. */
155 #define N_PROGBAR_UPDATES   100
156 /* We read around 200k/100ms don't update the progress bar more often than that */
157 #define MIN_QUANTUM         200000
158 #define MIN_NUMBER_OF_PACKET 1500
159
160 /*
161  * We could probably use g_signal_...() instead of the callbacks below but that
162  * would require linking our CLI programs to libgobject and creating an object
163  * instance for the signals.
164  */
165 typedef struct {
166   cf_callback_t cb_fct;
167   gpointer      user_data;
168 } cf_callback_data_t;
169
170 static GList *cf_callbacks = NULL;
171
172 static void
173 cf_callback_invoke(int event, gpointer data)
174 {
175   cf_callback_data_t *cb;
176   GList              *cb_item = cf_callbacks;
177
178   /* there should be at least one interested */
179   g_assert(cb_item != NULL);
180
181   while (cb_item != NULL) {
182     cb = (cf_callback_data_t *)cb_item->data;
183     cb->cb_fct(event, data, cb->user_data);
184     cb_item = g_list_next(cb_item);
185   }
186 }
187
188
189 void
190 cf_callback_add(cf_callback_t func, gpointer user_data)
191 {
192   cf_callback_data_t *cb;
193
194   cb = g_new(cf_callback_data_t,1);
195   cb->cb_fct = func;
196   cb->user_data = user_data;
197
198   cf_callbacks = g_list_prepend(cf_callbacks, cb);
199 }
200
201 void
202 cf_callback_remove(cf_callback_t func)
203 {
204   cf_callback_data_t *cb;
205   GList              *cb_item = cf_callbacks;
206
207   while (cb_item != NULL) {
208     cb = (cf_callback_data_t *)cb_item->data;
209     if (cb->cb_fct == func) {
210       cf_callbacks = g_list_remove(cf_callbacks, cb);
211       g_free(cb);
212       return;
213     }
214     cb_item = g_list_next(cb_item);
215   }
216
217   g_assert_not_reached();
218 }
219
220 void
221 cf_timestamp_auto_precision(capture_file *cf)
222 {
223   int i;
224   int prec = timestamp_get_precision();
225
226
227   /* don't try to get the file's precision if none is opened */
228   if (cf->state == FILE_CLOSED) {
229     return;
230   }
231
232   /* if we are in auto mode, set precision of current file */
233   if (prec == TS_PREC_AUTO ||
234      prec == TS_PREC_AUTO_SEC ||
235      prec == TS_PREC_AUTO_DSEC ||
236      prec == TS_PREC_AUTO_CSEC ||
237      prec == TS_PREC_AUTO_MSEC ||
238      prec == TS_PREC_AUTO_USEC ||
239      prec == TS_PREC_AUTO_NSEC)
240   {
241     switch(wtap_file_tsprecision(cf->wth)) {
242     case(WTAP_FILE_TSPREC_SEC):
243       timestamp_set_precision(TS_PREC_AUTO_SEC);
244       break;
245     case(WTAP_FILE_TSPREC_DSEC):
246       timestamp_set_precision(TS_PREC_AUTO_DSEC);
247       break;
248     case(WTAP_FILE_TSPREC_CSEC):
249       timestamp_set_precision(TS_PREC_AUTO_CSEC);
250       break;
251     case(WTAP_FILE_TSPREC_MSEC):
252       timestamp_set_precision(TS_PREC_AUTO_MSEC);
253       break;
254     case(WTAP_FILE_TSPREC_USEC):
255       timestamp_set_precision(TS_PREC_AUTO_USEC);
256       break;
257     case(WTAP_FILE_TSPREC_NSEC):
258       timestamp_set_precision(TS_PREC_AUTO_NSEC);
259       break;
260     default:
261       g_assert_not_reached();
262     }
263   }
264   /* Set the column widths of those columns that show the time in
265      "command-line-specified" format. */
266   for (i = 0; i < cf->cinfo.num_cols; i++) {
267     if (col_has_time_fmt(&cf->cinfo, i)) {
268       packet_list_resize_column(i);
269     }
270   }
271 }
272
273 gulong
274 cf_get_computed_elapsed(capture_file *cf)
275 {
276   return cf->computed_elapsed;
277 }
278
279 /*
280  * GLIB_CHECK_VERSION(2,28,0) adds g_get_real_time which could minimize or
281  * replace this
282  */
283 static void compute_elapsed(capture_file *cf, GTimeVal *start_time)
284 {
285   gdouble  delta_time;
286   GTimeVal time_now;
287
288   g_get_current_time(&time_now);
289
290   delta_time = (time_now.tv_sec - start_time->tv_sec) * 1e6 +
291     time_now.tv_usec - start_time->tv_usec;
292
293   cf->computed_elapsed = (gulong) (delta_time / 1000); /* ms */
294 }
295
296 static const nstime_t *
297 ws_get_frame_ts(void *data, guint32 frame_num)
298 {
299   capture_file *cf = (capture_file *) data;
300
301   if (cf->prev_dis && cf->prev_dis->num == frame_num)
302     return &cf->prev_dis->abs_ts;
303
304   if (cf->prev_cap && cf->prev_cap->num == frame_num)
305     return &cf->prev_cap->abs_ts;
306
307   if (cf->frames) {
308     frame_data *fd = frame_data_sequence_find(cf->frames, frame_num);
309
310     return (fd) ? &fd->abs_ts : NULL;
311   }
312
313   return NULL;
314 }
315
316 static const char *
317 ws_get_user_comment(void *data, const frame_data *fd)
318 {
319   capture_file *cf = (capture_file *) data;
320
321   return cf_get_user_packet_comment(cf, fd);
322 }
323
324 static epan_t *
325 ws_epan_new(capture_file *cf)
326 {
327   epan_t *epan = epan_new();
328
329   epan->data = cf;
330   epan->get_frame_ts = ws_get_frame_ts;
331   epan->get_interface_name = cap_file_get_interface_name;
332   epan->get_user_comment = ws_get_user_comment;
333
334   return epan;
335 }
336
337 cf_status_t
338 cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
339 {
340   wtap  *wth;
341   gchar *err_info;
342
343   wth = wtap_open_offline(fname, err, &err_info, TRUE);
344   if (wth == NULL)
345     goto fail;
346
347   /* The open succeeded.  Close whatever capture file we had open,
348      and fill in the information for this file. */
349   cf_close(cf);
350
351   /* XXX - we really want to initialize this after we've read all
352      the packets, so we know how much we'll ultimately need. */
353   buffer_init(&cf->buf, 1500);
354
355   /* Create new epan session for dissection.
356    * (The old one was freed in cf_close().)
357    */
358   cf->epan = ws_epan_new(cf);
359
360   /* We're about to start reading the file. */
361   cf->state = FILE_READ_IN_PROGRESS;
362
363   cf->wth = wth;
364   cf->f_datalen = 0;
365
366   /* Set the file name because we need it to set the follow stream filter.
367      XXX - is that still true?  We need it for other reasons, though,
368      in any case. */
369   cf->filename = g_strdup(fname);
370
371   /* Indicate whether it's a permanent or temporary file. */
372   cf->is_tempfile = is_tempfile;
373
374   /* No user changes yet. */
375   cf->unsaved_changes = FALSE;
376
377   cf->computed_elapsed = 0;
378
379   cf->cd_t        = wtap_file_type_subtype(cf->wth);
380   cf->linktypes = g_array_sized_new(FALSE, FALSE, (guint) sizeof(int), 1);
381   cf->count     = 0;
382   cf->packet_comment_count = 0;
383   cf->displayed_count = 0;
384   cf->marked_count = 0;
385   cf->ignored_count = 0;
386   cf->ref_time_count = 0;
387   cf->drops_known = FALSE;
388   cf->drops     = 0;
389   cf->snap      = wtap_snapshot_length(cf->wth);
390   if (cf->snap == 0) {
391     /* Snapshot length not known. */
392     cf->has_snap = FALSE;
393     cf->snap = WTAP_MAX_PACKET_SIZE;
394   } else
395     cf->has_snap = TRUE;
396
397   /* Allocate a frame_data_sequence for the frames in this file */
398   cf->frames = new_frame_data_sequence();
399
400   nstime_set_zero(&cf->elapsed_time);
401   cf->ref = NULL;
402   cf->prev_dis = NULL;
403   cf->prev_cap = NULL;
404   cf->cum_bytes = 0;
405
406   /* Adjust timestamp precision if auto is selected, col width will be adjusted */
407   cf_timestamp_auto_precision(cf);
408   /* XXX needed ? */
409   packet_list_queue_draw();
410   cf_callback_invoke(cf_cb_file_opened, cf);
411
412   if (cf->cd_t == WTAP_FILE_TYPE_SUBTYPE_BER) {
413     /* tell the BER dissector the file name */
414     ber_set_filename(cf->filename);
415   }
416
417   wtap_set_cb_new_ipv4(cf->wth, add_ipv4_name);
418   wtap_set_cb_new_ipv6(cf->wth, (wtap_new_ipv6_callback_t) add_ipv6_name);
419
420   return CF_OK;
421
422 fail:
423   cf_open_failure_alert_box(fname, *err, err_info, FALSE, 0);
424   return CF_ERROR;
425 }
426
427 /*
428  * Add an encapsulation type to cf->linktypes.
429  */
430 static void
431 cf_add_encapsulation_type(capture_file *cf, int encap)
432 {
433   guint i;
434
435   for (i = 0; i < cf->linktypes->len; i++) {
436     if (g_array_index(cf->linktypes, gint, i) == encap)
437       return; /* it's already there */
438   }
439   /* It's not already there - add it. */
440   g_array_append_val(cf->linktypes, encap);
441 }
442
443 /*
444  * Reset the state for the currently closed file, but don't do the
445  * UI callbacks; this is for use in "cf_open()", where we don't
446  * want the UI to go from "file open" to "file closed" back to
447  * "file open", we want it to go from "old file open" to "new file
448  * open and being read".
449  *
450  * XXX - currently, cf_open() calls cf_close(), rather than
451  * cf_reset_state().
452  */
453 static void
454 cf_reset_state(capture_file *cf)
455 {
456   /* Die if we're in the middle of reading a file. */
457   g_assert(cf->state != FILE_READ_IN_PROGRESS);
458
459   if (cf->wth) {
460     wtap_close(cf->wth);
461     cf->wth = NULL;
462   }
463   /* We have no file open... */
464   if (cf->filename != NULL) {
465     /* If it's a temporary file, remove it. */
466     if (cf->is_tempfile)
467       ws_unlink(cf->filename);
468     g_free(cf->filename);
469     cf->filename = NULL;
470   }
471   /* ...which means we have no changes to that file to save. */
472   cf->unsaved_changes = FALSE;
473
474   /* Free up the packet buffer. */
475   buffer_free(&cf->buf);
476
477   dfilter_free(cf->rfcode);
478   cf->rfcode = NULL;
479   if (cf->frames != NULL) {
480     free_frame_data_sequence(cf->frames);
481     cf->frames = NULL;
482   }
483 #ifdef WANT_PACKET_EDITOR
484   if (cf->edited_frames) {
485     g_tree_destroy(cf->edited_frames);
486     cf->edited_frames = NULL;
487   }
488 #endif
489   if (cf->frames_user_comments) {
490     g_tree_destroy(cf->frames_user_comments);
491     cf->frames_user_comments = NULL;
492   }
493   cf_unselect_packet(cf);   /* nothing to select */
494   cf->first_displayed = 0;
495   cf->last_displayed = 0;
496
497   /* No frames, no frame selected, no field in that frame selected. */
498   cf->count = 0;
499   cf->current_frame = 0;
500   cf->current_row = 0;
501   cf->finfo_selected = NULL;
502
503   /* No frame link-layer types, either. */
504   g_array_free(cf->linktypes, TRUE);
505   cf->linktypes = NULL;
506
507   /* Clear the packet list. */
508   packet_list_freeze();
509   packet_list_clear();
510   packet_list_thaw();
511
512   cf->f_datalen = 0;
513   nstime_set_zero(&cf->elapsed_time);
514
515   reset_tap_listeners();
516
517   /* We have no file open. */
518   cf->state = FILE_CLOSED;
519 }
520
521 /* Reset everything to a pristine state */
522 void
523 cf_close(capture_file *cf)
524 {
525   if (cf->state != FILE_CLOSED) {
526     cf_callback_invoke(cf_cb_file_closing, cf);
527
528   /* close things, if not already closed before */
529     color_filters_cleanup();
530     cf_reset_state(cf);
531     epan_free(cf->epan);
532     cf->epan = NULL;
533
534     cf_callback_invoke(cf_cb_file_closed, cf);
535   }
536 }
537
538 static float
539 calc_progbar_val(capture_file *cf, gint64 size, gint64 file_pos, gchar *status_str, gulong status_size)
540 {
541   float progbar_val;
542
543   progbar_val = (gfloat) file_pos / (gfloat) size;
544   if (progbar_val > 1.0) {
545
546     /*  The file probably grew while we were reading it.
547      *  Update file size, and try again.
548      */
549     size = wtap_file_size(cf->wth, NULL);
550
551     if (size >= 0)
552       progbar_val = (gfloat) file_pos / (gfloat) size;
553
554     /*  If it's still > 1, either "wtap_file_size()" failed (in which
555      *  case there's not much we can do about it), or the file
556      *  *shrank* (in which case there's not much we can do about
557      *  it); just clip the progress value at 1.0.
558      */
559     if (progbar_val > 1.0f)
560       progbar_val = 1.0f;
561   }
562
563   g_snprintf(status_str, status_size,
564              "%" G_GINT64_MODIFIER "dKB of %" G_GINT64_MODIFIER "dKB",
565              file_pos / 1024, size / 1024);
566
567   return progbar_val;
568 }
569
570 cf_read_status_t
571 cf_read(capture_file *cf, gboolean reloading)
572 {
573   int                  err;
574   gchar               *err_info;
575   gchar               *name_ptr;
576   progdlg_t           *progbar        = NULL;
577   gboolean             stop_flag;
578   GTimeVal             start_time;
579   epan_dissect_t       edt;
580   dfilter_t           *dfcode;
581   volatile gboolean    create_proto_tree;
582   guint                tap_flags;
583   gboolean             compiled;
584
585   /* Compile the current display filter.
586    * We assume this will not fail since cf->dfilter is only set in
587    * cf_filter IFF the filter was valid.
588    */
589   compiled = dfilter_compile(cf->dfilter, &dfcode);
590   g_assert(!cf->dfilter || (compiled && dfcode));
591
592   /* Get the union of the flags for all tap listeners. */
593   tap_flags = union_of_tap_listener_flags();
594   create_proto_tree =
595     (dfcode != NULL || have_filtering_tap_listeners() || (tap_flags & TL_REQUIRES_PROTO_TREE));
596
597   reset_tap_listeners();
598
599   name_ptr = g_filename_display_basename(cf->filename);
600
601   if (reloading)
602     cf_callback_invoke(cf_cb_file_reload_started, cf);
603   else
604     cf_callback_invoke(cf_cb_file_read_started, cf);
605
606   /* Record whether the file is compressed.
607      XXX - do we know this at open time? */
608   cf->iscompressed = wtap_iscompressed(cf->wth);
609
610   /* The packet list window will be empty until the file is completly loaded */
611   packet_list_freeze();
612
613   stop_flag = FALSE;
614   g_get_current_time(&start_time);
615
616   epan_dissect_init(&edt, cf->epan, create_proto_tree, FALSE);
617
618   TRY {
619 #ifdef HAVE_LIBPCAP
620     int     displayed_once    = 0;
621 #endif
622     int     count             = 0;
623
624     gint64  size;
625     gint64  file_pos;
626     gint64  data_offset;
627
628     gint64  progbar_quantum;
629     gint64  progbar_nextstep;
630     float   progbar_val;
631     gchar   status_str[100];
632
633     column_info *cinfo;
634
635     cinfo = (tap_flags & TL_REQUIRES_COLUMNS) ? &cf->cinfo : NULL;
636
637     /* Find the size of the file. */
638     size = wtap_file_size(cf->wth, NULL);
639
640     /* Update the progress bar when it gets to this value. */
641     progbar_nextstep = 0;
642     /* When we reach the value that triggers a progress bar update,
643        bump that value by this amount. */
644     if (size >= 0) {
645       progbar_quantum = size/N_PROGBAR_UPDATES;
646       if (progbar_quantum < MIN_QUANTUM)
647         progbar_quantum = MIN_QUANTUM;
648     }else
649       progbar_quantum = 0;
650
651     while ((wtap_read(cf->wth, &err, &err_info, &data_offset))) {
652       if (size >= 0) {
653         count++;
654         file_pos = wtap_read_so_far(cf->wth);
655
656         /* Create the progress bar if necessary.
657          * Check whether it should be created or not every MIN_NUMBER_OF_PACKET
658          */
659         if ((progbar == NULL) && !(count % MIN_NUMBER_OF_PACKET)) {
660           progbar_val = calc_progbar_val(cf, size, file_pos, status_str, sizeof(status_str));
661           if (reloading)
662             progbar = delayed_create_progress_dlg(cf->window, "Reloading", name_ptr,
663                 TRUE, &stop_flag, &start_time, progbar_val);
664           else
665             progbar = delayed_create_progress_dlg(cf->window, "Loading", name_ptr,
666                 TRUE, &stop_flag, &start_time, progbar_val);
667         }
668
669         /* Update the progress bar, but do it only N_PROGBAR_UPDATES times;
670            when we update it, we have to run the GTK+ main loop to get it
671            to repaint what's pending, and doing so may involve an "ioctl()"
672            to see if there's any pending input from an X server, and doing
673            that for every packet can be costly, especially on a big file. */
674         if (file_pos >= progbar_nextstep) {
675           if (progbar != NULL) {
676             progbar_val = calc_progbar_val(cf, size, file_pos, status_str, sizeof(status_str));
677             /* update the packet bar content on the first run or frequently on very large files */
678 #ifdef HAVE_LIBPCAP
679             if (progbar_quantum > 500000 || displayed_once == 0) {
680               if ((auto_scroll_live || displayed_once == 0 || cf->displayed_count < 1000) && cf->count != 0) {
681                 displayed_once = 1;
682                 packets_bar_update();
683               }
684             }
685 #endif /* HAVE_LIBPCAP */
686             update_progress_dlg(progbar, progbar_val, status_str);
687           }
688           progbar_nextstep += progbar_quantum;
689         }
690       }
691
692       if (stop_flag) {
693         /* Well, the user decided to abort the read. He/She will be warned and
694            it might be enough for him/her to work with the already loaded
695            packets.
696            This is especially true for very large capture files, where you don't
697            want to wait loading the whole file (which may last minutes or even
698            hours even on fast machines) just to see that it was the wrong file. */
699         break;
700       }
701       read_packet(cf, dfcode, &edt, cinfo, data_offset);
702     }
703   }
704   CATCH(OutOfMemoryError) {
705     simple_message_box(ESD_TYPE_ERROR, NULL,
706                    "Some infos / workarounds can be found at:\n"
707                    "http://wiki.wireshark.org/KnownBugs/OutOfMemory",
708                    "Sorry, but Wireshark has run out of memory and has to terminate now!");
709 #if 0
710     /* Could we close the current capture and free up memory from that? */
711 #else
712     /* we have to terminate, as we cannot recover from the memory error */
713     exit(1);
714 #endif
715   }
716   ENDTRY;
717
718   /* Free the display name */
719   g_free(name_ptr);
720
721   /* Cleanup and release all dfilter resources */
722   if (dfcode != NULL) {
723     dfilter_free(dfcode);
724   }
725
726   epan_dissect_cleanup(&edt);
727
728   /* We're done reading the file; destroy the progress bar if it was created. */
729   if (progbar != NULL)
730     destroy_progress_dlg(progbar);
731
732   /* We're done reading sequentially through the file. */
733   cf->state = FILE_READ_DONE;
734
735   /* Close the sequential I/O side, to free up memory it requires. */
736   wtap_sequential_close(cf->wth);
737
738   /* Allow the protocol dissectors to free up memory that they
739    * don't need after the sequential run-through of the packets. */
740   postseq_cleanup_all_protocols();
741
742   /* compute the time it took to load the file */
743   compute_elapsed(cf, &start_time);
744
745   /* Set the file encapsulation type now; we don't know what it is until
746      we've looked at all the packets, as we don't know until then whether
747      there's more than one type (and thus whether it's
748      WTAP_ENCAP_PER_PACKET). */
749   cf->lnk_t = wtap_file_encap(cf->wth);
750
751   cf->current_frame = frame_data_sequence_find(cf->frames, cf->first_displayed);
752   cf->current_row = 0;
753
754   packet_list_thaw();
755   if (reloading)
756     cf_callback_invoke(cf_cb_file_reload_finished, cf);
757   else
758     cf_callback_invoke(cf_cb_file_read_finished, cf);
759
760   /* If we have any displayed packets to select, select the first of those
761      packets by making the first row the selected row. */
762   if (cf->first_displayed != 0) {
763     packet_list_select_first_row();
764   }
765
766   if (stop_flag) {
767     simple_message_box(ESD_TYPE_WARN, NULL,
768                   "The remaining packets in the file were discarded.\n"
769                   "\n"
770                   "As a lot of packets from the original file will be missing,\n"
771                   "remember to be careful when saving the current content to a file.\n",
772                   "File loading was cancelled!");
773     return CF_READ_ERROR;
774   }
775
776   if (err != 0) {
777     /* Put up a message box noting that the read failed somewhere along
778        the line.  Don't throw out the stuff we managed to read, though,
779        if any. */
780     switch (err) {
781
782     case WTAP_ERR_UNSUPPORTED:
783       simple_error_message_box(
784                  "The capture file contains record data that Wireshark doesn't support.\n(%s)",
785                  err_info);
786       g_free(err_info);
787       break;
788
789     case WTAP_ERR_UNSUPPORTED_ENCAP:
790       simple_error_message_box(
791                  "The capture file has a packet with a network type that Wireshark doesn't support.\n(%s)",
792                  err_info);
793       g_free(err_info);
794       break;
795
796     case WTAP_ERR_CANT_READ:
797       simple_error_message_box(
798                  "An attempt to read from the capture file failed for"
799                  " some unknown reason.");
800       break;
801
802     case WTAP_ERR_SHORT_READ:
803       simple_error_message_box(
804                  "The capture file appears to have been cut short"
805                  " in the middle of a packet.");
806       break;
807
808     case WTAP_ERR_BAD_FILE:
809       simple_error_message_box(
810                  "The capture file appears to be damaged or corrupt.\n(%s)",
811                  err_info);
812       g_free(err_info);
813       break;
814
815     case WTAP_ERR_DECOMPRESS:
816       simple_error_message_box(
817                  "The compressed capture file appears to be damaged or corrupt.\n"
818                  "(%s)", err_info);
819       g_free(err_info);
820       break;
821
822     default:
823       simple_error_message_box(
824                  "An error occurred while reading the"
825                  " capture file: %s.", wtap_strerror(err));
826       break;
827     }
828     return CF_READ_ERROR;
829   } else
830     return CF_READ_OK;
831 }
832
833 #ifdef HAVE_LIBPCAP
834 cf_read_status_t
835 cf_continue_tail(capture_file *cf, volatile int to_read, int *err)
836 {
837   gchar            *err_info;
838   int               newly_displayed_packets = 0;
839   dfilter_t        *dfcode;
840   epan_dissect_t       edt;
841   gboolean create_proto_tree;
842   guint             tap_flags;
843   gboolean          compiled;
844
845   /* Compile the current display filter.
846    * We assume this will not fail since cf->dfilter is only set in
847    * cf_filter IFF the filter was valid.
848    */
849   compiled = dfilter_compile(cf->dfilter, &dfcode);
850   g_assert(!cf->dfilter || (compiled && dfcode));
851
852   /* Get the union of the flags for all tap listeners. */
853   tap_flags = union_of_tap_listener_flags();
854   create_proto_tree =
855     (dfcode != NULL || have_filtering_tap_listeners() || (tap_flags & TL_REQUIRES_PROTO_TREE));
856
857   *err = 0;
858
859   packet_list_check_end();
860   /* Don't freeze/thaw the list when doing live capture */
861   /*packet_list_freeze();*/
862
863   /*g_log(NULL, G_LOG_LEVEL_MESSAGE, "cf_continue_tail: %u new: %u", cf->count, to_read);*/
864
865   epan_dissect_init(&edt, cf->epan, create_proto_tree, FALSE);
866
867   TRY {
868     gint64 data_offset = 0;
869     column_info *cinfo;
870
871     cinfo = (tap_flags & TL_REQUIRES_COLUMNS) ? &cf->cinfo : NULL;
872
873     while (to_read != 0) {
874       wtap_cleareof(cf->wth);
875       if (!wtap_read(cf->wth, err, &err_info, &data_offset)) {
876         break;
877       }
878       if (cf->state == FILE_READ_ABORTED) {
879         /* Well, the user decided to exit Wireshark.  Break out of the
880            loop, and let the code below (which is called even if there
881            aren't any packets left to read) exit. */
882         break;
883       }
884       if (read_packet(cf, dfcode, &edt, (column_info *) cinfo, data_offset) != -1) {
885         newly_displayed_packets++;
886       }
887       to_read--;
888     }
889   }
890   CATCH(OutOfMemoryError) {
891     simple_message_box(ESD_TYPE_ERROR, NULL,
892                    "Some infos / workarounds can be found at:\n"
893                    "http://wiki.wireshark.org/KnownBugs/OutOfMemory",
894                    "Sorry, but Wireshark has run out of memory and has to terminate now!");
895 #if 0
896     /* Could we close the current capture and free up memory from that? */
897     return CF_READ_ABORTED;
898 #else
899     /* we have to terminate, as we cannot recover from the memory error */
900     exit(1);
901 #endif
902   }
903   ENDTRY;
904
905   /* Update the file encapsulation; it might have changed based on the
906      packets we've read. */
907   cf->lnk_t = wtap_file_encap(cf->wth);
908
909   /* Cleanup and release all dfilter resources */
910   if (dfcode != NULL) {
911     dfilter_free(dfcode);
912   }
913
914   epan_dissect_cleanup(&edt);
915
916   /*g_log(NULL, G_LOG_LEVEL_MESSAGE, "cf_continue_tail: count %u state: %u err: %u",
917     cf->count, cf->state, *err);*/
918
919   /* Don't freeze/thaw the list when doing live capture */
920   /*packet_list_thaw();*/
921   /* With the new packet list the first packet
922    * isn't automatically selected.
923    */
924   if (!cf->current_frame)
925     packet_list_select_first_row();
926
927   /* moving to the end of the packet list - if the user requested so and
928      we have some new packets. */
929   if (newly_displayed_packets && auto_scroll_live && cf->count != 0)
930       packet_list_moveto_end();
931
932   if (cf->state == FILE_READ_ABORTED) {
933     /* Well, the user decided to exit Wireshark.  Return CF_READ_ABORTED
934        so that our caller can kill off the capture child process;
935        this will cause an EOF on the pipe from the child, so
936        "cf_finish_tail()" will be called, and it will clean up
937        and exit. */
938     return CF_READ_ABORTED;
939   } else if (*err != 0) {
940     /* We got an error reading the capture file.
941        XXX - pop up a dialog box instead? */
942     g_warning("Error \"%s\" while reading: \"%s\" (\"%s\")",
943         wtap_strerror(*err), err_info, cf->filename);
944     g_free(err_info);
945
946     return CF_READ_ERROR;
947   } else
948     return CF_READ_OK;
949 }
950
951 void
952 cf_fake_continue_tail(capture_file *cf) {
953   cf->state = FILE_READ_DONE;
954 }
955
956 cf_read_status_t
957 cf_finish_tail(capture_file *cf, int *err)
958 {
959   gchar     *err_info;
960   gint64     data_offset;
961   dfilter_t *dfcode;
962   column_info *cinfo;
963   epan_dissect_t edt;
964   gboolean   create_proto_tree;
965   guint      tap_flags;
966   gboolean   compiled;
967
968   /* Compile the current display filter.
969    * We assume this will not fail since cf->dfilter is only set in
970    * cf_filter IFF the filter was valid.
971    */
972   compiled = dfilter_compile(cf->dfilter, &dfcode);
973   g_assert(!cf->dfilter || (compiled && dfcode));
974
975   /* Get the union of the flags for all tap listeners. */
976   tap_flags = union_of_tap_listener_flags();
977   cinfo = (tap_flags & TL_REQUIRES_COLUMNS) ? &cf->cinfo : NULL;
978   create_proto_tree =
979     (dfcode != NULL || have_filtering_tap_listeners() || (tap_flags & TL_REQUIRES_PROTO_TREE));
980
981   if (cf->wth == NULL) {
982     cf_close(cf);
983     return CF_READ_ERROR;
984   }
985
986   packet_list_check_end();
987   /* Don't freeze/thaw the list when doing live capture */
988   /*packet_list_freeze();*/
989
990   epan_dissect_init(&edt, cf->epan, create_proto_tree, FALSE);
991
992   while ((wtap_read(cf->wth, err, &err_info, &data_offset))) {
993     if (cf->state == FILE_READ_ABORTED) {
994       /* Well, the user decided to abort the read.  Break out of the
995          loop, and let the code below (which is called even if there
996          aren't any packets left to read) exit. */
997       break;
998     }
999     read_packet(cf, dfcode, &edt, cinfo, data_offset);
1000   }
1001
1002   /* Cleanup and release all dfilter resources */
1003   if (dfcode != NULL) {
1004     dfilter_free(dfcode);
1005   }
1006
1007   epan_dissect_cleanup(&edt);
1008
1009   /* Don't freeze/thaw the list when doing live capture */
1010   /*packet_list_thaw();*/
1011
1012   if (cf->state == FILE_READ_ABORTED) {
1013     /* Well, the user decided to abort the read.  We're only called
1014        when the child capture process closes the pipe to us (meaning
1015        it's probably exited), so we can just close the capture
1016        file; we return CF_READ_ABORTED so our caller can do whatever
1017        is appropriate when that happens. */
1018     cf_close(cf);
1019     return CF_READ_ABORTED;
1020   }
1021
1022   if (auto_scroll_live && cf->count != 0)
1023     packet_list_moveto_end();
1024
1025   /* We're done reading sequentially through the file. */
1026   cf->state = FILE_READ_DONE;
1027
1028   /* We're done reading sequentially through the file; close the
1029      sequential I/O side, to free up memory it requires. */
1030   wtap_sequential_close(cf->wth);
1031
1032   /* Allow the protocol dissectors to free up memory that they
1033    * don't need after the sequential run-through of the packets. */
1034   postseq_cleanup_all_protocols();
1035
1036   /* Update the file encapsulation; it might have changed based on the
1037      packets we've read. */
1038   cf->lnk_t = wtap_file_encap(cf->wth);
1039
1040   /* Update the details in the file-set dialog, as the capture file
1041    * has likely grown since we first stat-ed it */
1042   fileset_update_file(cf->filename);
1043
1044   if (*err != 0) {
1045     /* We got an error reading the capture file.
1046        XXX - pop up a dialog box? */
1047
1048     g_warning("Error \"%s\" while reading: \"%s\" (\"%s\")",
1049         wtap_strerror(*err), err_info, cf->filename);
1050     g_free(err_info);
1051     return CF_READ_ERROR;
1052   } else {
1053     return CF_READ_OK;
1054   }
1055 }
1056 #endif /* HAVE_LIBPCAP */
1057
1058 gchar *
1059 cf_get_display_name(capture_file *cf)
1060 {
1061   gchar *displayname;
1062
1063   /* Return a name to use in displays */
1064   if (!cf->is_tempfile) {
1065     /* Get the last component of the file name, and use that. */
1066     if (cf->filename) {
1067       displayname = g_filename_display_basename(cf->filename);
1068     } else {
1069       displayname=g_strdup("(No file)");
1070     }
1071   } else {
1072     /* The file we read is a temporary file from a live capture or
1073        a merge operation; we don't mention its name, but, if it's
1074        from a capture, give the source of the capture. */
1075     if (cf->source) {
1076       displayname = g_strdup(cf->source);
1077     } else {
1078       displayname = g_strdup("(Untitled)");
1079     }
1080   }
1081   return displayname;
1082 }
1083
1084 void cf_set_tempfile_source(capture_file *cf, gchar *source) {
1085   if (cf->source) {
1086     g_free(cf->source);
1087   }
1088
1089   if (source) {
1090     cf->source = g_strdup(source);
1091   } else {
1092     cf->source = g_strdup("");
1093   }
1094 }
1095
1096 const gchar *cf_get_tempfile_source(capture_file *cf) {
1097   if (!cf->source) {
1098     return "";
1099   }
1100
1101   return cf->source;
1102 }
1103
1104 /* XXX - use a macro instead? */
1105 int
1106 cf_get_packet_count(capture_file *cf)
1107 {
1108   return cf->count;
1109 }
1110
1111 /* XXX - use a macro instead? */
1112 void
1113 cf_set_packet_count(capture_file *cf, int packet_count)
1114 {
1115   cf->count = packet_count;
1116 }
1117
1118 /* XXX - use a macro instead? */
1119 gboolean
1120 cf_is_tempfile(capture_file *cf)
1121 {
1122   return cf->is_tempfile;
1123 }
1124
1125 void cf_set_tempfile(capture_file *cf, gboolean is_tempfile)
1126 {
1127   cf->is_tempfile = is_tempfile;
1128 }
1129
1130
1131 /* XXX - use a macro instead? */
1132 void cf_set_drops_known(capture_file *cf, gboolean drops_known)
1133 {
1134   cf->drops_known = drops_known;
1135 }
1136
1137 /* XXX - use a macro instead? */
1138 void cf_set_drops(capture_file *cf, guint32 drops)
1139 {
1140   cf->drops = drops;
1141 }
1142
1143 /* XXX - use a macro instead? */
1144 gboolean cf_get_drops_known(capture_file *cf)
1145 {
1146   return cf->drops_known;
1147 }
1148
1149 /* XXX - use a macro instead? */
1150 guint32 cf_get_drops(capture_file *cf)
1151 {
1152   return cf->drops;
1153 }
1154
1155 void cf_set_rfcode(capture_file *cf, dfilter_t *rfcode)
1156 {
1157   cf->rfcode = rfcode;
1158 }
1159
1160 static int
1161 add_packet_to_packet_list(frame_data *fdata, capture_file *cf,
1162     epan_dissect_t *edt, dfilter_t *dfcode, column_info *cinfo,
1163     struct wtap_pkthdr *phdr, const guint8 *buf, gboolean add_to_packet_list)
1164 {
1165   gint            row               = -1;
1166
1167   frame_data_set_before_dissect(fdata, &cf->elapsed_time,
1168                                 &cf->ref, cf->prev_dis);
1169   cf->prev_cap = fdata;
1170
1171   if (dfcode != NULL) {
1172       epan_dissect_prime_dfilter(edt, dfcode);
1173   }
1174
1175   /* Dissect the frame. */
1176   epan_dissect_run_with_taps(edt, phdr, frame_tvbuff_new(fdata, buf), fdata, cinfo);
1177
1178   /* If we don't have a display filter, set "passed_dfilter" to 1. */
1179   if (dfcode != NULL) {
1180     fdata->flags.passed_dfilter = dfilter_apply_edt(dfcode, edt) ? 1 : 0;
1181
1182     if (fdata->flags.passed_dfilter) {
1183       /* This frame passed the display filter but it may depend on other
1184        * (potentially not displayed) frames.  Find those frames and mark them
1185        * as depended upon.
1186        */
1187       g_slist_foreach(edt->pi.dependent_frames, find_and_mark_frame_depended_upon, cf->frames);
1188     }
1189   } else
1190     fdata->flags.passed_dfilter = 1;
1191
1192   if (fdata->flags.passed_dfilter || fdata->flags.ref_time)
1193     cf->displayed_count++;
1194
1195   if (add_to_packet_list) {
1196     /* We fill the needed columns from new_packet_list */
1197       row = packet_list_append(cinfo, fdata, &edt->pi);
1198   }
1199
1200   if (fdata->flags.passed_dfilter || fdata->flags.ref_time)
1201   {
1202     frame_data_set_after_dissect(fdata, &cf->cum_bytes);
1203     cf->prev_dis = fdata;
1204
1205     /* If we haven't yet seen the first frame, this is it.
1206
1207        XXX - we must do this before we add the row to the display,
1208        as, if the display's GtkCList's selection mode is
1209        GTK_SELECTION_BROWSE, when the first entry is added to it,
1210        "cf_select_packet()" will be called, and it will fetch the row
1211        data for the 0th row, and will get a null pointer rather than
1212        "fdata", as "gtk_clist_append()" won't yet have returned and
1213        thus "gtk_clist_set_row_data()" won't yet have been called.
1214
1215        We thus need to leave behind bread crumbs so that
1216        "cf_select_packet()" can find this frame.  See the comment
1217        in "cf_select_packet()". */
1218     if (cf->first_displayed == 0)
1219       cf->first_displayed = fdata->num;
1220
1221     /* This is the last frame we've seen so far. */
1222     cf->last_displayed = fdata->num;
1223   }
1224
1225   epan_dissect_reset(edt);
1226   return row;
1227 }
1228
1229 /* read in a new packet */
1230 /* returns the row of the new packet in the packet list or -1 if not displayed */
1231 static int
1232 read_packet(capture_file *cf, dfilter_t *dfcode, epan_dissect_t *edt,
1233             column_info *cinfo, gint64 offset)
1234 {
1235   struct wtap_pkthdr *phdr = wtap_phdr(cf->wth);
1236   const guint8 *buf = wtap_buf_ptr(cf->wth);
1237   frame_data    fdlocal;
1238   guint32       framenum;
1239   frame_data   *fdata;
1240   int           passed;
1241   int           row = -1;
1242
1243   /* Add this packet's link-layer encapsulation type to cf->linktypes, if
1244      it's not already there.
1245      XXX - yes, this is O(N), so if every packet had a different
1246      link-layer encapsulation type, it'd be O(N^2) to read the file, but
1247      there are probably going to be a small number of encapsulation types
1248      in a file. */
1249   cf_add_encapsulation_type(cf, phdr->pkt_encap);
1250
1251   /* The frame number of this packet is one more than the count of
1252      frames in the file so far. */
1253   framenum = cf->count + 1;
1254
1255   frame_data_init(&fdlocal, framenum, phdr, offset, cf->cum_bytes);
1256
1257   passed = TRUE;
1258   if (cf->rfcode) {
1259     epan_dissect_t rf_edt;
1260
1261     epan_dissect_init(&rf_edt, cf->epan, TRUE, FALSE);
1262     epan_dissect_prime_dfilter(&rf_edt, cf->rfcode);
1263     epan_dissect_run(&rf_edt, phdr, frame_tvbuff_new(&fdlocal, buf), &fdlocal, NULL);
1264     passed = dfilter_apply_edt(cf->rfcode, &rf_edt);
1265     epan_dissect_cleanup(&rf_edt);
1266   }
1267
1268   if (passed) {
1269     /* This does a shallow copy of fdlocal, which is good enough. */
1270     fdata = frame_data_sequence_add(cf->frames, &fdlocal);
1271
1272     cf->count++;
1273     if (phdr->opt_comment != NULL)
1274       cf->packet_comment_count++;
1275     cf->f_datalen = offset + fdlocal.cap_len;
1276
1277     if (!cf->redissecting) {
1278       row = add_packet_to_packet_list(fdata, cf, edt, dfcode,
1279                                       cinfo, phdr, buf, TRUE);
1280     }
1281   }
1282
1283   return row;
1284 }
1285
1286 cf_status_t
1287 cf_merge_files(char **out_filenamep, int in_file_count,
1288                char *const *in_filenames, int file_type, gboolean do_append)
1289 {
1290   merge_in_file_t *in_files, *in_file;
1291   char            *out_filename;
1292   char            *tmpname;
1293   int              out_fd;
1294   wtap_dumper     *pdh;
1295   int              open_err, read_err, write_err, close_err;
1296   gchar           *err_info;
1297   int              err_fileno;
1298   int              i;
1299   gboolean         got_read_error     = FALSE, got_write_error = FALSE;
1300   gint64           data_offset;
1301   progdlg_t       *progbar            = NULL;
1302   gboolean         stop_flag;
1303   gint64           f_len, file_pos;
1304   float            progbar_val;
1305   GTimeVal         start_time;
1306   gchar            status_str[100];
1307   gint64           progbar_nextstep;
1308   gint64           progbar_quantum;
1309   gchar           *display_basename;
1310   int              selected_frame_type;
1311   gboolean         fake_interface_ids = FALSE;
1312
1313   /* open the input files */
1314   if (!merge_open_in_files(in_file_count, in_filenames, &in_files,
1315                            &open_err, &err_info, &err_fileno)) {
1316     g_free(in_files);
1317     cf_open_failure_alert_box(in_filenames[err_fileno], open_err, err_info,
1318                               FALSE, 0);
1319     return CF_ERROR;
1320   }
1321
1322   if (*out_filenamep != NULL) {
1323     out_filename = *out_filenamep;
1324     out_fd = ws_open(out_filename, O_CREAT|O_TRUNC|O_BINARY, 0600);
1325     if (out_fd == -1)
1326       open_err = errno;
1327   } else {
1328     out_fd = create_tempfile(&tmpname, "wireshark");
1329     if (out_fd == -1)
1330       open_err = errno;
1331     out_filename = g_strdup(tmpname);
1332     *out_filenamep = out_filename;
1333   }
1334   if (out_fd == -1) {
1335     err_info = NULL;
1336     merge_close_in_files(in_file_count, in_files);
1337     g_free(in_files);
1338     cf_open_failure_alert_box(out_filename, open_err, NULL, TRUE, file_type);
1339     return CF_ERROR;
1340   }
1341
1342   selected_frame_type = merge_select_frame_type(in_file_count, in_files);
1343
1344   /* If we are trying to merge a number of libpcap files with different encapsulation types
1345    * change the output file type to pcapng and create SHB and IDB:s for the new file use the
1346    * interface index stored in in_files per file to change the phdr before writing the datablock.
1347    * XXX should it be an option to convert to pcapng?
1348    *
1349    * We need something similar when merging pcapng files possibly with an option to say
1350    * the same interface(s) used in all in files. SHBs comments should be merged together.
1351    */
1352   if ((selected_frame_type == WTAP_ENCAP_PER_PACKET)&&(file_type == WTAP_FILE_TYPE_SUBTYPE_PCAP)) {
1353     /* Write output in pcapng format */
1354     wtapng_section_t            *shb_hdr;
1355     wtapng_iface_descriptions_t *idb_inf, *idb_inf_merge_file;
1356     wtapng_if_descr_t            int_data, *file_int_data;
1357     GString                     *comment_gstr;
1358
1359     fake_interface_ids = TRUE;
1360     /* Create SHB info */
1361     shb_hdr      = wtap_file_get_shb_info(in_files[0].wth);
1362     comment_gstr = g_string_new("");
1363     g_string_append_printf(comment_gstr, "%s \n",shb_hdr->opt_comment);
1364     g_string_append_printf(comment_gstr, "File created by merging: \n");
1365     file_type = WTAP_FILE_TYPE_SUBTYPE_PCAPNG;
1366
1367     for (i = 0; i < in_file_count; i++) {
1368         g_string_append_printf(comment_gstr, "File%d: %s \n",i+1,in_files[i].filename);
1369     }
1370     shb_hdr->section_length = -1;
1371     /* options */
1372     shb_hdr->opt_comment   = g_string_free(comment_gstr, FALSE);  /* NULL if not available */
1373     shb_hdr->shb_hardware  = NULL;        /* NULL if not available, UTF-8 string containing the        */
1374                                           /*  description of the hardware used to create this section. */
1375     shb_hdr->shb_os        = NULL;        /* NULL if not available, UTF-8 string containing the name   */
1376                                           /*  of the operating system used to create this section.     */
1377     shb_hdr->shb_user_appl = "Wireshark"; /* NULL if not available, UTF-8 string containing the name   */
1378                                           /*  of the application used to create this section.          */
1379
1380     /* create fake IDB info */
1381     idb_inf = g_new(wtapng_iface_descriptions_t,1);
1382     idb_inf->number_of_interfaces = in_file_count; /* TODO make this the number of DIFFERENT encapsulation types
1383                                                     * check that snaplength is the same too?
1384                                                     */
1385     idb_inf->interface_data = g_array_new(FALSE, FALSE, sizeof(wtapng_if_descr_t));
1386
1387     for (i = 0; i < in_file_count; i++) {
1388       idb_inf_merge_file               = wtap_file_get_idb_info(in_files[i].wth);
1389       /* read the interface data from the in file to our combined interfca data */
1390       file_int_data = &g_array_index (idb_inf_merge_file->interface_data, wtapng_if_descr_t, 0);
1391       int_data.wtap_encap            = file_int_data->wtap_encap;
1392       int_data.time_units_per_second = file_int_data->time_units_per_second;
1393       int_data.link_type             = file_int_data->link_type;
1394       int_data.snap_len              = file_int_data->snap_len;
1395       int_data.if_name               = g_strdup(file_int_data->if_name);
1396       int_data.opt_comment           = NULL;
1397       int_data.if_description        = NULL;
1398       int_data.if_speed              = 0;
1399       int_data.if_tsresol            = 6;
1400       int_data.if_filter_str         = NULL;
1401       int_data.bpf_filter_len        = 0;
1402       int_data.if_filter_bpf_bytes   = NULL;
1403       int_data.if_os                 = NULL;
1404       int_data.if_fcslen             = -1;
1405       int_data.num_stat_entries      = 0;          /* Number of ISB:s */
1406       int_data.interface_statistics  = NULL;
1407
1408       g_array_append_val(idb_inf->interface_data, int_data);
1409       g_free(idb_inf_merge_file);
1410
1411       /* Set fake interface Id in per file data */
1412       in_files[i].interface_id = i;
1413     }
1414
1415     pdh = wtap_dump_fdopen_ng(out_fd, file_type,
1416                               selected_frame_type,
1417                               merge_max_snapshot_length(in_file_count, in_files),
1418                               FALSE /* compressed */, shb_hdr, idb_inf /* wtapng_iface_descriptions_t *idb_inf */, &open_err);
1419
1420     if (pdh == NULL) {
1421       ws_close(out_fd);
1422       merge_close_in_files(in_file_count, in_files);
1423       g_free(in_files);
1424       cf_open_failure_alert_box(out_filename, open_err, err_info, TRUE,
1425                                 file_type);
1426       return CF_ERROR;
1427     }
1428
1429   } else {
1430
1431     pdh = wtap_dump_fdopen(out_fd, file_type,
1432                            selected_frame_type,
1433                            merge_max_snapshot_length(in_file_count, in_files),
1434                            FALSE /* compressed */, &open_err);
1435     if (pdh == NULL) {
1436       ws_close(out_fd);
1437       merge_close_in_files(in_file_count, in_files);
1438       g_free(in_files);
1439       cf_open_failure_alert_box(out_filename, open_err, err_info, TRUE,
1440                                 file_type);
1441       return CF_ERROR;
1442     }
1443   }
1444
1445   /* Get the sum of the sizes of all the files. */
1446   f_len = 0;
1447   for (i = 0; i < in_file_count; i++)
1448     f_len += in_files[i].size;
1449
1450   /* Update the progress bar when it gets to this value. */
1451   progbar_nextstep = 0;
1452   /* When we reach the value that triggers a progress bar update,
1453      bump that value by this amount. */
1454   progbar_quantum = f_len/N_PROGBAR_UPDATES;
1455   /* Progress so far. */
1456   progbar_val = 0.0f;
1457
1458   stop_flag = FALSE;
1459   g_get_current_time(&start_time);
1460
1461   /* do the merge (or append) */
1462   for (;;) {
1463     if (do_append)
1464       in_file = merge_append_read_packet(in_file_count, in_files, &read_err,
1465                                          &err_info);
1466     else
1467       in_file = merge_read_packet(in_file_count, in_files, &read_err,
1468                                   &err_info);
1469     if (in_file == NULL) {
1470       /* EOF */
1471       break;
1472     }
1473
1474     if (read_err != 0) {
1475       /* I/O error reading from in_file */
1476       got_read_error = TRUE;
1477       break;
1478     }
1479
1480     /* Get the sum of the data offsets in all of the files. */
1481     data_offset = 0;
1482     for (i = 0; i < in_file_count; i++)
1483       data_offset += in_files[i].data_offset;
1484
1485     /* Create the progress bar if necessary.
1486        We check on every iteration of the loop, so that it takes no
1487        longer than the standard time to create it (otherwise, for a
1488        large file, we might take considerably longer than that standard
1489        time in order to get to the next progress bar step). */
1490     if (progbar == NULL) {
1491       progbar = delayed_create_progress_dlg(NULL, "Merging", "files",
1492         FALSE, &stop_flag, &start_time, progbar_val);
1493     }
1494
1495     /* Update the progress bar, but do it only N_PROGBAR_UPDATES times;
1496        when we update it, we have to run the GTK+ main loop to get it
1497        to repaint what's pending, and doing so may involve an "ioctl()"
1498        to see if there's any pending input from an X server, and doing
1499        that for every packet can be costly, especially on a big file. */
1500     if (data_offset >= progbar_nextstep) {
1501         /* Get the sum of the seek positions in all of the files. */
1502         file_pos = 0;
1503         for (i = 0; i < in_file_count; i++)
1504           file_pos += wtap_read_so_far(in_files[i].wth);
1505         progbar_val = (gfloat) file_pos / (gfloat) f_len;
1506         if (progbar_val > 1.0f) {
1507           /* Some file probably grew while we were reading it.
1508              That "shouldn't happen", so we'll just clip the progress
1509              value at 1.0. */
1510           progbar_val = 1.0f;
1511         }
1512         if (progbar != NULL) {
1513           g_snprintf(status_str, sizeof(status_str),
1514                      "%" G_GINT64_MODIFIER "dKB of %" G_GINT64_MODIFIER "dKB",
1515                      file_pos / 1024, f_len / 1024);
1516           update_progress_dlg(progbar, progbar_val, status_str);
1517         }
1518         progbar_nextstep += progbar_quantum;
1519     }
1520
1521     if (stop_flag) {
1522       /* Well, the user decided to abort the merge. */
1523       break;
1524     }
1525
1526     /* If we have WTAP_ENCAP_PER_PACKET and the infiles are of type
1527      * WTAP_FILE_TYPE_SUBTYPE_PCAP, we need to set the interface id
1528      * in the paket header = the interface index we used in the IDBs
1529      * interface description for this file(encapsulation type).
1530      */
1531     if (fake_interface_ids) {
1532       struct wtap_pkthdr *phdr;
1533
1534       phdr = wtap_phdr(in_file->wth);
1535       phdr->interface_id = in_file->interface_id;
1536       phdr->presence_flags = phdr->presence_flags | WTAP_HAS_INTERFACE_ID;
1537     }
1538     if (!wtap_dump(pdh, wtap_phdr(in_file->wth),
1539                    wtap_buf_ptr(in_file->wth), &write_err)) {
1540       got_write_error = TRUE;
1541       break;
1542     }
1543   }
1544
1545   /* We're done merging the files; destroy the progress bar if it was created. */
1546   if (progbar != NULL)
1547     destroy_progress_dlg(progbar);
1548
1549   merge_close_in_files(in_file_count, in_files);
1550   if (!got_read_error && !got_write_error) {
1551     if (!wtap_dump_close(pdh, &write_err))
1552       got_write_error = TRUE;
1553   } else
1554     wtap_dump_close(pdh, &close_err);
1555
1556   if (got_read_error) {
1557     /*
1558      * Find the file on which we got the error, and report the error.
1559      */
1560     for (i = 0; i < in_file_count; i++) {
1561       if (in_files[i].state == GOT_ERROR) {
1562         /* Put up a message box noting that a read failed somewhere along
1563            the line. */
1564         display_basename = g_filename_display_basename(in_files[i].filename);
1565         switch (read_err) {
1566
1567         case WTAP_ERR_UNSUPPORTED_ENCAP:
1568           simple_error_message_box(
1569                      "The capture file %s has a packet with a network type that Wireshark doesn't support.\n(%s)",
1570                      display_basename, err_info);
1571           g_free(err_info);
1572           break;
1573
1574         case WTAP_ERR_CANT_READ:
1575           simple_error_message_box(
1576                      "An attempt to read from the capture file %s failed for"
1577                      " some unknown reason.", display_basename);
1578           break;
1579
1580         case WTAP_ERR_SHORT_READ:
1581           simple_error_message_box(
1582                      "The capture file %s appears to have been cut short"
1583                       " in the middle of a packet.", display_basename);
1584           break;
1585
1586         case WTAP_ERR_BAD_FILE:
1587           simple_error_message_box(
1588                      "The capture file %s appears to be damaged or corrupt.\n(%s)",
1589                      display_basename, err_info);
1590           g_free(err_info);
1591           break;
1592
1593         case WTAP_ERR_DECOMPRESS:
1594           simple_error_message_box(
1595                      "The compressed capture file %s appears to be damaged or corrupt.\n"
1596                      "(%s)", display_basename, err_info);
1597           g_free(err_info);
1598           break;
1599
1600         default:
1601           simple_error_message_box(
1602                      "An error occurred while reading the"
1603                      " capture file %s: %s.",
1604                      display_basename,  wtap_strerror(read_err));
1605           break;
1606         }
1607         g_free(display_basename);
1608       }
1609     }
1610   }
1611
1612   if (got_write_error) {
1613     /* Put up an alert box for the write error. */
1614     if (write_err < 0) {
1615       /* Wiretap error. */
1616       switch (write_err) {
1617
1618       case WTAP_ERR_UNSUPPORTED_ENCAP:
1619         /*
1620          * This is a problem with the particular frame we're writing;
1621          * note that, and give the frame number.
1622          */
1623         display_basename = g_filename_display_basename(in_file->filename);
1624         simple_error_message_box(
1625                       "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.",
1626                       in_file->packet_num, display_basename,
1627                       wtap_file_type_subtype_string(file_type));
1628         g_free(display_basename);
1629         break;
1630
1631       default:
1632         display_basename = g_filename_display_basename(out_filename);
1633         simple_error_message_box(
1634                       "An error occurred while writing to the file \"%s\": %s.",
1635                       out_filename, wtap_strerror(write_err));
1636         g_free(display_basename);
1637         break;
1638       }
1639     } else {
1640       /* OS error. */
1641       write_failure_alert_box(out_filename, write_err);
1642     }
1643   }
1644
1645   if (got_read_error || got_write_error || stop_flag) {
1646     /* Callers aren't expected to treat an error or an explicit abort
1647        differently - we put up error dialogs ourselves, so they don't
1648        have to. */
1649     return CF_ERROR;
1650   } else
1651     return CF_OK;
1652 }
1653
1654 cf_status_t
1655 cf_filter_packets(capture_file *cf, gchar *dftext, gboolean force)
1656 {
1657   const char *filter_new = dftext ? dftext : "";
1658   const char *filter_old = cf->dfilter ? cf->dfilter : "";
1659   dfilter_t  *dfcode;
1660   GTimeVal    start_time;
1661
1662   /* if new filter equals old one, do nothing unless told to do so */
1663   if (!force && strcmp(filter_new, filter_old) == 0) {
1664     return CF_OK;
1665   }
1666
1667   dfcode=NULL;
1668
1669   if (dftext == NULL) {
1670     /* The new filter is an empty filter (i.e., display all packets).
1671      * so leave dfcode==NULL
1672      */
1673   } else {
1674     /*
1675      * We have a filter; make a copy of it (as we'll be saving it),
1676      * and try to compile it.
1677      */
1678     dftext = g_strdup(dftext);
1679     if (!dfilter_compile(dftext, &dfcode)) {
1680       /* The attempt failed; report an error. */
1681       simple_message_box(ESD_TYPE_ERROR, NULL,
1682           "See the help for a description of the display filter syntax.",
1683           "\"%s\" isn't a valid display filter: %s",
1684           dftext, dfilter_error_msg);
1685       g_free(dftext);
1686       return CF_ERROR;
1687     }
1688
1689     /* Was it empty? */
1690     if (dfcode == NULL) {
1691       /* Yes - free the filter text, and set it to null. */
1692       g_free(dftext);
1693       dftext = NULL;
1694     }
1695   }
1696
1697   /* We have a valid filter.  Replace the current filter. */
1698   g_free(cf->dfilter);
1699   cf->dfilter = dftext;
1700   g_get_current_time(&start_time);
1701
1702
1703   /* Now rescan the packet list, applying the new filter, but not
1704      throwing away information constructed on a previous pass. */
1705   if (dftext == NULL) {
1706     rescan_packets(cf, "Resetting", "Filter", FALSE);
1707   } else {
1708     rescan_packets(cf, "Filtering", dftext, FALSE);
1709   }
1710
1711   /* Cleanup and release all dfilter resources */
1712   dfilter_free(dfcode);
1713
1714   return CF_OK;
1715 }
1716
1717 void
1718 cf_reftime_packets(capture_file *cf)
1719 {
1720   ref_time_packets(cf);
1721 }
1722
1723 void
1724 cf_redissect_packets(capture_file *cf)
1725 {
1726   if (cf->state != FILE_CLOSED) {
1727     rescan_packets(cf, "Reprocessing", "all packets", TRUE);
1728   }
1729 }
1730
1731 gboolean
1732 cf_read_frame_r(capture_file *cf, const frame_data *fdata,
1733                 struct wtap_pkthdr *phdr, Buffer *buf)
1734 {
1735   int    err;
1736   gchar *err_info;
1737   gchar *display_basename;
1738
1739 #ifdef WANT_PACKET_EDITOR
1740   /* if fdata->file_off == -1 it means packet was edited, and we must find data inside edited_frames tree */
1741   if (G_UNLIKELY(fdata->file_off == -1)) {
1742     const modified_frame_data *frame = (const modified_frame_data *) g_tree_lookup(cf->edited_frames, GINT_TO_POINTER(fdata->num));
1743
1744     if (!frame) {
1745       simple_error_message_box("fdata->file_off == -1, but can't find modified frame!");
1746       return FALSE;
1747     }
1748
1749     *phdr = frame->phdr;
1750     buffer_assure_space(buf, frame->phdr.caplen);
1751     memcpy(buffer_start_ptr(buf), frame->pd, frame->phdr.caplen);
1752     return TRUE;
1753   }
1754 #endif
1755
1756   if (!wtap_seek_read(cf->wth, fdata->file_off, phdr, buf,
1757                       fdata->cap_len, &err, &err_info)) {
1758     display_basename = g_filename_display_basename(cf->filename);
1759     switch (err) {
1760
1761     case WTAP_ERR_UNSUPPORTED_ENCAP:
1762       simple_error_message_box("The file \"%s\" has a packet with a network type that Wireshark doesn't support.\n(%s)",
1763                  display_basename, err_info);
1764       g_free(err_info);
1765       break;
1766
1767     case WTAP_ERR_BAD_FILE:
1768       simple_error_message_box("An error occurred while reading from the file \"%s\": %s.\n(%s)",
1769                  display_basename, wtap_strerror(err), err_info);
1770       g_free(err_info);
1771       break;
1772
1773     default:
1774       simple_error_message_box(
1775                  "An error occurred while reading from the file \"%s\": %s.",
1776                  display_basename, wtap_strerror(err));
1777       break;
1778     }
1779     g_free(display_basename);
1780     return FALSE;
1781   }
1782   return TRUE;
1783 }
1784
1785 gboolean
1786 cf_read_frame(capture_file *cf, frame_data *fdata)
1787 {
1788   return cf_read_frame_r(cf, fdata, &cf->phdr, &cf->buf);
1789 }
1790
1791 /* Rescan the list of packets, reconstructing the CList.
1792
1793    "action" describes why we're doing this; it's used in the progress
1794    dialog box.
1795
1796    "action_item" describes what we're doing; it's used in the progress
1797    dialog box.
1798
1799    "redissect" is TRUE if we need to make the dissectors reconstruct
1800    any state information they have (because a preference that affects
1801    some dissector has changed, meaning some dissector might construct
1802    its state differently from the way it was constructed the last time). */
1803 static void
1804 rescan_packets(capture_file *cf, const char *action, const char *action_item, gboolean redissect)
1805 {
1806   /* Rescan packets new packet list */
1807   guint32     framenum;
1808   frame_data *fdata;
1809   progdlg_t  *progbar = NULL;
1810   gboolean    stop_flag;
1811   int         count;
1812   frame_data *selected_frame, *preceding_frame, *following_frame, *prev_frame;
1813   int         selected_frame_num, preceding_frame_num, following_frame_num, prev_frame_num;
1814   gboolean    selected_frame_seen;
1815   float       progbar_val;
1816   GTimeVal    start_time;
1817   gchar       status_str[100];
1818   int         progbar_nextstep;
1819   int         progbar_quantum;
1820   epan_dissect_t  edt;
1821   dfilter_t  *dfcode;
1822   column_info *cinfo;
1823   gboolean    create_proto_tree;
1824   guint       tap_flags;
1825   gboolean    add_to_packet_list = FALSE;
1826   gboolean    compiled;
1827   guint32     frames_count;
1828
1829   /* Compile the current display filter.
1830    * We assume this will not fail since cf->dfilter is only set in
1831    * cf_filter IFF the filter was valid.
1832    */
1833   compiled = dfilter_compile(cf->dfilter, &dfcode);
1834   g_assert(!cf->dfilter || (compiled && dfcode));
1835
1836   /* Get the union of the flags for all tap listeners. */
1837   tap_flags = union_of_tap_listener_flags();
1838   cinfo = (tap_flags & TL_REQUIRES_COLUMNS) ? &cf->cinfo : NULL;
1839   create_proto_tree =
1840     (dfcode != NULL || have_filtering_tap_listeners() || (tap_flags & TL_REQUIRES_PROTO_TREE));
1841
1842   reset_tap_listeners();
1843   /* Which frame, if any, is the currently selected frame?
1844      XXX - should the selected frame or the focus frame be the "current"
1845      frame, that frame being the one from which "Find Frame" searches
1846      start? */
1847   selected_frame = cf->current_frame;
1848
1849   /* Mark frame num as not found */
1850   selected_frame_num = -1;
1851
1852   /* Freeze the packet list while we redo it, so we don't get any
1853      screen updates while it happens. */
1854   packet_list_freeze();
1855
1856   if (redissect) {
1857     /* We need to re-initialize all the state information that protocols
1858        keep, because some preference that controls a dissector has changed,
1859        which might cause the state information to be constructed differently
1860        by that dissector. */
1861
1862     /* We might receive new packets while redissecting, and we don't
1863        want to dissect those before their time. */
1864     cf->redissecting = TRUE;
1865
1866     /* 'reset' dissection session */
1867     epan_free(cf->epan);
1868     cf->epan = ws_epan_new(cf);
1869
1870     /* We need to redissect the packets so we have to discard our old
1871      * packet list store. */
1872     packet_list_clear();
1873     add_to_packet_list = TRUE;
1874   }
1875
1876   /* We don't yet know which will be the first and last frames displayed. */
1877   cf->first_displayed = 0;
1878   cf->last_displayed = 0;
1879
1880   /* We currently don't display any packets */
1881   cf->displayed_count = 0;
1882
1883   /* Iterate through the list of frames.  Call a routine for each frame
1884      to check whether it should be displayed and, if so, add it to
1885      the display list. */
1886   cf->ref = NULL;
1887   cf->prev_dis = NULL;
1888   cf->prev_cap = NULL;
1889   cf->cum_bytes = 0;
1890
1891   /* Update the progress bar when it gets to this value. */
1892   progbar_nextstep = 0;
1893   /* When we reach the value that triggers a progress bar update,
1894      bump that value by this amount. */
1895   progbar_quantum = cf->count/N_PROGBAR_UPDATES;
1896   /* Count of packets at which we've looked. */
1897   count = 0;
1898   /* Progress so far. */
1899   progbar_val = 0.0f;
1900
1901   stop_flag = FALSE;
1902   g_get_current_time(&start_time);
1903
1904   /* no previous row yet */
1905   prev_frame_num = -1;
1906   prev_frame = NULL;
1907
1908   preceding_frame_num = -1;
1909   preceding_frame = NULL;
1910   following_frame_num = -1;
1911   following_frame = NULL;
1912
1913   selected_frame_seen = FALSE;
1914
1915   frames_count = cf->count;
1916
1917   epan_dissect_init(&edt, cf->epan, create_proto_tree, FALSE);
1918
1919   for (framenum = 1; framenum <= frames_count; framenum++) {
1920     fdata = frame_data_sequence_find(cf->frames, framenum);
1921
1922     /* Create the progress bar if necessary.
1923        We check on every iteration of the loop, so that it takes no
1924        longer than the standard time to create it (otherwise, for a
1925        large file, we might take considerably longer than that standard
1926        time in order to get to the next progress bar step). */
1927     if (progbar == NULL)
1928       progbar = delayed_create_progress_dlg(cf->window, action, action_item, TRUE,
1929                                             &stop_flag, &start_time,
1930                                             progbar_val);
1931
1932     /* Update the progress bar, but do it only N_PROGBAR_UPDATES times;
1933        when we update it, we have to run the GTK+ main loop to get it
1934        to repaint what's pending, and doing so may involve an "ioctl()"
1935        to see if there's any pending input from an X server, and doing
1936        that for every packet can be costly, especially on a big file. */
1937     if (count >= progbar_nextstep) {
1938       /* let's not divide by zero. I should never be started
1939        * with count == 0, so let's assert that
1940        */
1941       g_assert(cf->count > 0);
1942       progbar_val = (gfloat) count / frames_count;
1943
1944       if (progbar != NULL) {
1945         g_snprintf(status_str, sizeof(status_str),
1946                   "%4u of %u frames", count, frames_count);
1947         update_progress_dlg(progbar, progbar_val, status_str);
1948       }
1949
1950       progbar_nextstep += progbar_quantum;
1951     }
1952
1953     if (stop_flag) {
1954       /* Well, the user decided to abort the filtering.  Just stop.
1955
1956          XXX - go back to the previous filter?  Users probably just
1957          want not to wait for a filtering operation to finish;
1958          unless we cancel by having no filter, reverting to the
1959          previous filter will probably be even more expensive than
1960          continuing the filtering, as it involves going back to the
1961          beginning and filtering, and even with no filter we currently
1962          have to re-generate the entire clist, which is also expensive.
1963
1964          I'm not sure what Network Monitor does, but it doesn't appear
1965          to give you an unfiltered display if you cancel. */
1966       break;
1967     }
1968
1969     count++;
1970
1971     if (redissect) {
1972       /* Since all state for the frame was destroyed, mark the frame
1973        * as not visited, free the GSList referring to the state
1974        * data (the per-frame data itself was freed by
1975        * "init_dissection()"), and null out the GSList pointer. */
1976       frame_data_reset(fdata);
1977       frames_count = cf->count;
1978     }
1979
1980     /* Frame dependencies from the previous dissection/filtering are no longer valid. */
1981     fdata->flags.dependent_of_displayed = 0;
1982
1983     if (!cf_read_frame(cf, fdata))
1984       break; /* error reading the frame */
1985
1986     /* If the previous frame is displayed, and we haven't yet seen the
1987        selected frame, remember that frame - it's the closest one we've
1988        yet seen before the selected frame. */
1989     if (prev_frame_num != -1 && !selected_frame_seen && prev_frame->flags.passed_dfilter) {
1990       preceding_frame_num = prev_frame_num;
1991       preceding_frame = prev_frame;
1992     }
1993
1994     add_packet_to_packet_list(fdata, cf, &edt, dfcode,
1995                                     cinfo, &cf->phdr,
1996                                     buffer_start_ptr(&cf->buf),
1997                                     add_to_packet_list);
1998
1999     /* If this frame is displayed, and this is the first frame we've
2000        seen displayed after the selected frame, remember this frame -
2001        it's the closest one we've yet seen at or after the selected
2002        frame. */
2003     if (fdata->flags.passed_dfilter && selected_frame_seen && following_frame_num == -1) {
2004       following_frame_num = fdata->num;
2005       following_frame = fdata;
2006     }
2007     if (fdata == selected_frame) {
2008       selected_frame_seen = TRUE;
2009       if (fdata->flags.passed_dfilter)
2010           selected_frame_num = fdata->num;
2011     }
2012
2013     /* Remember this frame - it'll be the previous frame
2014        on the next pass through the loop. */
2015     prev_frame_num = fdata->num;
2016     prev_frame = fdata;
2017   }
2018
2019   epan_dissect_cleanup(&edt);
2020
2021   /* We are done redissecting the packet list. */
2022   cf->redissecting = FALSE;
2023
2024   if (redissect) {
2025       frames_count = cf->count;
2026     /* Clear out what remains of the visited flags and per-frame data
2027        pointers.
2028
2029        XXX - that may cause various forms of bogosity when dissecting
2030        these frames, as they won't have been seen by this sequential
2031        pass, but the only alternative I see is to keep scanning them
2032        even though the user requested that the scan stop, and that
2033        would leave the user stuck with an Wireshark grinding on
2034        until it finishes.  Should we just stick them with that? */
2035     for (; framenum <= frames_count; framenum++) {
2036       fdata = frame_data_sequence_find(cf->frames, framenum);
2037       frame_data_reset(fdata);
2038     }
2039   }
2040
2041   /* We're done filtering the packets; destroy the progress bar if it
2042      was created. */
2043   if (progbar != NULL)
2044     destroy_progress_dlg(progbar);
2045
2046   /* Unfreeze the packet list. */
2047   if (!add_to_packet_list)
2048     packet_list_recreate_visible_rows();
2049
2050   /* Compute the time it took to filter the file */
2051   compute_elapsed(cf, &start_time);
2052
2053   packet_list_thaw();
2054
2055   if (selected_frame_num == -1) {
2056     /* The selected frame didn't pass the filter. */
2057     if (selected_frame == NULL) {
2058       /* That's because there *was* no selected frame.  Make the first
2059          displayed frame the current frame. */
2060       selected_frame_num = 0;
2061     } else {
2062       /* Find the nearest displayed frame to the selected frame (whether
2063          it's before or after that frame) and make that the current frame.
2064          If the next and previous displayed frames are equidistant from the
2065          selected frame, choose the next one. */
2066       g_assert(following_frame == NULL ||
2067                following_frame->num >= selected_frame->num);
2068       g_assert(preceding_frame == NULL ||
2069                preceding_frame->num <= selected_frame->num);
2070       if (following_frame == NULL) {
2071         /* No frame after the selected frame passed the filter, so we
2072            have to select the last displayed frame before the selected
2073            frame. */
2074         selected_frame_num = preceding_frame_num;
2075         selected_frame = preceding_frame;
2076       } else if (preceding_frame == NULL) {
2077         /* No frame before the selected frame passed the filter, so we
2078            have to select the first displayed frame after the selected
2079            frame. */
2080         selected_frame_num = following_frame_num;
2081         selected_frame = following_frame;
2082       } else {
2083         /* Frames before and after the selected frame passed the filter, so
2084            we'll select the previous frame */
2085         selected_frame_num = preceding_frame_num;
2086         selected_frame = preceding_frame;
2087       }
2088     }
2089   }
2090
2091   if (selected_frame_num == -1) {
2092     /* There are no frames displayed at all. */
2093     cf_unselect_packet(cf);
2094   } else {
2095     /* Either the frame that was selected passed the filter, or we've
2096        found the nearest displayed frame to that frame.  Select it, make
2097        it the focus row, and make it visible. */
2098     /* Set to invalid to force update of packet list and packet details */
2099     cf->current_row = -1;
2100     if (selected_frame_num == 0) {
2101       packet_list_select_first_row();
2102     }else{
2103       if (!packet_list_select_row_from_data(selected_frame)) {
2104         /* We didn't find a row corresponding to this frame.
2105            This means that the frame isn't being displayed currently,
2106            so we can't select it. */
2107         simple_message_box(ESD_TYPE_INFO, NULL,
2108                            "The capture file is probably not fully dissected.",
2109                            "End of capture exceeded!");
2110       }
2111     }
2112   }
2113
2114   /* Cleanup and release all dfilter resources */
2115   dfilter_free(dfcode);
2116 }
2117
2118
2119 /*
2120  * Scan trough all frame data and recalculate the ref time
2121  * without rereading the file.
2122  * XXX - do we need a progres bar or is this fast enough?
2123  */
2124 static void
2125 ref_time_packets(capture_file *cf)
2126 {
2127   guint32     framenum;
2128   frame_data *fdata;
2129   nstime_t rel_ts;
2130
2131   cf->ref = NULL;
2132   cf->prev_dis = NULL;
2133   cf->cum_bytes = 0;
2134
2135   for (framenum = 1; framenum <= cf->count; framenum++) {
2136     fdata = frame_data_sequence_find(cf->frames, framenum);
2137
2138     /* just add some value here until we know if it is being displayed or not */
2139     fdata->cum_bytes = cf->cum_bytes + fdata->pkt_len;
2140
2141     /*
2142      *Timestamps
2143      */
2144
2145     /* If we don't have the time stamp of the first packet in the
2146      capture, it's because this is the first packet.  Save the time
2147      stamp of this packet as the time stamp of the first packet. */
2148     if (cf->ref == NULL)
2149         cf->ref = fdata;
2150       /* if this frames is marked as a reference time frame, reset
2151         firstsec and firstusec to this frame */
2152     if (fdata->flags.ref_time)
2153         cf->ref = fdata;
2154
2155     /* If we don't have the time stamp of the previous displayed packet,
2156      it's because this is the first displayed packet.  Save the time
2157      stamp of this packet as the time stamp of the previous displayed
2158      packet. */
2159     if (cf->prev_dis == NULL) {
2160         cf->prev_dis = fdata;
2161     }
2162
2163     /* Get the time elapsed between the first packet and this packet. */
2164     fdata->frame_ref_num = (fdata != cf->ref) ? cf->ref->num : 0;
2165     nstime_delta(&rel_ts, &fdata->abs_ts, &cf->ref->abs_ts);
2166
2167     /* If it's greater than the current elapsed time, set the elapsed time
2168      to it (we check for "greater than" so as not to be confused by
2169      time moving backwards). */
2170     if ((gint32)cf->elapsed_time.secs < rel_ts.secs
2171         || ((gint32)cf->elapsed_time.secs == rel_ts.secs && (gint32)cf->elapsed_time.nsecs < rel_ts.nsecs)) {
2172         cf->elapsed_time = rel_ts;
2173     }
2174
2175     /* If this frame is displayed, get the time elapsed between the
2176      previous displayed packet and this packet. */
2177     if ( fdata->flags.passed_dfilter ) {
2178         fdata->prev_dis_num = cf->prev_dis->num;
2179         cf->prev_dis = fdata;
2180     }
2181
2182     /*
2183      * Byte counts
2184      */
2185     if ( (fdata->flags.passed_dfilter) || (fdata->flags.ref_time) ) {
2186         /* This frame either passed the display filter list or is marked as
2187         a time reference frame.  All time reference frames are displayed
2188         even if they dont pass the display filter */
2189         if (fdata->flags.ref_time) {
2190             /* if this was a TIME REF frame we should reset the cum_bytes field */
2191             cf->cum_bytes = fdata->pkt_len;
2192             fdata->cum_bytes = cf->cum_bytes;
2193         } else {
2194             /* increase cum_bytes with this packets length */
2195             cf->cum_bytes += fdata->pkt_len;
2196         }
2197     }
2198   }
2199 }
2200
2201 typedef enum {
2202   PSP_FINISHED,
2203   PSP_STOPPED,
2204   PSP_FAILED
2205 } psp_return_t;
2206
2207 static psp_return_t
2208 process_specified_packets(capture_file *cf, packet_range_t *range,
2209     const char *string1, const char *string2, gboolean terminate_is_stop,
2210     gboolean (*callback)(capture_file *, frame_data *,
2211                          struct wtap_pkthdr *, const guint8 *, void *),
2212     void *callback_args)
2213 {
2214   guint32          framenum;
2215   frame_data      *fdata;
2216   Buffer           buf;
2217   psp_return_t     ret     = PSP_FINISHED;
2218
2219   progdlg_t       *progbar = NULL;
2220   int              progbar_count;
2221   float            progbar_val;
2222   gboolean         progbar_stop_flag;
2223   GTimeVal         progbar_start_time;
2224   gchar            progbar_status_str[100];
2225   int              progbar_nextstep;
2226   int              progbar_quantum;
2227   range_process_e  process_this;
2228   struct wtap_pkthdr phdr;
2229
2230   memset(&phdr, 0, sizeof(struct wtap_pkthdr));
2231   buffer_init(&buf, 1500);
2232
2233   /* Update the progress bar when it gets to this value. */
2234   progbar_nextstep = 0;
2235   /* When we reach the value that triggers a progress bar update,
2236      bump that value by this amount. */
2237   progbar_quantum = cf->count/N_PROGBAR_UPDATES;
2238   /* Count of packets at which we've looked. */
2239   progbar_count = 0;
2240   /* Progress so far. */
2241   progbar_val = 0.0f;
2242
2243   progbar_stop_flag = FALSE;
2244   g_get_current_time(&progbar_start_time);
2245
2246   if (range != NULL)
2247     packet_range_process_init(range);
2248
2249   /* Iterate through all the packets, printing the packets that
2250      were selected by the current display filter.  */
2251   for (framenum = 1; framenum <= cf->count; framenum++) {
2252     fdata = frame_data_sequence_find(cf->frames, framenum);
2253
2254     /* Create the progress bar if necessary.
2255        We check on every iteration of the loop, so that it takes no
2256        longer than the standard time to create it (otherwise, for a
2257        large file, we might take considerably longer than that standard
2258        time in order to get to the next progress bar step). */
2259     if (progbar == NULL)
2260       progbar = delayed_create_progress_dlg(cf->window, string1, string2,
2261                                             terminate_is_stop,
2262                                             &progbar_stop_flag,
2263                                             &progbar_start_time,
2264                                             progbar_val);
2265
2266     /* Update the progress bar, but do it only N_PROGBAR_UPDATES times;
2267        when we update it, we have to run the GTK+ main loop to get it
2268        to repaint what's pending, and doing so may involve an "ioctl()"
2269        to see if there's any pending input from an X server, and doing
2270        that for every packet can be costly, especially on a big file. */
2271     if (progbar_count >= progbar_nextstep) {
2272       /* let's not divide by zero. I should never be started
2273        * with count == 0, so let's assert that
2274        */
2275       g_assert(cf->count > 0);
2276       progbar_val = (gfloat) progbar_count / cf->count;
2277
2278       if (progbar != NULL) {
2279         g_snprintf(progbar_status_str, sizeof(progbar_status_str),
2280                    "%4u of %u packets", progbar_count, cf->count);
2281         update_progress_dlg(progbar, progbar_val, progbar_status_str);
2282       }
2283
2284       progbar_nextstep += progbar_quantum;
2285     }
2286
2287     if (progbar_stop_flag) {
2288       /* Well, the user decided to abort the operation.  Just stop,
2289          and arrange to return PSP_STOPPED to our caller, so they know
2290          it was stopped explicitly. */
2291       ret = PSP_STOPPED;
2292       break;
2293     }
2294
2295     progbar_count++;
2296
2297     if (range != NULL) {
2298       /* do we have to process this packet? */
2299       process_this = packet_range_process_packet(range, fdata);
2300       if (process_this == range_process_next) {
2301         /* this packet uninteresting, continue with next one */
2302         continue;
2303       } else if (process_this == range_processing_finished) {
2304         /* all interesting packets processed, stop the loop */
2305         break;
2306       }
2307     }
2308
2309     /* Get the packet */
2310     if (!cf_read_frame_r(cf, fdata, &phdr, &buf)) {
2311       /* Attempt to get the packet failed. */
2312       ret = PSP_FAILED;
2313       break;
2314     }
2315     /* Process the packet */
2316     if (!callback(cf, fdata, &phdr, buffer_start_ptr(&buf), callback_args)) {
2317       /* Callback failed.  We assume it reported the error appropriately. */
2318       ret = PSP_FAILED;
2319       break;
2320     }
2321   }
2322
2323   /* We're done printing the packets; destroy the progress bar if
2324      it was created. */
2325   if (progbar != NULL)
2326     destroy_progress_dlg(progbar);
2327
2328   buffer_free(&buf);
2329
2330   return ret;
2331 }
2332
2333 typedef struct {
2334   epan_dissect_t edt;
2335   column_info *cinfo;
2336 } retap_callback_args_t;
2337
2338 static gboolean
2339 retap_packet(capture_file *cf _U_, frame_data *fdata,
2340              struct wtap_pkthdr *phdr, const guint8 *pd,
2341              void *argsp)
2342 {
2343   retap_callback_args_t *args = (retap_callback_args_t *)argsp;
2344
2345   epan_dissect_run_with_taps(&args->edt, phdr, frame_tvbuff_new(fdata, pd), fdata, args->cinfo);
2346   epan_dissect_reset(&args->edt);
2347
2348   return TRUE;
2349 }
2350
2351 cf_read_status_t
2352 cf_retap_packets(capture_file *cf)
2353 {
2354   packet_range_t        range;
2355   retap_callback_args_t callback_args;
2356   gboolean              construct_protocol_tree;
2357   gboolean              filtering_tap_listeners;
2358   guint                 tap_flags;
2359   psp_return_t          ret;
2360
2361   /* Do we have any tap listeners with filters? */
2362   filtering_tap_listeners = have_filtering_tap_listeners();
2363
2364   tap_flags = union_of_tap_listener_flags();
2365
2366   /* If any tap listeners have filters, or require the protocol tree,
2367      construct the protocol tree. */
2368   construct_protocol_tree = filtering_tap_listeners ||
2369                             (tap_flags & TL_REQUIRES_PROTO_TREE);
2370
2371   /* If any tap listeners require the columns, construct them. */
2372   callback_args.cinfo = (tap_flags & TL_REQUIRES_COLUMNS) ? &cf->cinfo : NULL;
2373
2374   /* Reset the tap listeners. */
2375   reset_tap_listeners();
2376
2377   epan_dissect_init(&callback_args.edt, cf->epan, construct_protocol_tree, FALSE);
2378
2379   /* Iterate through the list of packets, dissecting all packets and
2380      re-running the taps. */
2381   packet_range_init(&range, cf);
2382   packet_range_process_init(&range);
2383
2384   ret = process_specified_packets(cf, &range, "Recalculating statistics on",
2385                                   "all packets", TRUE, retap_packet,
2386                                   &callback_args);
2387
2388   epan_dissect_cleanup(&callback_args.edt);
2389
2390   switch (ret) {
2391   case PSP_FINISHED:
2392     /* Completed successfully. */
2393     return CF_READ_OK;
2394
2395   case PSP_STOPPED:
2396     /* Well, the user decided to abort the refiltering.
2397        Return CF_READ_ABORTED so our caller knows they did that. */
2398     return CF_READ_ABORTED;
2399
2400   case PSP_FAILED:
2401     /* Error while retapping. */
2402     return CF_READ_ERROR;
2403   }
2404
2405   g_assert_not_reached();
2406   return CF_READ_OK;
2407 }
2408
2409 typedef struct {
2410   print_args_t *print_args;
2411   gboolean      print_header_line;
2412   char         *header_line_buf;
2413   int           header_line_buf_len;
2414   gboolean      print_formfeed;
2415   gboolean      print_separator;
2416   char         *line_buf;
2417   int           line_buf_len;
2418   gint         *col_widths;
2419   int           num_visible_cols;
2420   gint         *visible_cols;
2421   epan_dissect_t edt;
2422 } print_callback_args_t;
2423
2424 static gboolean
2425 print_packet(capture_file *cf, frame_data *fdata,
2426              struct wtap_pkthdr *phdr, const guint8 *pd,
2427              void *argsp)
2428 {
2429   print_callback_args_t *args = (print_callback_args_t *)argsp;
2430   int             i;
2431   char           *cp;
2432   int             line_len;
2433   int             column_len;
2434   int             cp_off;
2435   char            bookmark_name[9+10+1];  /* "__frameNNNNNNNNNN__\0" */
2436   char            bookmark_title[6+10+1]; /* "Frame NNNNNNNNNN__\0"  */
2437
2438   /* Fill in the column information if we're printing the summary
2439      information. */
2440   if (args->print_args->print_summary) {
2441     col_custom_prime_edt(&args->edt, &cf->cinfo);
2442     epan_dissect_run(&args->edt, phdr, frame_tvbuff_new(fdata, pd), fdata, &cf->cinfo);
2443     epan_dissect_fill_in_columns(&args->edt, FALSE, TRUE);
2444   } else
2445     epan_dissect_run(&args->edt, phdr, frame_tvbuff_new(fdata, pd), fdata, NULL);
2446
2447   if (args->print_formfeed) {
2448     if (!new_page(args->print_args->stream))
2449       goto fail;
2450   } else {
2451       if (args->print_separator) {
2452         if (!print_line(args->print_args->stream, 0, ""))
2453           goto fail;
2454       }
2455   }
2456
2457   /*
2458    * We generate bookmarks, if the output format supports them.
2459    * The name is "__frameN__".
2460    */
2461   g_snprintf(bookmark_name, sizeof bookmark_name, "__frame%u__", fdata->num);
2462
2463   if (args->print_args->print_summary) {
2464     if (!args->print_args->print_col_headings)
2465         args->print_header_line = FALSE;
2466     if (args->print_header_line) {
2467       if (!print_line(args->print_args->stream, 0, args->header_line_buf))
2468         goto fail;
2469       args->print_header_line = FALSE;  /* we might not need to print any more */
2470     }
2471     cp = &args->line_buf[0];
2472     line_len = 0;
2473     for (i = 0; i < args->num_visible_cols; i++) {
2474       /* Find the length of the string for this column. */
2475       column_len = (int) strlen(cf->cinfo.col_data[args->visible_cols[i]]);
2476       if (args->col_widths[i] > column_len)
2477          column_len = args->col_widths[i];
2478
2479       /* Make sure there's room in the line buffer for the column; if not,
2480          double its length. */
2481       line_len += column_len + 1;   /* "+1" for space */
2482       if (line_len > args->line_buf_len) {
2483         cp_off = (int) (cp - args->line_buf);
2484         args->line_buf_len = 2 * line_len;
2485         args->line_buf = (char *)g_realloc(args->line_buf, args->line_buf_len + 1);
2486         cp = args->line_buf + cp_off;
2487       }
2488
2489       /* Right-justify the packet number column. */
2490       if (cf->cinfo.col_fmt[args->visible_cols[i]] == COL_NUMBER)
2491         g_snprintf(cp, column_len+1, "%*s", args->col_widths[i], cf->cinfo.col_data[args->visible_cols[i]]);
2492       else
2493         g_snprintf(cp, column_len+1, "%-*s", args->col_widths[i], cf->cinfo.col_data[args->visible_cols[i]]);
2494       cp += column_len;
2495       if (i != args->num_visible_cols - 1)
2496         *cp++ = ' ';
2497     }
2498     *cp = '\0';
2499
2500     /*
2501      * Generate a bookmark, using the summary line as the title.
2502      */
2503     if (!print_bookmark(args->print_args->stream, bookmark_name,
2504                         args->line_buf))
2505       goto fail;
2506
2507     if (!print_line(args->print_args->stream, 0, args->line_buf))
2508       goto fail;
2509   } else {
2510     /*
2511      * Generate a bookmark, using "Frame N" as the title, as we're not
2512      * printing the summary line.
2513      */
2514     g_snprintf(bookmark_title, sizeof bookmark_title, "Frame %u", fdata->num);
2515     if (!print_bookmark(args->print_args->stream, bookmark_name,
2516                         bookmark_title))
2517       goto fail;
2518   } /* if (print_summary) */
2519
2520   if (args->print_args->print_dissections != print_dissections_none) {
2521     if (args->print_args->print_summary) {
2522       /* Separate the summary line from the tree with a blank line. */
2523       if (!print_line(args->print_args->stream, 0, ""))
2524         goto fail;
2525     }
2526
2527     /* Print the information in that tree. */
2528     if (!proto_tree_print(args->print_args, &args->edt, args->print_args->stream))
2529       goto fail;
2530
2531     /* Print a blank line if we print anything after this (aka more than one packet). */
2532     args->print_separator = TRUE;
2533
2534     /* Print a header line if we print any more packet summaries */
2535     if (args->print_args->print_col_headings)
2536         args->print_header_line = TRUE;
2537   }
2538
2539   if (args->print_args->print_hex) {
2540     if (args->print_args->print_summary || (args->print_args->print_dissections != print_dissections_none)) {
2541       if (!print_line(args->print_args->stream, 0, ""))
2542         goto fail;
2543     }
2544     /* Print the full packet data as hex. */
2545     if (!print_hex_data(args->print_args->stream, &args->edt))
2546       goto fail;
2547
2548     /* Print a blank line if we print anything after this (aka more than one packet). */
2549     args->print_separator = TRUE;
2550
2551     /* Print a header line if we print any more packet summaries */
2552     if (args->print_args->print_col_headings)
2553         args->print_header_line = TRUE;
2554   } /* if (args->print_args->print_dissections != print_dissections_none) */
2555
2556   epan_dissect_reset(&args->edt);
2557
2558   /* do we want to have a formfeed between each packet from now on? */
2559   if (args->print_args->print_formfeed) {
2560     args->print_formfeed = TRUE;
2561   }
2562
2563   return TRUE;
2564
2565 fail:
2566   epan_dissect_reset(&args->edt);
2567   return FALSE;
2568 }
2569
2570 cf_print_status_t
2571 cf_print_packets(capture_file *cf, print_args_t *print_args)
2572 {
2573   print_callback_args_t callback_args;
2574   gint          data_width;
2575   char         *cp;
2576   int           i, cp_off, column_len, line_len;
2577   int           num_visible_col = 0, last_visible_col = 0, visible_col_count;
2578   psp_return_t  ret;
2579   GList        *clp;
2580   fmt_data     *cfmt;
2581   gboolean      proto_tree_needed;
2582
2583   callback_args.print_args = print_args;
2584   callback_args.print_header_line = print_args->print_col_headings;
2585   callback_args.header_line_buf = NULL;
2586   callback_args.header_line_buf_len = 256;
2587   callback_args.print_formfeed = FALSE;
2588   callback_args.print_separator = FALSE;
2589   callback_args.line_buf = NULL;
2590   callback_args.line_buf_len = 256;
2591   callback_args.col_widths = NULL;
2592   callback_args.num_visible_cols = 0;
2593   callback_args.visible_cols = NULL;
2594
2595   if (!print_preamble(print_args->stream, cf->filename, wireshark_svnversion)) {
2596     destroy_print_stream(print_args->stream);
2597     return CF_PRINT_WRITE_ERROR;
2598   }
2599
2600   if (print_args->print_summary) {
2601     /* We're printing packet summaries.  Allocate the header line buffer
2602        and get the column widths. */
2603     callback_args.header_line_buf = (char *)g_malloc(callback_args.header_line_buf_len + 1);
2604
2605     /* Find the number of visible columns and the last visible column */
2606     for (i = 0; i < prefs.num_cols; i++) {
2607
2608         clp = g_list_nth(prefs.col_list, i);
2609         if (clp == NULL) /* Sanity check, Invalid column requested */
2610             continue;
2611
2612         cfmt = (fmt_data *) clp->data;
2613         if (cfmt->visible) {
2614             num_visible_col++;
2615             last_visible_col = i;
2616         }
2617     }
2618
2619     /* Find the widths for each of the columns - maximum of the
2620        width of the title and the width of the data - and construct
2621        a buffer with a line containing the column titles. */
2622     callback_args.num_visible_cols = num_visible_col;
2623     callback_args.col_widths = (gint *) g_malloc(sizeof(gint) * num_visible_col);
2624     callback_args.visible_cols = (gint *) g_malloc(sizeof(gint) * num_visible_col);
2625     cp = &callback_args.header_line_buf[0];
2626     line_len = 0;
2627     visible_col_count = 0;
2628     for (i = 0; i < cf->cinfo.num_cols; i++) {
2629
2630       clp = g_list_nth(prefs.col_list, i);
2631       if (clp == NULL) /* Sanity check, Invalid column requested */
2632           continue;
2633
2634       cfmt = (fmt_data *) clp->data;
2635       if (cfmt->visible == FALSE)
2636           continue;
2637
2638       /* Save the order of visible columns */
2639       callback_args.visible_cols[visible_col_count] = i;
2640
2641       /* Don't pad the last column. */
2642       if (i == last_visible_col)
2643         callback_args.col_widths[visible_col_count] = 0;
2644       else {
2645         callback_args.col_widths[visible_col_count] = (gint) strlen(cf->cinfo.col_title[i]);
2646         data_width = get_column_char_width(get_column_format(i));
2647         if (data_width > callback_args.col_widths[visible_col_count])
2648           callback_args.col_widths[visible_col_count] = data_width;
2649       }
2650
2651       /* Find the length of the string for this column. */
2652       column_len = (int) strlen(cf->cinfo.col_title[i]);
2653       if (callback_args.col_widths[i] > column_len)
2654         column_len = callback_args.col_widths[visible_col_count];
2655
2656       /* Make sure there's room in the line buffer for the column; if not,
2657          double its length. */
2658       line_len += column_len + 1;   /* "+1" for space */
2659       if (line_len > callback_args.header_line_buf_len) {
2660         cp_off = (int) (cp - callback_args.header_line_buf);
2661         callback_args.header_line_buf_len = 2 * line_len;
2662         callback_args.header_line_buf = (char *)g_realloc(callback_args.header_line_buf,
2663                                                   callback_args.header_line_buf_len + 1);
2664         cp = callback_args.header_line_buf + cp_off;
2665       }
2666
2667       /* Right-justify the packet number column. */
2668 /*      if (cf->cinfo.col_fmt[i] == COL_NUMBER)
2669         g_snprintf(cp, column_len+1, "%*s", callback_args.col_widths[visible_col_count], cf->cinfo.col_title[i]);
2670       else*/
2671       g_snprintf(cp, column_len+1, "%-*s", callback_args.col_widths[visible_col_count], cf->cinfo.col_title[i]);
2672       cp += column_len;
2673       if (i != cf->cinfo.num_cols - 1)
2674         *cp++ = ' ';
2675
2676       visible_col_count++;
2677     }
2678     *cp = '\0';
2679
2680     /* Now start out the main line buffer with the same length as the
2681        header line buffer. */
2682     callback_args.line_buf_len = callback_args.header_line_buf_len;
2683     callback_args.line_buf = (char *)g_malloc(callback_args.line_buf_len + 1);
2684   } /* if (print_summary) */
2685
2686   /* Create the protocol tree, and make it visible, if we're printing
2687      the dissection or the hex data.
2688      XXX - do we need it if we're just printing the hex data? */
2689   proto_tree_needed =
2690       callback_args.print_args->print_dissections != print_dissections_none ||
2691       callback_args.print_args->print_hex ||
2692       have_custom_cols(&cf->cinfo);
2693   epan_dissect_init(&callback_args.edt, cf->epan, proto_tree_needed, proto_tree_needed);
2694
2695   /* Iterate through the list of packets, printing the packets we were
2696      told to print. */
2697   ret = process_specified_packets(cf, &print_args->range, "Printing",
2698                                   "selected packets", TRUE, print_packet,
2699                                   &callback_args);
2700   epan_dissect_cleanup(&callback_args.edt);
2701   g_free(callback_args.header_line_buf);
2702   g_free(callback_args.line_buf);
2703   g_free(callback_args.col_widths);
2704   g_free(callback_args.visible_cols);
2705
2706   switch (ret) {
2707
2708   case PSP_FINISHED:
2709     /* Completed successfully. */
2710     break;
2711
2712   case PSP_STOPPED:
2713     /* Well, the user decided to abort the printing.
2714
2715        XXX - note that what got generated before they did that
2716        will get printed if we're piping to a print program; we'd
2717        have to write to a file and then hand that to the print
2718        program to make it actually not print anything. */
2719     break;
2720
2721   case PSP_FAILED:
2722     /* Error while printing.
2723
2724        XXX - note that what got generated before they did that
2725        will get printed if we're piping to a print program; we'd
2726        have to write to a file and then hand that to the print
2727        program to make it actually not print anything. */
2728     destroy_print_stream(print_args->stream);
2729     return CF_PRINT_WRITE_ERROR;
2730   }
2731
2732   if (!print_finale(print_args->stream)) {
2733     destroy_print_stream(print_args->stream);
2734     return CF_PRINT_WRITE_ERROR;
2735   }
2736
2737   if (!destroy_print_stream(print_args->stream))
2738     return CF_PRINT_WRITE_ERROR;
2739
2740   return CF_PRINT_OK;
2741 }
2742
2743 typedef struct {
2744   FILE *fh;
2745   epan_dissect_t edt;
2746 } write_packet_callback_args_t;
2747
2748 static gboolean
2749 write_pdml_packet(capture_file *cf _U_, frame_data *fdata,
2750                   struct wtap_pkthdr *phdr, const guint8 *pd,
2751           void *argsp)
2752 {
2753   write_packet_callback_args_t *args = (write_packet_callback_args_t *)argsp;
2754
2755   /* Create the protocol tree, but don't fill in the column information. */
2756   epan_dissect_run(&args->edt, phdr, frame_tvbuff_new(fdata, pd), fdata, NULL);
2757
2758   /* Write out the information in that tree. */
2759   proto_tree_write_pdml(&args->edt, args->fh);
2760
2761   epan_dissect_reset(&args->edt);
2762
2763   return !ferror(args->fh);
2764 }
2765
2766 cf_print_status_t
2767 cf_write_pdml_packets(capture_file *cf, print_args_t *print_args)
2768 {
2769   write_packet_callback_args_t callback_args;
2770   FILE         *fh;
2771   psp_return_t  ret;
2772
2773   fh = ws_fopen(print_args->file, "w");
2774   if (fh == NULL)
2775     return CF_PRINT_OPEN_ERROR; /* attempt to open destination failed */
2776
2777   write_pdml_preamble(fh, cf->filename);
2778   if (ferror(fh)) {
2779     fclose(fh);
2780     return CF_PRINT_WRITE_ERROR;
2781   }
2782
2783   callback_args.fh = fh;
2784   epan_dissect_init(&callback_args.edt, cf->epan, TRUE, TRUE);
2785
2786   /* Iterate through the list of packets, printing the packets we were
2787      told to print. */
2788   ret = process_specified_packets(cf, &print_args->range, "Writing PDML",
2789                                   "selected packets", TRUE,
2790                                   write_pdml_packet, &callback_args);
2791
2792   epan_dissect_cleanup(&callback_args.edt);
2793
2794   switch (ret) {
2795
2796   case PSP_FINISHED:
2797     /* Completed successfully. */
2798     break;
2799
2800   case PSP_STOPPED:
2801     /* Well, the user decided to abort the printing. */
2802     break;
2803
2804   case PSP_FAILED:
2805     /* Error while printing. */
2806     fclose(fh);
2807     return CF_PRINT_WRITE_ERROR;
2808   }
2809
2810   write_pdml_finale(fh);
2811   if (ferror(fh)) {
2812     fclose(fh);
2813     return CF_PRINT_WRITE_ERROR;
2814   }
2815
2816   /* XXX - check for an error */
2817   fclose(fh);
2818
2819   return CF_PRINT_OK;
2820 }
2821
2822 static gboolean
2823 write_psml_packet(capture_file *cf, frame_data *fdata,
2824                   struct wtap_pkthdr *phdr, const guint8 *pd,
2825           void *argsp)
2826 {
2827   write_packet_callback_args_t *args = (write_packet_callback_args_t *)argsp;
2828
2829   col_custom_prime_edt(&args->edt, &cf->cinfo);
2830   epan_dissect_run(&args->edt, phdr, frame_tvbuff_new(fdata, pd), fdata, &cf->cinfo);
2831   epan_dissect_fill_in_columns(&args->edt, FALSE, TRUE);
2832
2833   /* Write out the information in that tree. */
2834   proto_tree_write_psml(&args->edt, args->fh);
2835
2836   epan_dissect_reset(&args->edt);
2837
2838   return !ferror(args->fh);
2839 }
2840
2841 cf_print_status_t
2842 cf_write_psml_packets(capture_file *cf, print_args_t *print_args)
2843 {
2844   write_packet_callback_args_t callback_args;
2845   FILE         *fh;
2846   psp_return_t  ret;
2847
2848   gboolean proto_tree_needed;
2849
2850   fh = ws_fopen(print_args->file, "w");
2851   if (fh == NULL)
2852     return CF_PRINT_OPEN_ERROR; /* attempt to open destination failed */
2853
2854   write_psml_preamble(fh);
2855   if (ferror(fh)) {
2856     fclose(fh);
2857     return CF_PRINT_WRITE_ERROR;
2858   }
2859
2860   callback_args.fh = fh;
2861
2862   /* Fill in the column information, only create the protocol tree
2863      if having custom columns. */
2864   proto_tree_needed = have_custom_cols(&cf->cinfo);
2865   epan_dissect_init(&callback_args.edt, cf->epan, proto_tree_needed, proto_tree_needed);
2866
2867   /* Iterate through the list of packets, printing the packets we were
2868      told to print. */
2869   ret = process_specified_packets(cf, &print_args->range, "Writing PSML",
2870                                   "selected packets", TRUE,
2871                                   write_psml_packet, &callback_args);
2872
2873   epan_dissect_cleanup(&callback_args.edt);
2874
2875   switch (ret) {
2876
2877   case PSP_FINISHED:
2878     /* Completed successfully. */
2879     break;
2880
2881   case PSP_STOPPED:
2882     /* Well, the user decided to abort the printing. */
2883     break;
2884
2885   case PSP_FAILED:
2886     /* Error while printing. */
2887     fclose(fh);
2888     return CF_PRINT_WRITE_ERROR;
2889   }
2890
2891   write_psml_finale(fh);
2892   if (ferror(fh)) {
2893     fclose(fh);
2894     return CF_PRINT_WRITE_ERROR;
2895   }
2896
2897   /* XXX - check for an error */
2898   fclose(fh);
2899
2900   return CF_PRINT_OK;
2901 }
2902
2903 static gboolean
2904 write_csv_packet(capture_file *cf, frame_data *fdata,
2905                  struct wtap_pkthdr *phdr, const guint8 *pd,
2906                  void *argsp)
2907 {
2908   write_packet_callback_args_t *args = (write_packet_callback_args_t *)argsp;
2909
2910   /* Fill in the column information */
2911   col_custom_prime_edt(&args->edt, &cf->cinfo);
2912   epan_dissect_run(&args->edt, phdr, frame_tvbuff_new(fdata, pd), fdata, &cf->cinfo);
2913   epan_dissect_fill_in_columns(&args->edt, FALSE, TRUE);
2914
2915   /* Write out the information in that tree. */
2916   proto_tree_write_csv(&args->edt, args->fh);
2917
2918   epan_dissect_reset(&args->edt);
2919
2920   return !ferror(args->fh);
2921 }
2922
2923 cf_print_status_t
2924 cf_write_csv_packets(capture_file *cf, print_args_t *print_args)
2925 {
2926   write_packet_callback_args_t callback_args;
2927   gboolean        proto_tree_needed;
2928   FILE         *fh;
2929   psp_return_t  ret;
2930
2931   fh = ws_fopen(print_args->file, "w");
2932   if (fh == NULL)
2933     return CF_PRINT_OPEN_ERROR; /* attempt to open destination failed */
2934
2935   write_csv_preamble(fh);
2936   if (ferror(fh)) {
2937     fclose(fh);
2938     return CF_PRINT_WRITE_ERROR;
2939   }
2940
2941   callback_args.fh = fh;
2942
2943   /* only create the protocol tree if having custom columns. */
2944   proto_tree_needed = have_custom_cols(&cf->cinfo);
2945   epan_dissect_init(&callback_args.edt, cf->epan, proto_tree_needed, proto_tree_needed);
2946
2947   /* Iterate through the list of packets, printing the packets we were
2948      told to print. */
2949   ret = process_specified_packets(cf, &print_args->range, "Writing CSV",
2950                                   "selected packets", TRUE,
2951                                   write_csv_packet, fh);
2952
2953   epan_dissect_cleanup(&callback_args.edt);
2954
2955   switch (ret) {
2956
2957   case PSP_FINISHED:
2958     /* Completed successfully. */
2959     break;
2960
2961   case PSP_STOPPED:
2962     /* Well, the user decided to abort the printing. */
2963     break;
2964
2965   case PSP_FAILED:
2966     /* Error while printing. */
2967     fclose(fh);
2968     return CF_PRINT_WRITE_ERROR;
2969   }
2970
2971   write_csv_finale(fh);
2972   if (ferror(fh)) {
2973     fclose(fh);
2974     return CF_PRINT_WRITE_ERROR;
2975   }
2976
2977   /* XXX - check for an error */
2978   fclose(fh);
2979
2980   return CF_PRINT_OK;
2981 }
2982
2983 static gboolean
2984 write_carrays_packet(capture_file *cf _U_, frame_data *fdata,
2985              struct wtap_pkthdr *phdr,
2986              const guint8 *pd, void *argsp)
2987 {
2988   write_packet_callback_args_t *args = (write_packet_callback_args_t *)argsp;
2989
2990   epan_dissect_run(&args->edt, phdr, frame_tvbuff_new(fdata, pd), fdata, NULL);
2991   proto_tree_write_carrays(fdata->num, args->fh, &args->edt);
2992   epan_dissect_reset(&args->edt);
2993
2994   return !ferror(args->fh);
2995 }
2996
2997 cf_print_status_t
2998 cf_write_carrays_packets(capture_file *cf, print_args_t *print_args)
2999 {
3000   write_packet_callback_args_t callback_args;
3001   FILE         *fh;
3002   psp_return_t  ret;
3003
3004   fh = ws_fopen(print_args->file, "w");
3005
3006   if (fh == NULL)
3007     return CF_PRINT_OPEN_ERROR; /* attempt to open destination failed */
3008
3009   write_carrays_preamble(fh);
3010
3011   if (ferror(fh)) {
3012     fclose(fh);
3013     return CF_PRINT_WRITE_ERROR;
3014   }
3015
3016   callback_args.fh = fh;
3017   epan_dissect_init(&callback_args.edt, cf->epan, TRUE, TRUE);
3018
3019   /* Iterate through the list of packets, printing the packets we were
3020      told to print. */
3021   ret = process_specified_packets(cf, &print_args->range,
3022                   "Writing C Arrays",
3023                   "selected packets", TRUE,
3024                                   write_carrays_packet, &callback_args);
3025
3026   epan_dissect_cleanup(&callback_args.edt);
3027
3028   switch (ret) {
3029   case PSP_FINISHED:
3030     /* Completed successfully. */
3031     break;
3032   case PSP_STOPPED:
3033     /* Well, the user decided to abort the printing. */
3034     break;
3035   case PSP_FAILED:
3036     /* Error while printing. */
3037     fclose(fh);
3038     return CF_PRINT_WRITE_ERROR;
3039   }
3040
3041   write_carrays_finale(fh);
3042
3043   if (ferror(fh)) {
3044     fclose(fh);
3045     return CF_PRINT_WRITE_ERROR;
3046   }
3047
3048   fclose(fh);
3049   return CF_PRINT_OK;
3050 }
3051
3052 gboolean
3053 cf_find_packet_protocol_tree(capture_file *cf, const char *string,
3054                              search_direction dir)
3055 {
3056   match_data mdata;
3057
3058   mdata.string = string;
3059   mdata.string_len = strlen(string);
3060   return find_packet(cf, match_protocol_tree, &mdata, dir);
3061 }
3062
3063 gboolean
3064 cf_find_string_protocol_tree(capture_file *cf, proto_tree *tree,  match_data *mdata)
3065 {
3066   mdata->frame_matched = FALSE;
3067   mdata->string = convert_string_case(cf->sfilter, cf->case_type);
3068   mdata->string_len = strlen(mdata->string);
3069   mdata->cf = cf;
3070   /* Iterate through all the nodes looking for matching text */
3071   proto_tree_children_foreach(tree, match_subtree_text, mdata);
3072   return mdata->frame_matched ? MR_MATCHED : MR_NOTMATCHED;
3073 }
3074
3075 static match_result
3076 match_protocol_tree(capture_file *cf, frame_data *fdata, void *criterion)
3077 {
3078   match_data     *mdata = (match_data *)criterion;
3079   epan_dissect_t  edt;
3080
3081   /* Load the frame's data. */
3082   if (!cf_read_frame(cf, fdata)) {
3083     /* Attempt to get the packet failed. */
3084     return MR_ERROR;
3085   }
3086
3087   /* Construct the protocol tree, including the displayed text */
3088   epan_dissect_init(&edt, cf->epan, TRUE, TRUE);
3089   /* We don't need the column information */
3090   epan_dissect_run(&edt, &cf->phdr, frame_tvbuff_new_buffer(fdata, &cf->buf), fdata, NULL);
3091
3092   /* Iterate through all the nodes, seeing if they have text that matches. */
3093   mdata->cf = cf;
3094   mdata->frame_matched = FALSE;
3095   proto_tree_children_foreach(edt.tree, match_subtree_text, mdata);
3096   epan_dissect_cleanup(&edt);
3097   return mdata->frame_matched ? MR_MATCHED : MR_NOTMATCHED;
3098 }
3099
3100 static void
3101 match_subtree_text(proto_node *node, gpointer data)
3102 {
3103   match_data   *mdata      = (match_data *) data;
3104   const gchar  *string     = mdata->string;
3105   size_t        string_len = mdata->string_len;
3106   capture_file *cf         = mdata->cf;
3107   field_info   *fi         = PNODE_FINFO(node);
3108   gchar         label_str[ITEM_LABEL_LENGTH];
3109   gchar        *label_ptr;
3110   size_t        label_len;
3111   guint32       i;
3112   guint8        c_char;
3113   size_t        c_match    = 0;
3114
3115   /* dissection with an invisible proto tree? */
3116   g_assert(fi);
3117
3118   if (mdata->frame_matched) {
3119     /* We already had a match; don't bother doing any more work. */
3120     return;
3121   }
3122
3123   /* Don't match invisible entries. */
3124   if (PROTO_ITEM_IS_HIDDEN(node))
3125     return;
3126
3127   /* was a free format label produced? */
3128   if (fi->rep) {
3129     label_ptr = fi->rep->representation;
3130   } else {
3131     /* no, make a generic label */
3132     label_ptr = label_str;
3133     proto_item_fill_label(fi, label_str);
3134   }
3135
3136   /* Does that label match? */
3137   label_len = strlen(label_ptr);
3138   for (i = 0; i < label_len; i++) {
3139     c_char = label_ptr[i];
3140     if (cf->case_type)
3141       c_char = toupper(c_char);
3142     if (c_char == string[c_match]) {
3143       c_match++;
3144       if (c_match == string_len) {
3145         /* No need to look further; we have a match */
3146         mdata->frame_matched = TRUE;
3147         mdata->finfo = fi;
3148         return;
3149       }
3150     } else
3151       c_match = 0;
3152   }
3153
3154   /* Recurse into the subtree, if it exists */
3155   if (node->first_child != NULL)
3156     proto_tree_children_foreach(node, match_subtree_text, mdata);
3157 }
3158
3159 gboolean
3160 cf_find_packet_summary_line(capture_file *cf, const char *string,
3161                             search_direction dir)
3162 {
3163   match_data mdata;
3164
3165   mdata.string = string;
3166   mdata.string_len = strlen(string);
3167   return find_packet(cf, match_summary_line, &mdata, dir);
3168 }
3169
3170 static match_result
3171 match_summary_line(capture_file *cf, frame_data *fdata, void *criterion)
3172 {
3173   match_data     *mdata      = (match_data *)criterion;
3174   const gchar    *string     = mdata->string;
3175   size_t          string_len = mdata->string_len;
3176   epan_dissect_t  edt;
3177   const char     *info_column;
3178   size_t          info_column_len;
3179   match_result    result     = MR_NOTMATCHED;
3180   gint            colx;
3181   guint32         i;
3182   guint8          c_char;
3183   size_t          c_match    = 0;
3184
3185   /* Load the frame's data. */
3186   if (!cf_read_frame(cf, fdata)) {
3187     /* Attempt to get the packet failed. */
3188     return MR_ERROR;
3189   }
3190
3191   /* Don't bother constructing the protocol tree */
3192   epan_dissect_init(&edt, cf->epan, FALSE, FALSE);
3193   /* Get the column information */
3194   epan_dissect_run(&edt, &cf->phdr, frame_tvbuff_new_buffer(fdata, &cf->buf), fdata,
3195                    &cf->cinfo);
3196
3197   /* Find the Info column */
3198   for (colx = 0; colx < cf->cinfo.num_cols; colx++) {
3199     if (cf->cinfo.fmt_matx[colx][COL_INFO]) {
3200       /* Found it.  See if we match. */
3201       info_column = edt.pi.cinfo->col_data[colx];
3202       info_column_len = strlen(info_column);
3203       for (i = 0; i < info_column_len; i++) {
3204         c_char = info_column[i];
3205         if (cf->case_type)
3206           c_char = toupper(c_char);
3207         if (c_char == string[c_match]) {
3208           c_match++;
3209           if (c_match == string_len) {
3210             result = MR_MATCHED;
3211             break;
3212           }
3213         } else
3214           c_match = 0;
3215       }
3216       break;
3217     }
3218   }
3219   epan_dissect_cleanup(&edt);
3220   return result;
3221 }
3222
3223 typedef struct {
3224     const guint8 *data;
3225     size_t        data_len;
3226 } cbs_t;    /* "Counted byte string" */
3227
3228
3229 /*
3230  * The current match_* routines only support ASCII case insensitivity and don't
3231  * convert UTF-8 inputs to UTF-16 for matching.
3232  *
3233  * We could modify them to use the GLib Unicode routines or the International
3234  * Components for Unicode library but it's not apparent that we could do so
3235  * without consuming a lot more CPU and memory or that searching would be
3236  * significantly better.
3237  */
3238
3239 gboolean
3240 cf_find_packet_data(capture_file *cf, const guint8 *string, size_t string_size,
3241                     search_direction dir)
3242 {
3243   cbs_t info;
3244
3245   info.data = string;
3246   info.data_len = string_size;
3247
3248   /* String or hex search? */
3249   if (cf->string) {
3250     /* String search - what type of string? */
3251     switch (cf->scs_type) {
3252
3253     case SCS_NARROW_AND_WIDE:
3254       return find_packet(cf, match_narrow_and_wide, &info, dir);
3255
3256     case SCS_NARROW:
3257       return find_packet(cf, match_narrow, &info, dir);
3258
3259     case SCS_WIDE:
3260       return find_packet(cf, match_wide, &info, dir);
3261
3262     default:
3263       g_assert_not_reached();
3264       return FALSE;
3265     }
3266   } else
3267     return find_packet(cf, match_binary, &info, dir);
3268 }
3269
3270 static match_result
3271 match_narrow_and_wide(capture_file *cf, frame_data *fdata, void *criterion)
3272 {
3273   cbs_t        *info       = (cbs_t *)criterion;
3274   const guint8 *ascii_text = info->data;
3275   size_t        textlen    = info->data_len;
3276   match_result  result;
3277   guint32       buf_len;
3278   guint8       *pd;
3279   guint32       i;
3280   guint8        c_char;
3281   size_t        c_match    = 0;
3282
3283   /* Load the frame's data. */
3284   if (!cf_read_frame(cf, fdata)) {
3285     /* Attempt to get the packet failed. */
3286     return MR_ERROR;
3287   }
3288
3289   result = MR_NOTMATCHED;
3290   buf_len = fdata->cap_len;
3291   pd = buffer_start_ptr(&cf->buf);
3292   i = 0;
3293   while (i < buf_len) {
3294     c_char = pd[i];
3295     if (cf->case_type)
3296       c_char = toupper(c_char);
3297     if (c_char != '\0') {
3298       if (c_char == ascii_text[c_match]) {
3299         c_match += 1;
3300         if (c_match == textlen) {
3301           result = MR_MATCHED;
3302           cf->search_pos = i; /* Save the position of the last character
3303                                  for highlighting the field. */
3304           break;
3305         }
3306       }
3307       else {
3308         g_assert(i>=c_match);
3309         i -= (guint32)c_match;
3310         c_match = 0;
3311       }
3312     }
3313     i += 1;
3314   }
3315   return result;
3316 }
3317
3318 static match_result
3319 match_narrow(capture_file *cf, frame_data *fdata, void *criterion)
3320 {
3321   guint8       *pd;
3322   cbs_t        *info       = (cbs_t *)criterion;
3323   const guint8 *ascii_text = info->data;
3324   size_t        textlen    = info->data_len;
3325   match_result  result;
3326   guint32       buf_len;
3327   guint32       i;
3328   guint8        c_char;
3329   size_t        c_match    = 0;
3330
3331   /* Load the frame's data. */
3332   if (!cf_read_frame(cf, fdata)) {
3333     /* Attempt to get the packet failed. */
3334     return MR_ERROR;
3335   }
3336
3337   result = MR_NOTMATCHED;
3338   buf_len = fdata->cap_len;
3339   pd = buffer_start_ptr(&cf->buf);
3340   i = 0;
3341   while (i < buf_len) {
3342     c_char = pd[i];
3343     if (cf->case_type)
3344       c_char = toupper(c_char);
3345     if (c_char == ascii_text[c_match]) {
3346       c_match += 1;
3347       if (c_match == textlen) {
3348         result = MR_MATCHED;
3349         cf->search_pos = i; /* Save the position of the last character
3350                                for highlighting the field. */
3351         break;
3352       }
3353     }
3354     else {
3355       g_assert(i>=c_match);
3356       i -= (guint32)c_match;
3357       c_match = 0;
3358     }
3359     i += 1;
3360   }
3361
3362   return result;
3363 }
3364
3365 static match_result
3366 match_wide(capture_file *cf, frame_data *fdata, void *criterion)
3367 {
3368   cbs_t        *info       = (cbs_t *)criterion;
3369   const guint8 *ascii_text = info->data;
3370   size_t        textlen    = info->data_len;
3371   match_result  result;
3372   guint32       buf_len;
3373   guint8       *pd;
3374   guint32       i;
3375   guint8        c_char;
3376   size_t        c_match    = 0;
3377
3378   /* Load the frame's data. */
3379   if (!cf_read_frame(cf, fdata)) {
3380     /* Attempt to get the packet failed. */
3381     return MR_ERROR;
3382   }
3383
3384   result = MR_NOTMATCHED;
3385   buf_len = fdata->cap_len;
3386   pd = buffer_start_ptr(&cf->buf);
3387   i = 0;
3388   while (i < buf_len) {
3389     c_char = pd[i];
3390     if (cf->case_type)
3391       c_char = toupper(c_char);
3392     if (c_char == ascii_text[c_match]) {
3393       c_match += 1;
3394       if (c_match == textlen) {
3395         result = MR_MATCHED;
3396         cf->search_pos = i; /* Save the position of the last character
3397                                for highlighting the field. */
3398         break;
3399       }
3400       i += 1;
3401     }
3402     else {
3403       g_assert(i>=(c_match*2));
3404       i -= (guint32)c_match*2;
3405       c_match = 0;
3406     }
3407     i += 1;
3408   }
3409   return result;
3410 }
3411
3412 static match_result
3413 match_binary(capture_file *cf, frame_data *fdata, void *criterion)
3414 {
3415   cbs_t        *info        = (cbs_t *)criterion;
3416   const guint8 *binary_data = info->data;
3417   size_t        datalen     = info->data_len;
3418   match_result  result;
3419   guint32       buf_len;
3420   guint8       *pd;
3421   guint32       i;
3422   size_t        c_match     = 0;
3423
3424   /* Load the frame's data. */
3425   if (!cf_read_frame(cf, fdata)) {
3426     /* Attempt to get the packet failed. */
3427     return MR_ERROR;
3428   }
3429
3430   result = MR_NOTMATCHED;
3431   buf_len = fdata->cap_len;
3432   pd = buffer_start_ptr(&cf->buf);
3433   i = 0;
3434   while (i < buf_len) {
3435     if (pd[i] == binary_data[c_match]) {
3436       c_match += 1;
3437       if (c_match == datalen) {
3438         result = MR_MATCHED;
3439         cf->search_pos = i; /* Save the position of the last character
3440                                for highlighting the field. */
3441         break;
3442       }
3443     }
3444     else {
3445       g_assert(i>=c_match);
3446       i -= (guint32)c_match;
3447       c_match = 0;
3448     }
3449     i += 1;
3450   }
3451   return result;
3452 }
3453
3454 gboolean
3455 cf_find_packet_dfilter(capture_file *cf, dfilter_t *sfcode,
3456                        search_direction dir)
3457 {
3458   return find_packet(cf, match_dfilter, sfcode, dir);
3459 }
3460
3461 gboolean
3462 cf_find_packet_dfilter_string(capture_file *cf, const char *filter,
3463                               search_direction dir)
3464 {
3465   dfilter_t *sfcode;
3466   gboolean   result;
3467
3468   if (!dfilter_compile(filter, &sfcode)) {
3469      /*
3470       * XXX - this shouldn't happen, as the filter string is machine
3471       * generated
3472       */
3473     return FALSE;
3474   }
3475   if (sfcode == NULL) {
3476     /*
3477      * XXX - this shouldn't happen, as the filter string is machine
3478      * generated.
3479      */
3480     return FALSE;
3481   }
3482   result = find_packet(cf, match_dfilter, sfcode, dir);
3483   dfilter_free(sfcode);
3484   return result;
3485 }
3486
3487 static match_result
3488 match_dfilter(capture_file *cf, frame_data *fdata, void *criterion)
3489 {
3490   dfilter_t      *sfcode = (dfilter_t *)criterion;
3491   epan_dissect_t  edt;
3492   match_result    result;
3493
3494   /* Load the frame's data. */
3495   if (!cf_read_frame(cf, fdata)) {
3496     /* Attempt to get the packet failed. */
3497     return MR_ERROR;
3498   }
3499
3500   epan_dissect_init(&edt, cf->epan, TRUE, FALSE);
3501   epan_dissect_prime_dfilter(&edt, sfcode);
3502   epan_dissect_run(&edt, &cf->phdr, frame_tvbuff_new_buffer(fdata, &cf->buf), fdata, NULL);
3503   result = dfilter_apply_edt(sfcode, &edt) ? MR_MATCHED : MR_NOTMATCHED;
3504   epan_dissect_cleanup(&edt);
3505   return result;
3506 }
3507
3508 gboolean
3509 cf_find_packet_marked(capture_file *cf, search_direction dir)
3510 {
3511   return find_packet(cf, match_marked, NULL, dir);
3512 }
3513
3514 static match_result
3515 match_marked(capture_file *cf _U_, frame_data *fdata, void *criterion _U_)
3516 {
3517   return fdata->flags.marked ? MR_MATCHED : MR_NOTMATCHED;
3518 }
3519
3520 gboolean
3521 cf_find_packet_time_reference(capture_file *cf, search_direction dir)
3522 {
3523   return find_packet(cf, match_time_reference, NULL, dir);
3524 }
3525
3526 static match_result
3527 match_time_reference(capture_file *cf _U_, frame_data *fdata, void *criterion _U_)
3528 {
3529   return fdata->flags.ref_time ? MR_MATCHED : MR_NOTMATCHED;
3530 }
3531
3532 static gboolean
3533 find_packet(capture_file *cf,
3534             match_result (*match_function)(capture_file *, frame_data *, void *),
3535             void *criterion, search_direction dir)
3536 {
3537   frame_data  *start_fd;
3538   guint32      framenum;
3539   frame_data  *fdata;
3540   frame_data  *new_fd = NULL;
3541   progdlg_t   *progbar = NULL;
3542   gboolean     stop_flag;
3543   int          count;
3544   gboolean     found;
3545   float        progbar_val;
3546   GTimeVal     start_time;
3547   gchar        status_str[100];
3548   int          progbar_nextstep;
3549   int          progbar_quantum;
3550   const char  *title;
3551   match_result result;
3552
3553   start_fd = cf->current_frame;
3554   if (start_fd != NULL)  {
3555     /* Iterate through the list of packets, starting at the packet we've
3556        picked, calling a routine to run the filter on the packet, see if
3557        it matches, and stop if so.  */
3558     count = 0;
3559     framenum = start_fd->num;
3560
3561     /* Update the progress bar when it gets to this value. */
3562     progbar_nextstep = 0;
3563     /* When we reach the value that triggers a progress bar update,
3564        bump that value by this amount. */
3565     progbar_quantum = cf->count/N_PROGBAR_UPDATES;
3566     /* Progress so far. */
3567     progbar_val = 0.0f;
3568
3569     stop_flag = FALSE;
3570     g_get_current_time(&start_time);
3571
3572     title = cf->sfilter?cf->sfilter:"";
3573     for (;;) {
3574       /* Create the progress bar if necessary.
3575          We check on every iteration of the loop, so that it takes no
3576          longer than the standard time to create it (otherwise, for a
3577          large file, we might take considerably longer than that standard
3578          time in order to get to the next progress bar step). */
3579       if (progbar == NULL)
3580          progbar = delayed_create_progress_dlg(cf->window, "Searching", title,
3581            FALSE, &stop_flag, &start_time, progbar_val);
3582
3583       /* Update the progress bar, but do it only N_PROGBAR_UPDATES times;
3584          when we update it, we have to run the GTK+ main loop to get it
3585          to repaint what's pending, and doing so may involve an "ioctl()"
3586          to see if there's any pending input from an X server, and doing
3587          that for every packet can be costly, especially on a big file. */
3588       if (count >= progbar_nextstep) {
3589         /* let's not divide by zero. I should never be started
3590          * with count == 0, so let's assert that
3591          */
3592         g_assert(cf->count > 0);
3593
3594         progbar_val = (gfloat) count / cf->count;
3595
3596         if (progbar != NULL) {
3597           g_snprintf(status_str, sizeof(status_str),
3598                      "%4u of %u packets", count, cf->count);
3599           update_progress_dlg(progbar, progbar_val, status_str);
3600         }
3601
3602         progbar_nextstep += progbar_quantum;
3603       }
3604
3605       if (stop_flag) {
3606         /* Well, the user decided to abort the search.  Go back to the
3607            frame where we started. */
3608         new_fd = start_fd;
3609         break;
3610       }
3611
3612       /* Go past the current frame. */
3613       if (dir == SD_BACKWARD) {
3614         /* Go on to the previous frame. */
3615         if (framenum == 1) {
3616           /*
3617            * XXX - other apps have a bit more of a detailed message
3618            * for this, and instead of offering "OK" and "Cancel",
3619            * they offer things such as "Continue" and "Cancel";
3620            * we need an API for popping up alert boxes with
3621            * {Verb} and "Cancel".
3622            */
3623
3624           if (prefs.gui_find_wrap)
3625           {
3626               statusbar_push_temporary_msg("Search reached the beginning. Continuing at end.");
3627               framenum = cf->count;     /* wrap around */
3628           }
3629           else
3630           {
3631               statusbar_push_temporary_msg("Search reached the beginning.");
3632               framenum = start_fd->num; /* stay on previous packet */
3633           }
3634         } else
3635           framenum--;
3636       } else {
3637         /* Go on to the next frame. */
3638         if (framenum == cf->count) {
3639           if (prefs.gui_find_wrap)
3640           {
3641               statusbar_push_temporary_msg("Search reached the end. Continuing at beginning.");
3642               framenum = 1;             /* wrap around */
3643           }
3644           else
3645           {
3646               statusbar_push_temporary_msg("Search reached the end.");
3647               framenum = start_fd->num; /* stay on previous packet */
3648           }
3649         } else
3650           framenum++;
3651       }
3652       fdata = frame_data_sequence_find(cf->frames, framenum);
3653
3654       count++;
3655
3656       /* Is this packet in the display? */
3657       if (fdata->flags.passed_dfilter) {
3658         /* Yes.  Does it match the search criterion? */
3659         result = (*match_function)(cf, fdata, criterion);
3660         if (result == MR_ERROR) {
3661           /* Error; our caller has reported the error.  Go back to the frame
3662              where we started. */
3663           new_fd = start_fd;
3664           break;
3665         } else if (result == MR_MATCHED) {
3666           /* Yes.  Go to the new frame. */
3667           new_fd = fdata;
3668           break;
3669         }
3670       }
3671
3672       if (fdata == start_fd) {
3673         /* We're back to the frame we were on originally, and that frame
3674            doesn't match the search filter.  The search failed. */
3675         break;
3676       }
3677     }
3678
3679     /* We're done scanning the packets; destroy the progress bar if it
3680        was created. */
3681     if (progbar != NULL)
3682       destroy_progress_dlg(progbar);
3683   }
3684
3685   if (new_fd != NULL) {
3686     /* Find and select */
3687     cf->search_in_progress = TRUE;
3688     found = packet_list_select_row_from_data(new_fd);
3689     cf->search_in_progress = FALSE;
3690     cf->search_pos = 0; /* Reset the position */
3691     if (!found) {
3692       /* We didn't find a row corresponding to this frame.
3693          This means that the frame isn't being displayed currently,
3694          so we can't select it. */
3695       simple_message_box(ESD_TYPE_INFO, NULL,
3696                          "The capture file is probably not fully dissected.",
3697                          "End of capture exceeded!");
3698       return FALSE;
3699     }
3700     return TRUE;    /* success */
3701   } else
3702     return FALSE;   /* failure */
3703 }
3704
3705 gboolean
3706 cf_goto_frame(capture_file *cf, guint fnumber)
3707 {
3708   frame_data *fdata;
3709
3710   fdata = frame_data_sequence_find(cf->frames, fnumber);
3711
3712   if (fdata == NULL) {
3713     /* we didn't find a packet with that packet number */
3714     statusbar_push_temporary_msg("There is no packet number %u.", fnumber);
3715     return FALSE;   /* we failed to go to that packet */
3716   }
3717   if (!fdata->flags.passed_dfilter) {
3718     /* that packet currently isn't displayed */
3719     /* XXX - add it to the set of displayed packets? */
3720     statusbar_push_temporary_msg("Packet number %u isn't displayed.", fnumber);
3721     return FALSE;   /* we failed to go to that packet */
3722   }
3723
3724   if (!packet_list_select_row_from_data(fdata)) {
3725     /* We didn't find a row corresponding to this frame.
3726        This means that the frame isn't being displayed currently,
3727        so we can't select it. */
3728     simple_message_box(ESD_TYPE_INFO, NULL,
3729                        "The capture file is probably not fully dissected.",
3730                        "End of capture exceeded!");
3731     return FALSE;
3732   }
3733   return TRUE;  /* we got to that packet */
3734 }
3735
3736 gboolean
3737 cf_goto_top_frame(void)
3738 {
3739   /* Find and select */
3740   packet_list_select_first_row();
3741   return TRUE;  /* we got to that packet */
3742 }
3743
3744 gboolean
3745 cf_goto_bottom_frame(void)
3746 {
3747   /* Find and select */
3748   packet_list_select_last_row();
3749   return TRUE;  /* we got to that packet */
3750 }
3751
3752 /*
3753  * Go to frame specified by currently selected protocol tree item.
3754  */
3755 gboolean
3756 cf_goto_framenum(capture_file *cf)
3757 {
3758   header_field_info *hfinfo;
3759   guint32            framenum;
3760
3761   if (cf->finfo_selected) {
3762     hfinfo = cf->finfo_selected->hfinfo;
3763     g_assert(hfinfo);
3764     if (hfinfo->type == FT_FRAMENUM) {
3765       framenum = fvalue_get_uinteger(&cf->finfo_selected->value);
3766       if (framenum != 0)
3767         return cf_goto_frame(cf, framenum);
3768       }
3769   }
3770
3771   return FALSE;
3772 }
3773
3774 /* Select the packet on a given row. */
3775 void
3776 cf_select_packet(capture_file *cf, int row)
3777 {
3778   epan_dissect_t *old_edt;
3779   frame_data     *fdata;
3780
3781   /* Get the frame data struct pointer for this frame */
3782   fdata = packet_list_get_row_data(row);
3783
3784   if (fdata == NULL) {
3785     /* XXX - if a GtkCList's selection mode is GTK_SELECTION_BROWSE, when
3786        the first entry is added to it by "real_insert_row()", that row
3787        is selected (see "real_insert_row()", in "ui/gtk/gtkclist.c", in both
3788        our version and the vanilla GTK+ version).
3789
3790        This means that a "select-row" signal is emitted; this causes
3791        "packet_list_select_cb()" to be called, which causes "cf_select_packet()"
3792        to be called.
3793
3794        "cf_select_packet()" fetches, above, the data associated with the
3795        row that was selected; however, as "gtk_clist_append()", which
3796        called "real_insert_row()", hasn't yet returned, we haven't yet
3797        associated any data with that row, so we get back a null pointer.
3798
3799        We can't assume that there's only one frame in the frame list,
3800        either, as we may be filtering the display.
3801
3802        We therefore assume that, if "row" is 0, i.e. the first row
3803        is being selected, and "cf->first_displayed" equals
3804        "cf->last_displayed", i.e. there's only one frame being
3805        displayed, that frame is the frame we want.
3806
3807        This means we have to set "cf->first_displayed" and
3808        "cf->last_displayed" before adding the row to the
3809        GtkCList; see the comment in "add_packet_to_packet_list()". */
3810
3811        if (row == 0 && cf->first_displayed == cf->last_displayed)
3812          fdata = frame_data_sequence_find(cf->frames, cf->first_displayed);
3813   }
3814
3815   /* If fdata _still_ isn't set simply give up. */
3816   if (fdata == NULL) {
3817     return;
3818   }
3819
3820   /* Get the data in that frame. */
3821   if (!cf_read_frame (cf, fdata)) {
3822     return;
3823   }
3824
3825   /* Record that this frame is the current frame. */
3826   cf->current_frame = fdata;
3827   cf->current_row = row;
3828
3829   old_edt = cf->edt;
3830   /* Create the logical protocol tree. */
3831   /* We don't need the columns here. */
3832   cf->edt = epan_dissect_new(cf->epan, TRUE, TRUE);
3833
3834   tap_build_interesting(cf->edt);
3835   epan_dissect_run(cf->edt, &cf->phdr, frame_tvbuff_new_buffer(cf->current_frame, &cf->buf),
3836                    cf->current_frame, NULL);
3837
3838   dfilter_macro_build_ftv_cache(cf->edt->tree);