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