Add APIs to Wiretap to return the file of the size as supplied by the OS
[metze/wireshark/wip.git] / file.c
1 /* file.c
2  * File I/O routines
3  *
4  * $Id$
5  *
6  * Ethereal - Network traffic analyzer
7  * By Gerald Combs <gerald@ethereal.com>
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 #ifdef HAVE_IO_H
36 #include <io.h>
37 #endif
38
39 #include <stdlib.h>
40 #include <stdio.h>
41 #include <string.h>
42 #include <ctype.h>
43 #include <errno.h>
44 #include <signal.h>
45
46 #ifdef HAVE_FCNTL_H
47 #include <fcntl.h>
48 #endif
49
50 #ifdef NEED_STRERROR_H
51 #include "strerror.h"
52 #endif
53
54 #include <epan/epan.h>
55 #include <epan/filesystem.h>
56
57 #include "color.h"
58 #include "color_filters.h"
59 #include <epan/column.h>
60 #include <epan/packet.h>
61 #include "packet-range.h"
62 #include "print.h"
63 #include "file.h"
64 #include "fileset.h"
65 #include "util.h"
66 #include "merge.h"
67 #include "alert_box.h"
68 #include "simple_dialog.h"
69 #include "progress_dlg.h"
70 #include "ui_util.h"
71 #include <epan/prefs.h>
72 #include <epan/dfilter/dfilter.h>
73 #include <epan/conversation.h>
74 #include <epan/epan_dissect.h>
75 #include <epan/tap.h>
76 #include "tap_dfilter_dlg.h"
77 #include <epan/dissectors/packet-data.h>
78
79 /* Win32 needs the O_BINARY flag for open() */
80 #ifndef O_BINARY
81 #define O_BINARY        0
82 #endif
83
84 #ifdef HAVE_LIBPCAP
85 gboolean auto_scroll_live;
86 #endif
87
88 static guint32 firstsec, firstusec;
89 static guint32 prevsec, prevusec;
90 static guint32 cum_bytes = 0;
91
92 static void cf_reset_state(capture_file *cf);
93
94 static void read_packet(capture_file *cf, long offset);
95
96 static void rescan_packets(capture_file *cf, const char *action, const char *action_item,
97         gboolean refilter, gboolean redissect);
98
99 static gboolean match_protocol_tree(capture_file *cf, frame_data *fdata,
100         void *criterion);
101 static void match_subtree_text(proto_node *node, gpointer data);
102 static gboolean match_summary_line(capture_file *cf, frame_data *fdata,
103         void *criterion);
104 static gboolean match_ascii_and_unicode(capture_file *cf, frame_data *fdata,
105         void *criterion);
106 static gboolean match_ascii(capture_file *cf, frame_data *fdata,
107         void *criterion);
108 static gboolean match_unicode(capture_file *cf, frame_data *fdata,
109         void *criterion);
110 static gboolean match_binary(capture_file *cf, frame_data *fdata,
111         void *criterion);
112 static gboolean match_dfilter(capture_file *cf, frame_data *fdata,
113         void *criterion);
114 static gboolean find_packet(capture_file *cf,
115         gboolean (*match_function)(capture_file *, frame_data *, void *),
116         void *criterion);
117
118 static void cf_open_failure_alert_box(const char *filename, int err,
119                                       gchar *err_info, gboolean for_writing,
120                                       int file_type);
121 static const char *file_rename_error_message(int err);
122 static void cf_write_failure_alert_box(const char *filename, int err);
123 static void cf_close_failure_alert_box(const char *filename, int err);
124 static   gboolean copy_binary_file(const char *from_filename, const char *to_filename);
125
126 /* Update the progress bar this many times when reading a file. */
127 #define N_PROGBAR_UPDATES       100
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 /* one callback for now, we could have a list later */
135 static cf_callback_t cf_cb = NULL;
136 static gpointer cf_cb_user_data = NULL;
137
138 void
139 cf_callback_invoke(int event, gpointer data)
140 {
141     g_assert(cf_cb != NULL);
142     cf_cb(event, data, cf_cb_user_data);
143 }
144
145
146 void
147 cf_callback_add(cf_callback_t func, gpointer user_data)
148 {
149     /* More than one callback listener is currently not implemented,
150        but should be easy to do. */
151     g_assert(cf_cb == NULL);
152     cf_cb = func;
153     cf_cb_user_data = user_data;
154 }
155
156 void
157 cf_callback_remove(cf_callback_t func _U_)
158 {
159     g_assert(cf_cb != NULL);
160     cf_cb = NULL;
161     cf_cb_user_data = NULL;
162 }
163
164
165 cf_status_t
166 cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
167 {
168   wtap       *wth;
169   gchar       *err_info;
170   gint64      size;
171
172   wth = wtap_open_offline(fname, err, &err_info, TRUE);
173   if (wth == NULL)
174     goto fail;
175
176   /* Find the size of the file. */
177   size = wtap_file_size(wth, err);
178   if (size == -1) {
179     wtap_close(wth);
180     goto fail;
181   }
182
183   /* The open succeeded.  Close whatever capture file we had open,
184      and fill in the information for this file. */
185   cf_reset_state(cf);
186
187   /* Initialize all data structures used for dissection. */
188   init_dissection();
189
190   /* We're about to start reading the file. */
191   cf->state = FILE_READ_IN_PROGRESS;
192
193   cf->wth = wth;
194   cf->f_datalen = 0;
195   cf->f_len = size;
196
197   /* Set the file name because we need it to set the follow stream filter.
198      XXX - is that still true?  We need it for other reasons, though,
199      in any case. */
200   cf->filename = g_strdup(fname);
201
202   /* Indicate whether it's a permanent or temporary file. */
203   cf->is_tempfile = is_tempfile;
204
205   /* If it's a temporary capture buffer file, mark it as not saved. */
206   cf->user_saved = !is_tempfile;
207
208   cf->cd_t      = wtap_file_type(cf->wth);
209   cf->count     = 0;
210   cf->displayed_count = 0;
211   cf->marked_count = 0;
212   cf->drops_known = FALSE;
213   cf->drops     = 0;
214   cf->esec      = 0;
215   cf->eusec     = 0;
216   cf->snap      = wtap_snapshot_length(cf->wth);
217   if (cf->snap == 0) {
218     /* Snapshot length not known. */
219     cf->has_snap = FALSE;
220     cf->snap = WTAP_MAX_PACKET_SIZE;
221   } else
222     cf->has_snap = TRUE;
223   firstsec = 0, firstusec = 0;
224   prevsec = 0, prevusec = 0;
225
226   cf->plist_chunk = g_mem_chunk_new("frame_data_chunk",
227         sizeof(frame_data),
228         FRAME_DATA_CHUNK_SIZE * sizeof(frame_data),
229         G_ALLOC_AND_FREE);
230   g_assert(cf->plist_chunk);
231
232   fileset_file_opened(fname);
233
234   return CF_OK;
235
236 fail:
237   cf_open_failure_alert_box(fname, *err, err_info, FALSE, 0);
238   return CF_ERROR;
239 }
240
241
242 /*
243  * Reset the state for the currently closed file, but don't do the
244  * UI callbacks; this is for use in "cf_open()", where we don't
245  * want the UI to go from "file open" to "file closed" back to
246  * "file open", we want it to go from "old file open" to "new file
247  * open and being read".
248  */
249 static void
250 cf_reset_state(capture_file *cf)
251 {
252   /* Die if we're in the middle of reading a file. */
253   g_assert(cf->state != FILE_READ_IN_PROGRESS);
254
255   if (cf->wth) {
256     wtap_close(cf->wth);
257     cf->wth = NULL;
258   }
259   /* We have no file open... */
260   if (cf->filename != NULL) {
261     /* If it's a temporary file, remove it. */
262     if (cf->is_tempfile)
263       unlink(cf->filename);
264     g_free(cf->filename);
265     cf->filename = NULL;
266   }
267   /* ...which means we have nothing to save. */
268   cf->user_saved = FALSE;
269
270   if (cf->plist_chunk != NULL) {
271     g_mem_chunk_destroy(cf->plist_chunk);
272     cf->plist_chunk = NULL;
273   }
274   if (cf->rfcode != NULL) {
275     dfilter_free(cf->rfcode);
276     cf->rfcode = NULL;
277   }
278   cf->plist = NULL;
279   cf->plist_end = NULL;
280   cf_unselect_packet(cf);       /* nothing to select */
281   cf->first_displayed = NULL;
282   cf->last_displayed = NULL;
283
284   /* No frame selected, no field in that frame selected. */
285   cf->current_frame = NULL;
286   cf->finfo_selected = NULL;
287
288   /* Clear the packet list. */
289   packet_list_freeze();
290   packet_list_clear();
291   packet_list_thaw();
292
293   cf->f_datalen = 0;
294   cf->f_len = 0;
295   cf->count = 0;
296   cf->esec  = 0;
297   cf->eusec = 0;
298
299   reset_tap_listeners();
300
301   /* We have no file open. */
302   cf->state = FILE_CLOSED;
303
304   fileset_file_closed();
305 }
306
307 /* Reset everything to a pristine state */
308 void
309 cf_close(capture_file *cf)
310 {
311   cf_reset_state(cf);
312
313   cleanup_dissection();
314
315   cf_callback_invoke(cf_cb_file_closed, cf);
316 }
317
318 cf_read_status_t
319 cf_read(capture_file *cf)
320 {
321   int         err;
322   gchar       *err_info;
323   const gchar *name_ptr;
324   const char  *errmsg;
325   char         errmsg_errno[1024+1];
326   gchar        err_str[2048+1];
327   long         data_offset;
328   progdlg_t   *progbar = NULL;
329   gboolean     stop_flag;
330   gint64       size, file_pos;
331   float        prog_val;
332   GTimeVal     start_time;
333   gchar        status_str[100];
334   int          progbar_nextstep;
335   int          progbar_quantum;
336
337   cum_bytes=0;
338
339   reset_tap_listeners();
340   tap_dfilter_dlg_update();
341
342   cf_callback_invoke(cf_cb_file_read_start, cf);
343
344   name_ptr = get_basename(cf->filename);
345
346   /* Update the progress bar when it gets to this value. */
347   progbar_nextstep = 0;
348   /* When we reach the value that triggers a progress bar update,
349      bump that value by this amount. */
350   progbar_quantum = cf->f_len/N_PROGBAR_UPDATES;
351
352   packet_list_freeze();
353
354   stop_flag = FALSE;
355   g_get_current_time(&start_time);
356
357   while ((wtap_read(cf->wth, &err, &err_info, &data_offset))) {
358     /* Update the progress bar, but do it only N_PROGBAR_UPDATES times;
359        when we update it, we have to run the GTK+ main loop to get it
360        to repaint what's pending, and doing so may involve an "ioctl()"
361        to see if there's any pending input from an X server, and doing
362        that for every packet can be costly, especially on a big file. */
363     if (data_offset >= progbar_nextstep) {
364         file_pos = wtap_read_so_far(cf->wth, NULL);
365         prog_val = (gfloat) file_pos / (gfloat) cf->f_len;
366         if (prog_val > 1.0) {
367           /* The file probably grew while we were reading it.
368              Update "cf->f_len", and try again. */
369           size = wtap_file_size(cf->wth, NULL);
370           if (size != -1) {
371             cf->f_len = size;
372             prog_val = (gfloat) file_pos / (gfloat) cf->f_len;
373           }
374           /* If it's still > 1, either "wtap_file_size()" failed (in which
375              case there's not much we can do about it), or the file
376              *shrank* (in which case there's not much we can do about
377              it); just clip the progress value at 1.0. */
378           if (prog_val > 1.0)
379             prog_val = 1.0;
380         }
381         if (progbar == NULL) {
382           /* Create the progress bar if necessary */
383           progbar = delayed_create_progress_dlg("Loading", name_ptr,
384             &stop_flag, &start_time, prog_val);
385         }
386         if (progbar != NULL) {
387           g_snprintf(status_str, sizeof(status_str),
388                      "%" PRId64 "KB of %" PRId64 "KB",
389                      file_pos / 1024, cf->f_len / 1024);
390           update_progress_dlg(progbar, prog_val, status_str);
391         }
392         progbar_nextstep += progbar_quantum;
393     }
394
395     if (stop_flag) {
396       /* Well, the user decided to abort the read.  Destroy the progress
397          bar, close the capture file, and return CF_READ_ABORTED so our caller
398          can do whatever is appropriate when that happens. */
399       destroy_progress_dlg(progbar);
400       cf->state = FILE_READ_ABORTED;    /* so that we're allowed to close it */
401       packet_list_thaw();               /* undo our freeze */
402       cf_close(cf);
403       return CF_READ_ABORTED;
404     }
405     read_packet(cf, data_offset);
406   }
407
408   /* We're done reading the file; destroy the progress bar if it was created. */
409   if (progbar != NULL)
410     destroy_progress_dlg(progbar);
411
412   /* We're done reading sequentially through the file. */
413   cf->state = FILE_READ_DONE;
414
415   /* Close the sequential I/O side, to free up memory it requires. */
416   wtap_sequential_close(cf->wth);
417
418   /* Allow the protocol dissectors to free up memory that they
419    * don't need after the sequential run-through of the packets. */
420   postseq_cleanup_all_protocols();
421
422   /* Set the file encapsulation type now; we don't know what it is until
423      we've looked at all the packets, as we don't know until then whether
424      there's more than one type (and thus whether it's
425      WTAP_ENCAP_PER_PACKET). */
426   cf->lnk_t = wtap_file_encap(cf->wth);
427
428   cf->current_frame = cf->first_displayed;
429   packet_list_thaw();
430
431   cf_callback_invoke(cf_cb_file_read_finished, cf);
432
433   /* If we have any displayed packets to select, select the first of those
434      packets by making the first row the selected row. */
435   if (cf->first_displayed != NULL)
436     packet_list_select_row(0);
437
438   if (err != 0) {
439     /* Put up a message box noting that the read failed somewhere along
440        the line.  Don't throw out the stuff we managed to read, though,
441        if any. */
442     switch (err) {
443
444     case WTAP_ERR_UNSUPPORTED_ENCAP:
445       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
446                "The capture file has a packet with a network type that Ethereal doesn't support.\n(%s)",
447                err_info);
448       g_free(err_info);
449       errmsg = errmsg_errno;
450       break;
451
452     case WTAP_ERR_CANT_READ:
453       errmsg = "An attempt to read from the capture file failed for"
454                " some unknown reason.";
455       break;
456
457     case WTAP_ERR_SHORT_READ:
458       errmsg = "The capture file appears to have been cut short"
459                " in the middle of a packet.";
460       break;
461
462     case WTAP_ERR_BAD_RECORD:
463       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
464                "The capture file appears to be damaged or corrupt.\n(%s)",
465                err_info);
466       g_free(err_info);
467       errmsg = errmsg_errno;
468       break;
469
470     default:
471       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
472                "An error occurred while reading the"
473                " capture file: %s.", wtap_strerror(err));
474       errmsg = errmsg_errno;
475       break;
476     }
477     g_snprintf(err_str, sizeof err_str, errmsg);
478     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, err_str);
479     return CF_READ_ERROR;
480   } else
481     return CF_READ_OK;
482 }
483
484 #ifdef HAVE_LIBPCAP
485 cf_status_t
486 cf_start_tail(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
487 {
488   cf_status_t cf_status;
489
490   cf_status = cf_open(cf, fname, is_tempfile, err);
491   return cf_status;
492 }
493
494 cf_read_status_t
495 cf_continue_tail(capture_file *cf, int to_read, int *err)
496 {
497   long data_offset = 0;
498   gchar *err_info;
499
500   *err = 0;
501
502   packet_list_freeze();
503
504   while (to_read != 0 && (wtap_read(cf->wth, err, &err_info, &data_offset))) {
505     if (cf->state == FILE_READ_ABORTED) {
506       /* Well, the user decided to exit Ethereal.  Break out of the
507          loop, and let the code below (which is called even if there
508          aren't any packets left to read) exit. */
509       break;
510     }
511     read_packet(cf, data_offset);
512     to_read--;
513   }
514
515   packet_list_thaw();
516
517   /* XXX - this cheats and looks inside the packet list to find the final
518      row number. */
519   if (auto_scroll_live && cf->plist_end != NULL)
520     packet_list_moveto_end();
521
522   if (cf->state == FILE_READ_ABORTED) {
523     /* Well, the user decided to exit Ethereal.  Return CF_READ_ABORTED
524        so that our caller can kill off the capture child process;
525        this will cause an EOF on the pipe from the child, so
526        "cf_finish_tail()" will be called, and it will clean up
527        and exit. */
528     return CF_READ_ABORTED;
529   } else if (*err != 0) {
530     /* We got an error reading the capture file.
531        XXX - pop up a dialog box? */
532     return CF_READ_ERROR;
533   } else
534     return CF_READ_OK;
535 }
536
537 cf_read_status_t
538 cf_finish_tail(capture_file *cf, int *err)
539 {
540   gchar *err_info;
541   long data_offset;
542   gint64 size;
543
544   if(cf->wth == NULL) {
545     cf_close(cf);
546     return CF_READ_ERROR;
547   }
548
549   packet_list_freeze();
550
551   while ((wtap_read(cf->wth, err, &err_info, &data_offset))) {
552     if (cf->state == FILE_READ_ABORTED) {
553       /* Well, the user decided to abort the read.  Break out of the
554          loop, and let the code below (which is called even if there
555          aren't any packets left to read) exit. */
556       break;
557     }
558     read_packet(cf, data_offset);
559   }
560
561   if (cf->state == FILE_READ_ABORTED) {
562     /* Well, the user decided to abort the read.  We're only called
563        when the child capture process closes the pipe to us (meaning
564        it's probably exited), so we can just close the capture
565        file; we return CF_READ_ABORTED so our caller can do whatever
566        is appropriate when that happens. */
567     cf_close(cf);
568     return CF_READ_ABORTED;
569   }
570
571   packet_list_thaw();
572   if (auto_scroll_live && cf->plist_end != NULL)
573     /* XXX - this cheats and looks inside the packet list to find the final
574        row number. */
575     packet_list_moveto_end();
576
577   /* We're done reading sequentially through the file. */
578   cf->state = FILE_READ_DONE;
579
580   /* we have to update the f_len field */
581   /* Find the size of the file. */
582   size = wtap_file_size(cf->wth, NULL);
583   if (size != -1)
584         cf->f_len = size;
585
586   /* We're done reading sequentially through the file; close the
587      sequential I/O side, to free up memory it requires. */
588   wtap_sequential_close(cf->wth);
589
590   /* Allow the protocol dissectors to free up memory that they
591    * don't need after the sequential run-through of the packets. */
592   postseq_cleanup_all_protocols();
593
594   /* Set the file encapsulation type now; we don't know what it is until
595      we've looked at all the packets, as we don't know until then whether
596      there's more than one type (and thus whether it's
597      WTAP_ENCAP_PER_PACKET). */
598   cf->lnk_t = wtap_file_encap(cf->wth);
599
600   if (*err != 0) {
601     /* We got an error reading the capture file.
602        XXX - pop up a dialog box? */
603     return CF_READ_ERROR;
604   } else {
605     return CF_READ_OK;
606   }
607 }
608 #endif /* HAVE_LIBPCAP */
609
610 const gchar *
611 cf_get_display_name(capture_file *cf)
612 {
613   const gchar *displayname;
614
615   /* Return a name to use in displays */
616   if (!cf->is_tempfile) {
617     /* Get the last component of the file name, and use that. */
618     if (cf->filename){
619       displayname = get_basename(cf->filename);
620     } else {
621       displayname="(No file)";
622     }
623   } else {
624     /* The file we read is a temporary file from a live capture;
625        we don't mention its name. */
626     displayname = "(Untitled)";
627   }
628   return displayname;
629 }
630
631 /* XXX - use a macro instead? */
632 int
633 cf_packet_count(capture_file *cf)
634 {
635     return cf->count;
636 }
637
638 /* XXX - use a macro instead? */
639 gboolean
640 cf_is_tempfile(capture_file *cf)
641 {
642     return cf->is_tempfile;
643 }
644
645 void cf_set_tempfile(capture_file *cf, gboolean is_tempfile)
646 {
647     cf->is_tempfile = is_tempfile;
648 }
649
650
651 /* XXX - use a macro instead? */
652 void cf_set_drops_known(capture_file *cf, gboolean drops_known)
653 {
654     cf->drops_known = drops_known;
655 }
656
657 /* XXX - use a macro instead? */
658 void cf_set_drops(capture_file *cf, guint32 drops)
659 {
660     cf->drops = drops;
661 }
662
663 /* XXX - use a macro instead? */
664 gboolean cf_get_drops_known(capture_file *cf)
665 {
666     return cf->drops_known;
667 }
668
669 /* XXX - use a macro instead? */
670 guint32 cf_get_drops(capture_file *cf)
671 {
672     return cf->drops;
673 }
674
675 void cf_set_rfcode(capture_file *cf, dfilter_t *rfcode)
676 {
677     cf->rfcode = rfcode;
678 }
679
680 static int
681 add_packet_to_packet_list(frame_data *fdata, capture_file *cf,
682         union wtap_pseudo_header *pseudo_header, const guchar *buf,
683         gboolean refilter)
684 {
685   gint          row;
686   gboolean      create_proto_tree = FALSE;
687   epan_dissect_t *edt;
688
689   /* just add some value here until we know if it is being displayed or not */
690   fdata->cum_bytes  = cum_bytes + fdata->pkt_len;
691
692   /* If we don't have the time stamp of the first packet in the
693      capture, it's because this is the first packet.  Save the time
694      stamp of this packet as the time stamp of the first packet. */
695   if (!firstsec && !firstusec) {
696     firstsec  = fdata->abs_secs;
697     firstusec = fdata->abs_usecs;
698   }
699   /* if this frames is marked as a reference time frame, reset
700      firstsec and firstusec to this frame */
701   if(fdata->flags.ref_time){
702     firstsec  = fdata->abs_secs;
703     firstusec = fdata->abs_usecs;
704   }
705
706   /* If we don't have the time stamp of the previous displayed packet,
707      it's because this is the first displayed packet.  Save the time
708      stamp of this packet as the time stamp of the previous displayed
709      packet. */
710   if (!prevsec && !prevusec) {
711     prevsec  = fdata->abs_secs;
712     prevusec = fdata->abs_usecs;
713   }
714
715   /* Get the time elapsed between the first packet and this packet. */
716   compute_timestamp_diff(&fdata->rel_secs, &fdata->rel_usecs,
717      fdata->abs_secs, fdata->abs_usecs, firstsec, firstusec);
718
719   /* If it's greater than the current elapsed time, set the elapsed time
720      to it (we check for "greater than" so as not to be confused by
721      time moving backwards). */
722   if ((gint32)cf->esec < fdata->rel_secs
723   || ((gint32)cf->esec == fdata->rel_secs && (gint32)cf->eusec < fdata->rel_usecs)) {
724     cf->esec = fdata->rel_secs;
725     cf->eusec = fdata->rel_usecs;
726   }
727
728   /* Get the time elapsed between the previous displayed packet and
729      this packet. */
730   compute_timestamp_diff(&fdata->del_secs, &fdata->del_usecs,
731         fdata->abs_secs, fdata->abs_usecs, prevsec, prevusec);
732
733   /* If either
734
735         we have a display filter and are re-applying it;
736
737         we have a list of color filters;
738
739         we have tap listeners;
740
741      allocate a protocol tree root node, so that we'll construct
742      a protocol tree against which a filter expression can be
743      evaluated. */
744   if ((cf->dfcode != NULL && refilter) || color_filters_used()
745         || num_tap_filters != 0)
746           create_proto_tree = TRUE;
747
748   /* Dissect the frame. */
749   edt = epan_dissect_new(create_proto_tree, FALSE);
750
751   if (cf->dfcode != NULL && refilter) {
752       epan_dissect_prime_dfilter(edt, cf->dfcode);
753   }
754   if (color_filters_used()) {
755       color_filters_prime_edt(edt);
756   }
757   tap_queue_init(edt);
758   epan_dissect_run(edt, pseudo_header, buf, fdata, &cf->cinfo);
759   tap_push_tapped_queue(edt);
760
761   /* If we have a display filter, apply it if we're refiltering, otherwise
762      leave the "passed_dfilter" flag alone.
763
764      If we don't have a display filter, set "passed_dfilter" to 1. */
765   if (cf->dfcode != NULL) {
766     if (refilter) {
767       fdata->flags.passed_dfilter = dfilter_apply_edt(cf->dfcode, edt) ? 1 : 0;
768     }
769   } else
770     fdata->flags.passed_dfilter = 1;
771
772   if( (fdata->flags.passed_dfilter) 
773    || (edt->pi.fd->flags.ref_time) ){
774     /* This frame either passed the display filter list or is marked as
775        a time reference frame.  All time reference frames are displayed
776        even if they dont pass the display filter */
777     /* if this was a TIME REF frame we should reset the cul bytes field */
778     if(edt->pi.fd->flags.ref_time){
779       cum_bytes = fdata->pkt_len;
780       fdata->cum_bytes  = cum_bytes;
781     }
782
783     /* increase cum_bytes with this packets length */
784     cum_bytes += fdata->pkt_len;
785
786     epan_dissect_fill_in_columns(edt);
787
788     /* If we haven't yet seen the first frame, this is it.
789
790        XXX - we must do this before we add the row to the display,
791        as, if the display's GtkCList's selection mode is
792        GTK_SELECTION_BROWSE, when the first entry is added to it,
793        "cf_select_packet()" will be called, and it will fetch the row
794        data for the 0th row, and will get a null pointer rather than
795        "fdata", as "gtk_clist_append()" won't yet have returned and
796        thus "gtk_clist_set_row_data()" won't yet have been called.
797
798        We thus need to leave behind bread crumbs so that
799        "cf_select_packet()" can find this frame.  See the comment
800        in "cf_select_packet()". */
801     if (cf->first_displayed == NULL)
802       cf->first_displayed = fdata;
803
804     /* This is the last frame we've seen so far. */
805     cf->last_displayed = fdata;
806
807     row = packet_list_append(cf->cinfo.col_data, fdata);
808
809     /* colorize packet: if packet is marked, use preferences, 
810        otherwise try to apply color filters */
811       if (fdata->flags.marked) {
812           fdata->color_filter = NULL;
813           packet_list_set_colors(row, &prefs.gui_marked_fg, &prefs.gui_marked_bg);
814       } else {
815           fdata->color_filter = color_filters_colorize_packet(row, edt);
816       }
817
818     /* Set the time of the previous displayed frame to the time of this
819        frame. */
820     prevsec = fdata->abs_secs;
821     prevusec = fdata->abs_usecs;
822
823     cf->displayed_count++;
824   } else {
825     /* This frame didn't pass the display filter, so it's not being added
826        to the clist, and thus has no row. */
827     row = -1;
828   }
829   epan_dissect_free(edt);
830   return row;
831 }
832
833 static void
834 read_packet(capture_file *cf, long offset)
835 {
836   const struct wtap_pkthdr *phdr = wtap_phdr(cf->wth);
837   union wtap_pseudo_header *pseudo_header = wtap_pseudoheader(cf->wth);
838   const guchar *buf = wtap_buf_ptr(cf->wth);
839   frame_data   *fdata;
840   int           passed;
841   frame_data   *plist_end;
842   epan_dissect_t *edt;
843
844   /* Allocate the next list entry, and add it to the list. */
845   fdata = g_mem_chunk_alloc(cf->plist_chunk);
846
847   fdata->next = NULL;
848   fdata->prev = NULL;
849   fdata->pfd  = NULL;
850   fdata->pkt_len  = phdr->len;
851   fdata->cap_len  = phdr->caplen;
852   fdata->file_off = offset;
853   fdata->lnk_t = phdr->pkt_encap;
854   fdata->abs_secs  = phdr->ts.tv_sec;
855   fdata->abs_usecs = phdr->ts.tv_usec;
856   fdata->flags.encoding = CHAR_ASCII;
857   fdata->flags.visited = 0;
858   fdata->flags.marked = 0;
859   fdata->flags.ref_time = 0;
860
861   passed = TRUE;
862   if (cf->rfcode) {
863     edt = epan_dissect_new(TRUE, FALSE);
864     epan_dissect_prime_dfilter(edt, cf->rfcode);
865     epan_dissect_run(edt, pseudo_header, buf, fdata, NULL);
866     passed = dfilter_apply_edt(cf->rfcode, edt);
867     epan_dissect_free(edt);
868   }
869   if (passed) {
870     plist_end = cf->plist_end;
871     fdata->prev = plist_end;
872     if (plist_end != NULL)
873       plist_end->next = fdata;
874     else
875       cf->plist = fdata;
876     cf->plist_end = fdata;
877
878     cf->count++;
879     cf->f_datalen = offset + phdr->caplen;
880     fdata->num = cf->count;
881     add_packet_to_packet_list(fdata, cf, pseudo_header, buf, TRUE);
882   } else {
883     /* XXX - if we didn't have read filters, or if we could avoid
884        allocating the "frame_data" structure until we knew whether
885        the frame passed the read filter, we could use a G_ALLOC_ONLY
886        memory chunk...
887
888        ...but, at least in one test I did, where I just made the chunk
889        a G_ALLOC_ONLY chunk and read in a huge capture file, it didn't
890        seem to save a noticeable amount of time or space. */
891     g_mem_chunk_free(cf->plist_chunk, fdata);
892   }
893 }
894
895 cf_status_t
896 cf_merge_files(char **out_filenamep, int in_file_count,
897                char *const *in_filenames, int file_type, gboolean do_append)
898 {
899   merge_in_file_t  *in_files;
900   wtap             *wth;
901   char             *out_filename;
902   char              tmpname[128+1];
903   int               out_fd;
904   wtap_dumper      *pdh;
905   int               open_err, read_err, write_err, close_err;
906   gchar            *err_info;
907   int               err_fileno; 
908   int               i;
909   char              errmsg_errno[1024+1];
910   gchar             err_str[2048+1];
911   const char       *errmsg;
912   gboolean          got_read_error = FALSE, got_write_error = FALSE;
913   long              data_offset;
914   progdlg_t        *progbar = NULL;
915   gboolean          stop_flag;
916   gint64            f_len, file_pos;
917   float             prog_val;
918   GTimeVal          start_time;
919   gchar             status_str[100];
920   int               progbar_nextstep;
921   int               progbar_quantum;
922
923   /* open the input files */
924   if (!merge_open_in_files(in_file_count, in_filenames, &in_files,
925                            &open_err, &err_info, &err_fileno)) {
926     free(in_files);
927     cf_open_failure_alert_box(in_filenames[err_fileno], open_err, err_info,
928                               FALSE, 0);
929     return CF_ERROR;
930   }
931
932   if (*out_filenamep != NULL) {
933     out_filename = *out_filenamep;
934     out_fd = open(out_filename, O_CREAT|O_TRUNC|O_BINARY, 0600);
935     if (out_fd == -1)
936       open_err = errno;
937   } else {
938     out_fd = create_tempfile(tmpname, sizeof tmpname, "ether");
939     if (out_fd == -1)
940       open_err = errno;
941     out_filename = g_strdup(tmpname);
942     *out_filenamep = out_filename;
943   }
944   if (out_fd == -1) {
945     err_info = NULL;
946     merge_close_in_files(in_file_count, in_files);
947     free(in_files);
948     cf_open_failure_alert_box(out_filename, open_err, NULL, TRUE, file_type);
949     return CF_ERROR;
950   }
951
952   pdh = wtap_dump_fdopen(out_fd, file_type,
953       merge_select_frame_type(in_file_count, in_files),
954       merge_max_snapshot_length(in_file_count, in_files), &open_err);
955   if (pdh == NULL) {
956     close(out_fd);
957     merge_close_in_files(in_file_count, in_files);
958     free(in_files);
959     cf_open_failure_alert_box(out_filename, open_err, err_info, TRUE,
960                               file_type);
961     return CF_ERROR;
962   }
963
964   /* Get the sum of the sizes of all the files. */
965   f_len = 0;
966   for (i = 0; i < in_file_count; i++)
967     f_len += in_files[i].size;
968
969   /* Update the progress bar when it gets to this value. */
970   progbar_nextstep = 0;
971   /* When we reach the value that triggers a progress bar update,
972      bump that value by this amount. */
973   progbar_quantum = f_len/N_PROGBAR_UPDATES;
974
975   stop_flag = FALSE;
976   g_get_current_time(&start_time);
977
978   /* do the merge (or append) */
979   for (;;) {
980     if (do_append)
981       wth = merge_append_read_packet(in_file_count, in_files, &read_err,
982                                      &err_info);
983     else
984       wth = merge_read_packet(in_file_count, in_files, &read_err,
985                               &err_info);
986     if (wth == NULL) {
987       if (read_err != 0)
988         got_read_error = TRUE;
989       break;
990     }
991
992     /* Get the sum of the data offsets in all of the files. */
993     data_offset = 0;
994     for (i = 0; i < in_file_count; i++)
995       data_offset += in_files[i].data_offset;
996
997     if (data_offset >= progbar_nextstep) {
998         /* Get the sum of the seek positions in all of the files. */
999         file_pos = 0;
1000         for (i = 0; i < in_file_count; i++)
1001           file_pos += wtap_read_so_far(in_files[i].wth, NULL);
1002         prog_val = (gfloat) file_pos / (gfloat) f_len;
1003         if (prog_val > 1.0) {
1004           /* Some file probably grew while we were reading it.
1005              That "shouldn't happen", so we'll just clip the progress
1006              value at 1.0. */
1007           prog_val = 1.0;
1008         }
1009         if (progbar == NULL) {
1010           /* Create the progress bar if necessary */
1011           progbar = delayed_create_progress_dlg("Merging", "files",
1012             &stop_flag, &start_time, prog_val);
1013         }
1014         if (progbar != NULL) {
1015           g_snprintf(status_str, sizeof(status_str),
1016                      "%" PRId64 "KB of %" PRId64 "KB",
1017                      file_pos / 1024, f_len / 1024);
1018           update_progress_dlg(progbar, prog_val, status_str);
1019         }
1020         progbar_nextstep += progbar_quantum;
1021     }
1022
1023     if (!wtap_dump(pdh, wtap_phdr(wth), wtap_pseudoheader(wth),
1024          wtap_buf_ptr(wth), &write_err)) {
1025       got_write_error = TRUE;
1026       break;
1027     }
1028   }
1029
1030   /* We're done merging the files; destroy the progress bar if it was created. */
1031   if (progbar != NULL)
1032     destroy_progress_dlg(progbar);
1033
1034   merge_close_in_files(in_file_count, in_files);
1035   if (!got_read_error && !got_write_error) {
1036     if (!wtap_dump_close(pdh, &write_err))
1037       got_write_error = TRUE;
1038   } else
1039     wtap_dump_close(pdh, &close_err);
1040
1041   if (got_read_error) {
1042     /*
1043      * Find the file on which we got the error, and report the error.
1044      */
1045     for (i = 0; i < in_file_count; i++) {
1046       if (in_files[i].state == GOT_ERROR) {
1047         /* Put up a message box noting that a read failed somewhere along
1048            the line. */
1049         switch (read_err) {
1050
1051         case WTAP_ERR_UNSUPPORTED_ENCAP:
1052           g_snprintf(errmsg_errno, sizeof(errmsg_errno),
1053                    "The capture file %%s has a packet with a network type that Ethereal doesn't support.\n(%s)",
1054                    err_info);
1055           g_free(err_info);
1056           errmsg = errmsg_errno;
1057           break;
1058
1059         case WTAP_ERR_CANT_READ:
1060           errmsg = "An attempt to read from the capture file %s failed for"
1061                    " some unknown reason.";
1062           break;
1063
1064         case WTAP_ERR_SHORT_READ:
1065           errmsg = "The capture file %s appears to have been cut short"
1066                    " in the middle of a packet.";
1067           break;
1068
1069         case WTAP_ERR_BAD_RECORD:
1070           g_snprintf(errmsg_errno, sizeof(errmsg_errno),
1071                    "The capture file %%s appears to be damaged or corrupt.\n(%s)",
1072                    err_info);
1073           g_free(err_info);
1074           errmsg = errmsg_errno;
1075           break;
1076
1077         default:
1078           g_snprintf(errmsg_errno, sizeof(errmsg_errno),
1079                    "An error occurred while reading the"
1080                    " capture file %%s: %s.", wtap_strerror(read_err));
1081           errmsg = errmsg_errno;
1082           break;
1083         }
1084         g_snprintf(err_str, sizeof err_str, errmsg, in_files[i].filename);
1085         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, err_str);
1086       }
1087     }
1088   }
1089
1090   if (got_write_error) {
1091     /* Put up an alert box for the write error. */
1092     cf_write_failure_alert_box(out_filename, write_err);
1093   }
1094
1095   return (!got_read_error && !got_write_error) ? CF_OK : CF_ERROR;
1096 }
1097
1098 cf_status_t
1099 cf_filter_packets(capture_file *cf, gchar *dftext, gboolean force)
1100 {
1101   dfilter_t  *dfcode;
1102   const char *filter_new = dftext ? dftext : "";
1103   const char *filter_old = cf->dfilter ? cf->dfilter : "";
1104
1105   /* if new filter equals old one, do nothing unless told to do so */
1106   if (!force && strcmp(filter_new, filter_old) == 0) {
1107     return CF_OK;
1108   }
1109
1110   if (dftext == NULL) {
1111     /* The new filter is an empty filter (i.e., display all packets). */
1112     dfcode = NULL;
1113   } else {
1114     /*
1115      * We have a filter; make a copy of it (as we'll be saving it),
1116      * and try to compile it.
1117      */
1118     dftext = g_strdup(dftext);
1119     if (!dfilter_compile(dftext, &dfcode)) {
1120       /* The attempt failed; report an error. */
1121       gchar *safe_dftext = simple_dialog_format_message(dftext);
1122       gchar *safe_dfilter_error_msg = simple_dialog_format_message(
1123           dfilter_error_msg);
1124       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, 
1125           "%s%s%s\n"
1126           "\n"
1127           "The following display filter isn't a valid display filter:\n%s\n"
1128           "See the help for a description of the display filter syntax.",
1129           simple_dialog_primary_start(), safe_dfilter_error_msg,
1130           simple_dialog_primary_end(), safe_dftext);
1131       g_free(safe_dfilter_error_msg);
1132       g_free(safe_dftext);
1133       g_free(dftext);
1134       return CF_ERROR;
1135     }
1136
1137     /* Was it empty? */
1138     if (dfcode == NULL) {
1139       /* Yes - free the filter text, and set it to null. */
1140       g_free(dftext);
1141       dftext = NULL;
1142     }
1143   }
1144
1145   /* We have a valid filter.  Replace the current filter. */
1146   if (cf->dfilter != NULL)
1147     g_free(cf->dfilter);
1148   cf->dfilter = dftext;
1149   if (cf->dfcode != NULL)
1150     dfilter_free(cf->dfcode);
1151   cf->dfcode = dfcode;
1152
1153   /* Now rescan the packet list, applying the new filter, but not
1154      throwing away information constructed on a previous pass. */
1155   if (dftext == NULL) {
1156     rescan_packets(cf, "Resetting", "Filter", TRUE, FALSE);
1157   } else {
1158     rescan_packets(cf, "Filtering", dftext, TRUE, FALSE);
1159   }
1160   return CF_OK;
1161 }
1162
1163 void
1164 cf_colorize_packets(capture_file *cf)
1165 {
1166   rescan_packets(cf, "Colorizing", "all packets", FALSE, FALSE);
1167 }
1168
1169 void
1170 cf_reftime_packets(capture_file *cf)
1171 {
1172   rescan_packets(cf, "Updating Reftime", "all packets", FALSE, FALSE);
1173 }
1174
1175 void
1176 cf_redissect_packets(capture_file *cf)
1177 {
1178   rescan_packets(cf, "Reprocessing", "all packets", TRUE, TRUE);
1179 }
1180
1181 /* Rescan the list of packets, reconstructing the CList.
1182
1183    "action" describes why we're doing this; it's used in the progress
1184    dialog box.
1185
1186    "action_item" describes what we're doing; it's used in the progress
1187    dialog box.
1188
1189    "refilter" is TRUE if we need to re-evaluate the filter expression.
1190
1191    "redissect" is TRUE if we need to make the dissectors reconstruct
1192    any state information they have (because a preference that affects
1193    some dissector has changed, meaning some dissector might construct
1194    its state differently from the way it was constructed the last time). */
1195 static void
1196 rescan_packets(capture_file *cf, const char *action, const char *action_item,
1197                 gboolean refilter, gboolean redissect)
1198 {
1199   frame_data *fdata;
1200   progdlg_t  *progbar = NULL;
1201   gboolean    stop_flag;
1202   int         count;
1203   int         err;
1204   gchar      *err_info;
1205   frame_data *selected_frame, *preceding_frame, *following_frame, *prev_frame;
1206   int         selected_row, prev_row, preceding_row, following_row;
1207   gboolean    selected_frame_seen;
1208   int         row;
1209   float       prog_val;
1210   GTimeVal    start_time;
1211   gchar       status_str[100];
1212   int         progbar_nextstep;
1213   int         progbar_quantum;
1214
1215   cum_bytes=0;
1216   reset_tap_listeners();
1217   /* Which frame, if any, is the currently selected frame?
1218      XXX - should the selected frame or the focus frame be the "current"
1219      frame, that frame being the one from which "Find Frame" searches
1220      start? */
1221   selected_frame = cf->current_frame;
1222
1223   /* We don't yet know what row that frame will be on, if any, after we
1224      rebuild the clist, however. */
1225   selected_row = -1;
1226
1227   if (redissect) {
1228     /* We need to re-initialize all the state information that protocols
1229        keep, because some preference that controls a dissector has changed,
1230        which might cause the state information to be constructed differently
1231        by that dissector. */
1232
1233     /* Initialize all data structures used for dissection. */
1234     init_dissection();
1235   }
1236
1237   /* Freeze the packet list while we redo it, so we don't get any
1238      screen updates while it happens. */
1239   packet_list_freeze();
1240
1241   /* Clear it out. */
1242   packet_list_clear();
1243
1244   /* We don't yet know which will be the first and last frames displayed. */
1245   cf->first_displayed = NULL;
1246   cf->last_displayed = NULL;
1247
1248   /* We currently don't display any packets */
1249   cf->displayed_count = 0;
1250
1251   /* Iterate through the list of frames.  Call a routine for each frame
1252      to check whether it should be displayed and, if so, add it to
1253      the display list. */
1254   firstsec = 0;
1255   firstusec = 0;
1256   prevsec = 0;
1257   prevusec = 0;
1258
1259   /* Update the progress bar when it gets to this value. */
1260   progbar_nextstep = 0;
1261   /* When we reach the value that triggers a progress bar update,
1262      bump that value by this amount. */
1263   progbar_quantum = cf->count/N_PROGBAR_UPDATES;
1264   /* Count of packets at which we've looked. */
1265   count = 0;
1266
1267   stop_flag = FALSE;
1268   g_get_current_time(&start_time);
1269
1270   row = -1;             /* no previous row yet */
1271   prev_row = -1;
1272   prev_frame = NULL;
1273
1274   preceding_row = -1;
1275   preceding_frame = NULL;
1276   following_row = -1;
1277   following_frame = NULL;
1278
1279   selected_frame_seen = FALSE;
1280
1281   for (fdata = cf->plist; fdata != NULL; fdata = fdata->next) {
1282     /* Update the progress bar, but do it only N_PROGBAR_UPDATES times;
1283        when we update it, we have to run the GTK+ main loop to get it
1284        to repaint what's pending, and doing so may involve an "ioctl()"
1285        to see if there's any pending input from an X server, and doing
1286        that for every packet can be costly, especially on a big file. */
1287     if (count >= progbar_nextstep) {
1288       /* let's not divide by zero. I should never be started
1289        * with count == 0, so let's assert that
1290        */
1291       g_assert(cf->count > 0);
1292       prog_val = (gfloat) count / cf->count;
1293
1294       if (progbar == NULL)
1295         /* Create the progress bar if necessary */
1296         progbar = delayed_create_progress_dlg(action, action_item, &stop_flag,
1297           &start_time, prog_val);
1298
1299       if (progbar != NULL) {
1300         g_snprintf(status_str, sizeof(status_str),
1301                   "%4u of %u frames", count, cf->count);
1302         update_progress_dlg(progbar, prog_val, status_str);
1303       }
1304
1305       progbar_nextstep += progbar_quantum;
1306     }
1307
1308     if (stop_flag) {
1309       /* Well, the user decided to abort the filtering.  Just stop.
1310
1311          XXX - go back to the previous filter?  Users probably just
1312          want not to wait for a filtering operation to finish;
1313          unless we cancel by having no filter, reverting to the
1314          previous filter will probably be even more expensive than
1315          continuing the filtering, as it involves going back to the
1316          beginning and filtering, and even with no filter we currently
1317          have to re-generate the entire clist, which is also expensive.
1318
1319          I'm not sure what Network Monitor does, but it doesn't appear
1320          to give you an unfiltered display if you cancel. */
1321       break;
1322     }
1323
1324     count++;
1325
1326     if (redissect) {
1327       /* Since all state for the frame was destroyed, mark the frame
1328        * as not visited, free the GSList referring to the state
1329        * data (the per-frame data itself was freed by
1330        * "init_dissection()"), and null out the GSList pointer. */
1331       fdata->flags.visited = 0;
1332       if (fdata->pfd) {
1333         g_slist_free(fdata->pfd);
1334         fdata->pfd = NULL;
1335       }
1336     }
1337
1338     if (!wtap_seek_read (cf->wth, fdata->file_off, &cf->pseudo_header,
1339         cf->pd, fdata->cap_len, &err, &err_info)) {
1340         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
1341                       cf_read_error_message(err, err_info), cf->filename);
1342         break;
1343     }
1344
1345     /* If the previous frame is displayed, and we haven't yet seen the
1346        selected frame, remember that frame - it's the closest one we've
1347        yet seen before the selected frame. */
1348     if (prev_row != -1 && !selected_frame_seen) {
1349       preceding_row = prev_row;
1350       preceding_frame = prev_frame;
1351     }
1352     row = add_packet_to_packet_list(fdata, cf, &cf->pseudo_header, cf->pd,
1353                                         refilter);
1354
1355     /* If this frame is displayed, and this is the first frame we've
1356        seen displayed after the selected frame, remember this frame -
1357        it's the closest one we've yet seen at or after the selected
1358        frame. */
1359     if (row != -1 && selected_frame_seen && following_row == -1) {
1360       following_row = row;
1361       following_frame = fdata;
1362     }
1363     if (fdata == selected_frame) {
1364       selected_row = row;
1365       selected_frame_seen = TRUE;
1366     }
1367
1368     /* Remember this row/frame - it'll be the previous row/frame
1369        on the next pass through the loop. */
1370     prev_row = row;
1371     prev_frame = fdata;
1372   }
1373
1374   if (redissect) {
1375     /* Clear out what remains of the visited flags and per-frame data
1376        pointers.
1377
1378        XXX - that may cause various forms of bogosity when dissecting
1379        these frames, as they won't have been seen by this sequential
1380        pass, but the only alternative I see is to keep scanning them
1381        even though the user requested that the scan stop, and that
1382        would leave the user stuck with an Ethereal grinding on
1383        until it finishes.  Should we just stick them with that? */
1384     for (; fdata != NULL; fdata = fdata->next) {
1385       fdata->flags.visited = 0;
1386       if (fdata->pfd) {
1387         g_slist_free(fdata->pfd);
1388         fdata->pfd = NULL;
1389       }
1390     }
1391   }
1392
1393   /* We're done filtering the packets; destroy the progress bar if it
1394      was created. */
1395   if (progbar != NULL)
1396     destroy_progress_dlg(progbar);
1397
1398   /* Unfreeze the packet list. */
1399   packet_list_thaw();
1400
1401   if (selected_row == -1) {
1402     /* The selected frame didn't pass the filter. */
1403     if (selected_frame == NULL) {
1404       /* That's because there *was* no selected frame.  Make the first
1405          displayed frame the current frame. */
1406       selected_row = 0;
1407     } else {
1408       /* Find the nearest displayed frame to the selected frame (whether
1409          it's before or after that frame) and make that the current frame.
1410          If the next and previous displayed frames are equidistant from the
1411          selected frame, choose the next one. */
1412       g_assert(following_frame == NULL ||
1413                following_frame->num >= selected_frame->num);
1414       g_assert(preceding_frame == NULL ||
1415                preceding_frame->num <= selected_frame->num);
1416       if (following_frame == NULL) {
1417         /* No frame after the selected frame passed the filter, so we
1418            have to select the last displayed frame before the selected
1419            frame. */
1420         selected_row = preceding_row;
1421       } else if (preceding_frame == NULL) {
1422         /* No frame before the selected frame passed the filter, so we
1423            have to select the first displayed frame after the selected
1424            frame. */
1425         selected_row = following_row;
1426       } else {
1427         /* Choose the closer of the last displayed frame before the
1428            selected frame and the first displayed frame after the
1429            selected frame; in case of a tie, choose the first displayed
1430            frame after the selected frame. */
1431         if (following_frame->num - selected_frame->num <=
1432             selected_frame->num - preceding_frame->num) {
1433           selected_row = following_row;
1434         } else {
1435           /* The previous frame is closer to the selected frame than the
1436              next frame. */
1437           selected_row = preceding_row;
1438         }
1439       }
1440     }
1441   }
1442
1443   if (selected_row == -1) {
1444     /* There are no frames displayed at all. */
1445     cf_unselect_packet(cf);
1446   } else {
1447     /* Either the frame that was selected passed the filter, or we've
1448        found the nearest displayed frame to that frame.  Select it, make
1449        it the focus row, and make it visible. */
1450     packet_list_set_selected_row(selected_row);
1451   }
1452 }
1453
1454 typedef enum {
1455   PSP_FINISHED,
1456   PSP_STOPPED,
1457   PSP_FAILED
1458 } psp_return_t;
1459
1460 static psp_return_t
1461 process_specified_packets(capture_file *cf, packet_range_t *range,
1462     const char *string1, const char *string2,
1463     gboolean (*callback)(capture_file *, frame_data *,
1464                          union wtap_pseudo_header *, const guint8 *, void *),
1465     void *callback_args)
1466 {
1467   frame_data *fdata;
1468   int         err;
1469   gchar      *err_info;
1470   union wtap_pseudo_header pseudo_header;
1471   guint8      pd[WTAP_MAX_PACKET_SIZE+1];
1472   psp_return_t ret = PSP_FINISHED;
1473
1474   progdlg_t  *progbar = NULL;
1475   int         progbar_count;
1476   float       progbar_val;
1477   gboolean    progbar_stop_flag;
1478   GTimeVal    progbar_start_time;
1479   gchar       progbar_status_str[100];
1480   int         progbar_nextstep;
1481   int         progbar_quantum;
1482   range_process_e process_this;
1483
1484   /* Update the progress bar when it gets to this value. */
1485   progbar_nextstep = 0;
1486   /* When we reach the value that triggers a progress bar update,
1487      bump that value by this amount. */
1488   progbar_quantum = cf->count/N_PROGBAR_UPDATES;
1489   /* Count of packets at which we've looked. */
1490   progbar_count = 0;
1491
1492   progbar_stop_flag = FALSE;
1493   g_get_current_time(&progbar_start_time);
1494
1495   packet_range_process_init(range);
1496
1497   /* Iterate through the list of packets, printing the packets that
1498      were selected by the current display filter.  */
1499   for (fdata = cf->plist; fdata != NULL; fdata = fdata->next) {
1500     /* Update the progress bar, but do it only N_PROGBAR_UPDATES times;
1501        when we update it, we have to run the GTK+ main loop to get it
1502        to repaint what's pending, and doing so may involve an "ioctl()"
1503        to see if there's any pending input from an X server, and doing
1504        that for every packet can be costly, especially on a big file. */
1505     if (progbar_count >= progbar_nextstep) {
1506       /* let's not divide by zero. I should never be started
1507        * with count == 0, so let's assert that
1508        */
1509       g_assert(cf->count > 0);
1510       progbar_val = (gfloat) progbar_count / cf->count;
1511
1512       if (progbar == NULL)
1513         /* Create the progress bar if necessary */
1514         progbar = delayed_create_progress_dlg(string1, string2,
1515                                               &progbar_stop_flag,
1516                                               &progbar_start_time,
1517                                               progbar_val);
1518
1519       if (progbar != NULL) {
1520         g_snprintf(progbar_status_str, sizeof(progbar_status_str),
1521                    "%4u of %u packets", progbar_count, cf->count);
1522         update_progress_dlg(progbar, progbar_val, progbar_status_str);
1523       }
1524
1525       progbar_nextstep += progbar_quantum;
1526     }
1527
1528     if (progbar_stop_flag) {
1529       /* Well, the user decided to abort the operation.  Just stop,
1530          and arrange to return TRUE to our caller, so they know it
1531          was stopped explicitly. */
1532       ret = PSP_STOPPED;
1533       break;
1534     }
1535
1536     progbar_count++;
1537
1538     /* do we have to process this packet? */
1539     process_this = packet_range_process_packet(range, fdata);
1540     if (process_this == range_process_next) {
1541         /* this packet uninteresting, continue with next one */
1542         continue;
1543     } else if (process_this == range_processing_finished) {
1544         /* all interesting packets processed, stop the loop */
1545         break;
1546     }
1547
1548     /* Get the packet */
1549     if (!wtap_seek_read(cf->wth, fdata->file_off, &pseudo_header,
1550                         pd, fdata->cap_len, &err, &err_info)) {
1551       /* Attempt to get the packet failed. */
1552       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
1553                     cf_read_error_message(err, err_info), cf->filename);
1554       ret = PSP_FAILED;
1555       break;
1556     }
1557     /* Process the packet */
1558     if (!callback(cf, fdata, &pseudo_header, pd, callback_args)) {
1559       /* Callback failed.  We assume it reported the error appropriately. */
1560       ret = PSP_FAILED;
1561       break;
1562     }
1563   }
1564
1565   /* We're done printing the packets; destroy the progress bar if
1566      it was created. */
1567   if (progbar != NULL)
1568     destroy_progress_dlg(progbar);
1569
1570   return ret;
1571 }
1572
1573 static gboolean
1574 retap_packet(capture_file *cf _U_, frame_data *fdata,
1575              union wtap_pseudo_header *pseudo_header, const guint8 *pd,
1576              void *argsp _U_)
1577 {
1578   epan_dissect_t *edt;
1579
1580   /* If we have tap listeners, allocate a protocol tree root node, so that
1581      we'll construct a protocol tree against which a filter expression can
1582      be evaluated. */
1583   edt = epan_dissect_new(num_tap_filters != 0, FALSE);
1584   tap_queue_init(edt);
1585   epan_dissect_run(edt, pseudo_header, pd, fdata, NULL);
1586   tap_push_tapped_queue(edt);
1587   epan_dissect_free(edt);
1588
1589   return TRUE;
1590 }
1591
1592 cf_read_status_t
1593 cf_retap_packets(capture_file *cf)
1594 {
1595   packet_range_t range;
1596
1597   /* Reset the tap listeners. */
1598   reset_tap_listeners();
1599
1600   /* Iterate through the list of packets, dissecting all packets and
1601      re-running the taps. */
1602   packet_range_init(&range);
1603   packet_range_process_init(&range);
1604   switch (process_specified_packets(cf, &range, "Refiltering statistics on",
1605                                     "all packets", retap_packet,
1606                                     NULL)) {
1607   case PSP_FINISHED:
1608     /* Completed successfully. */
1609     return CF_OK;
1610
1611   case PSP_STOPPED:
1612     /* Well, the user decided to abort the refiltering.
1613        Return CF_READ_ABORTED so our caller knows they did that. */
1614     return CF_READ_ABORTED;
1615
1616   case PSP_FAILED:
1617     /* Error while retapping. */
1618     return CF_READ_ERROR;
1619   }
1620
1621   g_assert_not_reached();
1622   return CF_READ_OK;
1623 }
1624
1625 typedef struct {
1626   print_args_t *print_args;
1627   gboolean      print_header_line;
1628   char         *header_line_buf;
1629   int           header_line_buf_len;
1630   gboolean      print_formfeed;
1631   gboolean      print_separator;
1632   char         *line_buf;
1633   int           line_buf_len;
1634   gint         *col_widths;
1635 } print_callback_args_t;
1636
1637 static gboolean
1638 print_packet(capture_file *cf, frame_data *fdata,
1639              union wtap_pseudo_header *pseudo_header, const guint8 *pd,
1640              void *argsp)
1641 {
1642   print_callback_args_t *args = argsp;
1643   epan_dissect_t *edt;
1644   int             i;
1645   char           *cp;
1646   int             line_len;
1647   int             column_len;
1648   int             cp_off;
1649   gboolean        proto_tree_needed;
1650   char            bookmark_name[9+10+1];        /* "__frameNNNNNNNNNN__\0" */
1651   char            bookmark_title[6+10+1];       /* "Frame NNNNNNNNNN__\0" */
1652
1653   /* Create the protocol tree, and make it visible, if we're printing
1654      the dissection or the hex data.
1655      XXX - do we need it if we're just printing the hex data? */
1656   proto_tree_needed = 
1657       args->print_args->print_dissections != print_dissections_none || args->print_args->print_hex;
1658   edt = epan_dissect_new(proto_tree_needed, proto_tree_needed);
1659
1660   /* Fill in the column information if we're printing the summary
1661      information. */
1662   if (args->print_args->print_summary) {
1663     epan_dissect_run(edt, pseudo_header, pd, fdata, &cf->cinfo);
1664     epan_dissect_fill_in_columns(edt);
1665   } else
1666     epan_dissect_run(edt, pseudo_header, pd, fdata, NULL);
1667
1668   if (args->print_formfeed) {
1669     if (!new_page(args->print_args->stream))
1670       goto fail;
1671   } else {
1672       if (args->print_separator) {
1673         if (!print_line(args->print_args->stream, 0, ""))
1674           goto fail;
1675       }
1676   }
1677
1678   /*
1679    * We generate bookmarks, if the output format supports them.
1680    * The name is "__frameN__".
1681    */
1682   g_snprintf(bookmark_name, sizeof bookmark_name, "__frame%u__", fdata->num);
1683
1684   if (args->print_args->print_summary) {
1685     if (args->print_header_line) {
1686       if (!print_line(args->print_args->stream, 0, args->header_line_buf))
1687         goto fail;
1688       args->print_header_line = FALSE;  /* we might not need to print any more */
1689     }
1690     cp = &args->line_buf[0];
1691     line_len = 0;
1692     for (i = 0; i < cf->cinfo.num_cols; i++) {
1693       /* Find the length of the string for this column. */
1694       column_len = strlen(cf->cinfo.col_data[i]);
1695       if (args->col_widths[i] > column_len)
1696          column_len = args->col_widths[i];
1697
1698       /* Make sure there's room in the line buffer for the column; if not,
1699          double its length. */
1700       line_len += column_len + 1;       /* "+1" for space */
1701       if (line_len > args->line_buf_len) {
1702         cp_off = cp - args->line_buf;
1703         args->line_buf_len = 2 * line_len;
1704         args->line_buf = g_realloc(args->line_buf, args->line_buf_len + 1);
1705         cp = args->line_buf + cp_off;
1706       }
1707
1708       /* Right-justify the packet number column. */
1709       if (cf->cinfo.col_fmt[i] == COL_NUMBER)
1710         sprintf(cp, "%*s", args->col_widths[i], cf->cinfo.col_data[i]);
1711       else
1712         sprintf(cp, "%-*s", args->col_widths[i], cf->cinfo.col_data[i]);
1713       cp += column_len;
1714       if (i != cf->cinfo.num_cols - 1)
1715         *cp++ = ' ';
1716     }
1717     *cp = '\0';
1718
1719     /*
1720      * Generate a bookmark, using the summary line as the title.
1721      */
1722     if (!print_bookmark(args->print_args->stream, bookmark_name,
1723                         args->line_buf))
1724       goto fail;
1725
1726     if (!print_line(args->print_args->stream, 0, args->line_buf))
1727       goto fail;
1728   } else {
1729     /*
1730      * Generate a bookmark, using "Frame N" as the title, as we're not
1731      * printing the summary line.
1732      */
1733     g_snprintf(bookmark_title, sizeof bookmark_title, "Frame %u", fdata->num);
1734     if (!print_bookmark(args->print_args->stream, bookmark_name,
1735                         bookmark_title))
1736       goto fail;
1737   } /* if (print_summary) */
1738
1739   if (args->print_args->print_dissections != print_dissections_none) {
1740     if (args->print_args->print_summary) {
1741       /* Separate the summary line from the tree with a blank line. */
1742       if (!print_line(args->print_args->stream, 0, ""))
1743         goto fail;
1744     }
1745
1746     /* Print the information in that tree. */
1747     if (!proto_tree_print(args->print_args, edt, args->print_args->stream))
1748       goto fail;
1749
1750     /* Print a blank line if we print anything after this (aka more than one packet). */
1751     args->print_separator = TRUE;
1752
1753     /* Print a header line if we print any more packet summaries */
1754     args->print_header_line = TRUE;
1755   }
1756
1757   if (args->print_args->print_hex) {
1758     /* Print the full packet data as hex. */
1759     if (!print_hex_data(args->print_args->stream, edt))
1760       goto fail;
1761
1762     /* Print a blank line if we print anything after this (aka more than one packet). */
1763     args->print_separator = TRUE;
1764
1765     /* Print a header line if we print any more packet summaries */
1766     args->print_header_line = TRUE;
1767   } /* if (args->print_args->print_dissections != print_dissections_none) */
1768
1769   epan_dissect_free(edt);
1770
1771   /* do we want to have a formfeed between each packet from now on? */
1772   if(args->print_args->print_formfeed) {
1773     args->print_formfeed = TRUE;
1774   }
1775
1776   return TRUE;
1777
1778 fail:
1779   epan_dissect_free(edt);
1780   return FALSE;
1781 }
1782
1783 cf_print_status_t
1784 cf_print_packets(capture_file *cf, print_args_t *print_args)
1785 {
1786   int         i;
1787   print_callback_args_t callback_args;
1788   gint        data_width;
1789   char        *cp;
1790   int         cp_off;
1791   int         column_len;
1792   int         line_len;
1793   psp_return_t ret;
1794
1795   callback_args.print_args = print_args;
1796   callback_args.print_header_line = TRUE;
1797   callback_args.header_line_buf = NULL;
1798   callback_args.header_line_buf_len = 256;
1799   callback_args.print_formfeed = FALSE;
1800   callback_args.print_separator = FALSE;
1801   callback_args.line_buf = NULL;
1802   callback_args.line_buf_len = 256;
1803   callback_args.col_widths = NULL;
1804
1805   if (!print_preamble(print_args->stream, cf->filename)) {
1806     destroy_print_stream(print_args->stream);
1807     return CF_PRINT_WRITE_ERROR;
1808   }
1809
1810   if (print_args->print_summary) {
1811     /* We're printing packet summaries.  Allocate the header line buffer
1812        and get the column widths. */
1813     callback_args.header_line_buf = g_malloc(callback_args.header_line_buf_len + 1);
1814
1815     /* Find the widths for each of the columns - maximum of the
1816        width of the title and the width of the data - and construct
1817        a buffer with a line containing the column titles. */
1818     callback_args.col_widths = (gint *) g_malloc(sizeof(gint) * cf->cinfo.num_cols);
1819     cp = &callback_args.header_line_buf[0];
1820     line_len = 0;
1821     for (i = 0; i < cf->cinfo.num_cols; i++) {
1822       /* Don't pad the last column. */
1823       if (i == cf->cinfo.num_cols - 1)
1824         callback_args.col_widths[i] = 0;
1825       else {
1826         callback_args.col_widths[i] = strlen(cf->cinfo.col_title[i]);
1827         data_width = get_column_char_width(get_column_format(i));
1828         if (data_width > callback_args.col_widths[i])
1829           callback_args.col_widths[i] = data_width;
1830       }
1831
1832       /* Find the length of the string for this column. */
1833       column_len = strlen(cf->cinfo.col_title[i]);
1834       if (callback_args.col_widths[i] > column_len)
1835         column_len = callback_args.col_widths[i];
1836
1837       /* Make sure there's room in the line buffer for the column; if not,
1838          double its length. */
1839       line_len += column_len + 1;       /* "+1" for space */
1840       if (line_len > callback_args.header_line_buf_len) {
1841         cp_off = cp - callback_args.header_line_buf;
1842         callback_args.header_line_buf_len = 2 * line_len;
1843         callback_args.header_line_buf = g_realloc(callback_args.header_line_buf,
1844                                                   callback_args.header_line_buf_len + 1);
1845         cp = callback_args.header_line_buf + cp_off;
1846       }
1847
1848       /* Right-justify the packet number column. */
1849 /*      if (cf->cinfo.col_fmt[i] == COL_NUMBER)
1850         sprintf(cp, "%*s", callback_args.col_widths[i], cf->cinfo.col_title[i]);
1851       else*/
1852         sprintf(cp, "%-*s", callback_args.col_widths[i], cf->cinfo.col_title[i]);
1853       cp += column_len;
1854       if (i != cf->cinfo.num_cols - 1)
1855         *cp++ = ' ';
1856     }
1857     *cp = '\0';
1858
1859     /* Now start out the main line buffer with the same length as the
1860        header line buffer. */
1861     callback_args.line_buf_len = callback_args.header_line_buf_len;
1862     callback_args.line_buf = g_malloc(callback_args.line_buf_len + 1);
1863   } /* if (print_summary) */
1864
1865   /* Iterate through the list of packets, printing the packets we were
1866      told to print. */
1867   ret = process_specified_packets(cf, &print_args->range, "Printing",
1868                                   "selected packets", print_packet,
1869                                   &callback_args);
1870
1871   if (callback_args.header_line_buf != NULL)
1872     g_free(callback_args.header_line_buf);
1873   if (callback_args.line_buf != NULL)
1874     g_free(callback_args.line_buf);
1875   if (callback_args.col_widths != NULL)
1876     g_free(callback_args.col_widths);
1877
1878   switch (ret) {
1879
1880   case PSP_FINISHED:
1881     /* Completed successfully. */
1882     break;
1883
1884   case PSP_STOPPED:
1885     /* Well, the user decided to abort the printing.
1886
1887        XXX - note that what got generated before they did that
1888        will get printed if we're piping to a print program; we'd
1889        have to write to a file and then hand that to the print
1890        program to make it actually not print anything. */
1891     break;
1892
1893   case PSP_FAILED:
1894     /* Error while printing.
1895
1896        XXX - note that what got generated before they did that
1897        will get printed if we're piping to a print program; we'd
1898        have to write to a file and then hand that to the print
1899        program to make it actually not print anything. */
1900     destroy_print_stream(print_args->stream);
1901     return CF_PRINT_WRITE_ERROR;
1902   }
1903
1904   if (!print_finale(print_args->stream)) {
1905     destroy_print_stream(print_args->stream);
1906     return CF_PRINT_WRITE_ERROR;
1907   }
1908
1909   if (!destroy_print_stream(print_args->stream))
1910     return CF_PRINT_WRITE_ERROR;
1911
1912   return CF_PRINT_OK;
1913 }
1914
1915 static gboolean
1916 write_pdml_packet(capture_file *cf _U_, frame_data *fdata,
1917                   union wtap_pseudo_header *pseudo_header, const guint8 *pd,
1918                   void *argsp)
1919 {
1920   FILE *fh = argsp;
1921   epan_dissect_t *edt;
1922
1923   /* Create the protocol tree, but don't fill in the column information. */
1924   edt = epan_dissect_new(TRUE, TRUE);
1925   epan_dissect_run(edt, pseudo_header, pd, fdata, NULL);
1926
1927   /* Write out the information in that tree. */
1928   proto_tree_write_pdml(edt, fh);
1929
1930   epan_dissect_free(edt);
1931
1932   return !ferror(fh);
1933 }
1934
1935 cf_print_status_t
1936 cf_write_pdml_packets(capture_file *cf, print_args_t *print_args)
1937 {
1938   FILE        *fh;
1939   psp_return_t ret;
1940
1941   fh = fopen(print_args->file, "w");
1942   if (fh == NULL)
1943     return CF_PRINT_OPEN_ERROR; /* attempt to open destination failed */
1944
1945   write_pdml_preamble(fh);
1946   if (ferror(fh)) {
1947     fclose(fh);
1948     return CF_PRINT_WRITE_ERROR;
1949   }
1950
1951   /* Iterate through the list of packets, printing the packets we were
1952      told to print. */
1953   ret = process_specified_packets(cf, &print_args->range, "Writing PDML",
1954                                   "selected packets", write_pdml_packet,
1955                                   fh);
1956
1957   switch (ret) {
1958
1959   case PSP_FINISHED:
1960     /* Completed successfully. */
1961     break;
1962
1963   case PSP_STOPPED:
1964     /* Well, the user decided to abort the printing. */
1965     break;
1966
1967   case PSP_FAILED:
1968     /* Error while printing. */
1969     fclose(fh);
1970     return CF_PRINT_WRITE_ERROR;
1971   }
1972
1973   write_pdml_finale(fh);
1974   if (ferror(fh)) {
1975     fclose(fh);
1976     return CF_PRINT_WRITE_ERROR;
1977   }
1978
1979   /* XXX - check for an error */
1980   fclose(fh);
1981
1982   return CF_PRINT_OK;
1983 }
1984
1985 static gboolean
1986 write_psml_packet(capture_file *cf, frame_data *fdata,
1987                   union wtap_pseudo_header *pseudo_header, const guint8 *pd,
1988                   void *argsp)
1989 {
1990   FILE *fh = argsp;
1991   epan_dissect_t *edt;
1992
1993   /* Fill in the column information, but don't create the protocol tree. */
1994   edt = epan_dissect_new(FALSE, FALSE);
1995   epan_dissect_run(edt, pseudo_header, pd, fdata, &cf->cinfo);
1996   epan_dissect_fill_in_columns(edt);
1997
1998   /* Write out the information in that tree. */
1999   proto_tree_write_psml(edt, fh);
2000
2001   epan_dissect_free(edt);
2002
2003   return !ferror(fh);
2004 }
2005
2006 cf_print_status_t
2007 cf_write_psml_packets(capture_file *cf, print_args_t *print_args)
2008 {
2009   FILE        *fh;
2010   psp_return_t ret;
2011
2012   fh = fopen(print_args->file, "w");
2013   if (fh == NULL)
2014     return CF_PRINT_OPEN_ERROR; /* attempt to open destination failed */
2015
2016   write_psml_preamble(fh);
2017   if (ferror(fh)) {
2018     fclose(fh);
2019     return CF_PRINT_WRITE_ERROR;
2020   }
2021
2022   /* Iterate through the list of packets, printing the packets we were
2023      told to print. */
2024   ret = process_specified_packets(cf, &print_args->range, "Writing PSML",
2025                                   "selected packets", write_psml_packet,
2026                                   fh);
2027
2028   switch (ret) {
2029
2030   case PSP_FINISHED:
2031     /* Completed successfully. */
2032     break;
2033
2034   case PSP_STOPPED:
2035     /* Well, the user decided to abort the printing. */
2036     break;
2037
2038   case PSP_FAILED:
2039     /* Error while printing. */
2040     fclose(fh);
2041     return CF_PRINT_WRITE_ERROR;
2042   }
2043
2044   write_psml_finale(fh);
2045   if (ferror(fh)) {
2046     fclose(fh);
2047     return CF_PRINT_WRITE_ERROR;
2048   }
2049
2050   /* XXX - check for an error */
2051   fclose(fh);
2052
2053   return CF_PRINT_OK;
2054 }
2055
2056 static gboolean
2057 write_csv_packet(capture_file *cf, frame_data *fdata,
2058                  union wtap_pseudo_header *pseudo_header, const guint8 *pd,
2059                  void *argsp)
2060 {
2061   FILE *fh = argsp;
2062   epan_dissect_t *edt;
2063
2064   /* Fill in the column information, but don't create the protocol tree. */
2065   edt = epan_dissect_new(FALSE, FALSE);
2066   epan_dissect_run(edt, pseudo_header, pd, fdata, &cf->cinfo);
2067   epan_dissect_fill_in_columns(edt);
2068
2069   /* Write out the information in that tree. */
2070   proto_tree_write_csv(edt, fh);
2071
2072   epan_dissect_free(edt);
2073
2074   return !ferror(fh);
2075 }
2076
2077 cf_print_status_t
2078 cf_write_csv_packets(capture_file *cf, print_args_t *print_args)
2079 {
2080   FILE        *fh;
2081   psp_return_t ret;
2082
2083   fh = fopen(print_args->file, "w");
2084   if (fh == NULL)
2085     return CF_PRINT_OPEN_ERROR; /* attempt to open destination failed */
2086
2087   write_csv_preamble(fh);
2088   if (ferror(fh)) {
2089     fclose(fh);
2090     return CF_PRINT_WRITE_ERROR;
2091   }
2092
2093   /* Iterate through the list of packets, printing the packets we were
2094      told to print. */
2095   ret = process_specified_packets(cf, &print_args->range, "Writing CSV",
2096                                   "selected packets", write_csv_packet,
2097                                   fh);
2098
2099   switch (ret) {
2100
2101   case PSP_FINISHED:
2102     /* Completed successfully. */
2103     break;
2104
2105   case PSP_STOPPED:
2106     /* Well, the user decided to abort the printing. */
2107     break;
2108
2109   case PSP_FAILED:
2110     /* Error while printing. */
2111     fclose(fh);
2112     return CF_PRINT_WRITE_ERROR;
2113   }
2114
2115   write_csv_finale(fh);
2116   if (ferror(fh)) {
2117     fclose(fh);
2118     return CF_PRINT_WRITE_ERROR;
2119   }
2120
2121   /* XXX - check for an error */
2122   fclose(fh);
2123
2124   return CF_PRINT_OK;
2125 }
2126
2127 /* Scan through the packet list and change all columns that use the
2128    "command-line-specified" time stamp format to use the current
2129    value of that format. */
2130 void
2131 cf_change_time_formats(capture_file *cf)
2132 {
2133   frame_data *fdata;
2134   progdlg_t  *progbar = NULL;
2135   gboolean    stop_flag;
2136   int         count;
2137   int         row;
2138   int         i;
2139   float       prog_val;
2140   GTimeVal    start_time;
2141   gchar       status_str[100];
2142   int         progbar_nextstep;
2143   int         progbar_quantum;
2144   int         first, last;
2145   gboolean    sorted_by_frame_column;
2146
2147   /* Are there any columns with time stamps in the "command-line-specified"
2148      format?
2149
2150      XXX - we have to force the "column is writable" flag on, as it
2151      might be off from the last frame that was dissected. */
2152   col_set_writable(&cf->cinfo, TRUE);
2153   if (!check_col(&cf->cinfo, COL_CLS_TIME)) {
2154     /* No, there aren't any columns in that format, so we have no work
2155        to do. */
2156     return;
2157   }
2158   first = cf->cinfo.col_first[COL_CLS_TIME];
2159   g_assert(first >= 0);
2160   last = cf->cinfo.col_last[COL_CLS_TIME];
2161
2162   /* Freeze the packet list while we redo it, so we don't get any
2163      screen updates while it happens. */
2164   packet_list_freeze();
2165
2166   /* Update the progress bar when it gets to this value. */
2167   progbar_nextstep = 0;
2168   /* When we reach the value that triggers a progress bar update,
2169      bump that value by this amount. */
2170   progbar_quantum = cf->count/N_PROGBAR_UPDATES;
2171   /* Count of packets at which we've looked. */
2172   count = 0;
2173
2174   /*  If the rows are currently sorted by the frame column then we know
2175    *  the row number of each packet: it's the row number of the previously
2176    *  displayed packet + 1.
2177    *
2178    *  Otherwise, if the display is sorted by a different column then we have
2179    *  to use the O(N) packet_list_find_row_from_data() (thus making the job
2180    *  of changing the time display format O(N**2)).
2181    *
2182    *  (XXX - In fact it's still O(N**2) because gtk_clist_set_text() takes
2183    *  the row number and walks that many elements down the clist to find
2184    *  the appropriate element.)
2185    */
2186   sorted_by_frame_column = FALSE;
2187   for (i = 0; i < cf->cinfo.num_cols; i++) {
2188     if (cf->cinfo.col_fmt[i] == COL_NUMBER)
2189     {
2190       sorted_by_frame_column = (i == packet_list_get_sort_column());
2191       break;
2192     }
2193   }
2194
2195   stop_flag = FALSE;
2196   g_get_current_time(&start_time);
2197
2198   /* Iterate through the list of packets, checking whether the packet
2199      is in a row of the summary list and, if so, whether there are
2200      any columns that show the time in the "command-line-specified"
2201      format and, if so, update that row. */
2202   for (fdata = cf->plist, row = -1; fdata != NULL; fdata = fdata->next) {
2203     /* Update the progress bar, but do it only N_PROGBAR_UPDATES times;
2204        when we update it, we have to run the GTK+ main loop to get it
2205        to repaint what's pending, and doing so may involve an "ioctl()"
2206        to see if there's any pending input from an X server, and doing
2207        that for every packet can be costly, especially on a big file. */
2208     if (count >= progbar_nextstep) {
2209       /* let's not divide by zero. I should never be started
2210        * with count == 0, so let's assert that
2211        */
2212       g_assert(cf->count > 0);
2213
2214       prog_val = (gfloat) count / cf->count;
2215
2216       if (progbar == NULL)
2217         /* Create the progress bar if necessary */
2218         progbar = delayed_create_progress_dlg("Changing", "time display", 
2219           &stop_flag, &start_time, prog_val);
2220
2221       if (progbar != NULL) {
2222         g_snprintf(status_str, sizeof(status_str),
2223                    "%4u of %u packets", count, cf->count);
2224         update_progress_dlg(progbar, prog_val, status_str);
2225       }
2226
2227       progbar_nextstep += progbar_quantum;
2228     }
2229
2230     if (stop_flag) {
2231       /* Well, the user decided to abort the redisplay.  Just stop.
2232
2233          XXX - this leaves the time field in the old format in
2234          frames we haven't yet processed.  So it goes; should we
2235          simply not offer them the option of stopping? */
2236       break;
2237     }
2238
2239     count++;
2240
2241     /* Find what row this packet is in. */
2242     if (!sorted_by_frame_column) {
2243       /* This function is O(N), so we try to avoid using it... */
2244       row = packet_list_find_row_from_data(fdata);
2245     } else {
2246       /* ...which we do by maintaining a count of packets that are
2247          being displayed (i.e., that have passed the display filter),
2248          and using the current value of that count as the row number
2249          (which is why we can only do it when the display is sorted
2250          by the frame number). */
2251       if (fdata->flags.passed_dfilter)
2252         row++;
2253       else
2254         continue;
2255     }
2256
2257     if (row != -1) {
2258       /* This packet is in the summary list, on row "row". */
2259
2260       for (i = first; i <= last; i++) {
2261         if (cf->cinfo.fmt_matx[i][COL_CLS_TIME]) {
2262           /* This is one of the columns that shows the time in
2263              "command-line-specified" format; update it. */
2264           cf->cinfo.col_buf[i][0] = '\0';
2265           col_set_cls_time(fdata, &cf->cinfo, i);
2266           packet_list_set_text(row, i, cf->cinfo.col_data[i]);
2267         }
2268       }
2269     }
2270   }
2271
2272   /* We're done redisplaying the packets; destroy the progress bar if it
2273      was created. */
2274   if (progbar != NULL)
2275     destroy_progress_dlg(progbar);
2276
2277   /* Set the column widths of those columns that show the time in
2278      "command-line-specified" format. */
2279   for (i = first; i <= last; i++) {
2280     if (cf->cinfo.fmt_matx[i][COL_CLS_TIME]) {
2281       packet_list_set_cls_time_width(i);
2282     }
2283   }
2284
2285   /* Unfreeze the packet list. */
2286   packet_list_thaw();
2287 }
2288
2289 typedef struct {
2290         const char      *string;
2291         size_t          string_len;
2292         capture_file    *cf;
2293         gboolean        frame_matched;
2294 } match_data;
2295
2296 gboolean
2297 cf_find_packet_protocol_tree(capture_file *cf, const char *string)
2298 {
2299   match_data            mdata;
2300
2301   mdata.string = string;
2302   mdata.string_len = strlen(string);
2303   return find_packet(cf, match_protocol_tree, &mdata);
2304 }
2305
2306 static gboolean
2307 match_protocol_tree(capture_file *cf, frame_data *fdata, void *criterion)
2308 {
2309   match_data            *mdata = criterion;
2310   epan_dissect_t        *edt;
2311
2312   /* Construct the protocol tree, including the displayed text */
2313   edt = epan_dissect_new(TRUE, TRUE);
2314   /* We don't need the column information */
2315   epan_dissect_run(edt, &cf->pseudo_header, cf->pd, fdata, NULL);
2316
2317   /* Iterate through all the nodes, seeing if they have text that matches. */
2318   mdata->cf = cf;
2319   mdata->frame_matched = FALSE;
2320   proto_tree_children_foreach(edt->tree, match_subtree_text, mdata);
2321   epan_dissect_free(edt);
2322   return mdata->frame_matched;
2323 }
2324
2325 static void
2326 match_subtree_text(proto_node *node, gpointer data)
2327 {
2328   match_data    *mdata = (match_data*) data;
2329   const gchar   *string = mdata->string;
2330   size_t        string_len = mdata->string_len;
2331   capture_file  *cf = mdata->cf;
2332   field_info    *fi = PITEM_FINFO(node);
2333   gchar         label_str[ITEM_LABEL_LENGTH];
2334   gchar         *label_ptr;
2335   size_t        label_len;
2336   guint32       i;
2337   guint8        c_char;
2338   size_t        c_match = 0;
2339
2340   if (mdata->frame_matched) {
2341     /* We already had a match; don't bother doing any more work. */
2342     return;
2343   }
2344
2345   /* Don't match invisible entries. */
2346   if (PROTO_ITEM_IS_HIDDEN(node))
2347     return;
2348
2349   /* was a free format label produced? */
2350   if (fi->rep) {
2351     label_ptr = fi->rep->representation;
2352   } else {
2353     /* no, make a generic label */
2354     label_ptr = label_str;
2355     proto_item_fill_label(fi, label_str);
2356   }
2357     
2358   /* Does that label match? */
2359   label_len = strlen(label_ptr);
2360   for (i = 0; i < label_len; i++) {
2361     c_char = label_ptr[i];
2362     if (cf->case_type)
2363       c_char = toupper(c_char);
2364     if (c_char == string[c_match]) {
2365       c_match++;
2366       if (c_match == string_len) {
2367         /* No need to look further; we have a match */
2368         mdata->frame_matched = TRUE;
2369         return;
2370       }
2371     } else
2372       c_match = 0;
2373   }
2374   
2375   /* Recurse into the subtree, if it exists */
2376   if (node->first_child != NULL)
2377     proto_tree_children_foreach(node, match_subtree_text, mdata);
2378 }
2379
2380 gboolean
2381 cf_find_packet_summary_line(capture_file *cf, const char *string)
2382 {
2383   match_data            mdata;
2384
2385   mdata.string = string;
2386   mdata.string_len = strlen(string);
2387   return find_packet(cf, match_summary_line, &mdata);
2388 }
2389
2390 static gboolean
2391 match_summary_line(capture_file *cf, frame_data *fdata, void *criterion)
2392 {
2393   match_data            *mdata = criterion;
2394   const gchar           *string = mdata->string;
2395   size_t                string_len = mdata->string_len;
2396   epan_dissect_t        *edt;
2397   const char            *info_column;
2398   size_t                info_column_len;
2399   gboolean              frame_matched = FALSE;
2400   gint                  colx;
2401   guint32               i;
2402   guint8                c_char;
2403   size_t                c_match = 0;
2404
2405   /* Don't bother constructing the protocol tree */
2406   edt = epan_dissect_new(FALSE, FALSE);
2407   /* Get the column information */
2408   epan_dissect_run(edt, &cf->pseudo_header, cf->pd, fdata, &cf->cinfo);
2409
2410   /* Find the Info column */
2411   for (colx = 0; colx < cf->cinfo.num_cols; colx++) {
2412     if (cf->cinfo.fmt_matx[colx][COL_INFO]) {
2413       /* Found it.  See if we match. */
2414       info_column = edt->pi.cinfo->col_data[colx];
2415       info_column_len = strlen(info_column);
2416       for (i = 0; i < info_column_len; i++) {
2417         c_char = info_column[i];
2418         if (cf->case_type)
2419           c_char = toupper(c_char);
2420         if (c_char == string[c_match]) {
2421           c_match++;
2422           if (c_match == string_len) {
2423             frame_matched = TRUE;
2424             break;
2425           }
2426         } else
2427           c_match = 0;
2428       }
2429       break;
2430     }
2431   }
2432   epan_dissect_free(edt);
2433   return frame_matched;
2434 }
2435
2436 typedef struct {
2437         const guint8 *data;
2438         size_t data_len;
2439 } cbs_t;        /* "Counted byte string" */
2440
2441 gboolean
2442 cf_find_packet_data(capture_file *cf, const guint8 *string, size_t string_size)
2443 {
2444   cbs_t info;
2445
2446   info.data = string;
2447   info.data_len = string_size;
2448
2449   /* String or hex search? */
2450   if (cf->string) {
2451     /* String search - what type of string? */
2452     switch (cf->scs_type) {
2453
2454     case SCS_ASCII_AND_UNICODE:
2455       return find_packet(cf, match_ascii_and_unicode, &info);
2456
2457     case SCS_ASCII:
2458       return find_packet(cf, match_ascii, &info);
2459
2460     case SCS_UNICODE:
2461       return find_packet(cf, match_unicode, &info);
2462
2463     default:
2464       g_assert_not_reached();
2465       return FALSE;
2466     }
2467   } else
2468     return find_packet(cf, match_binary, &info);
2469 }
2470
2471 static gboolean
2472 match_ascii_and_unicode(capture_file *cf, frame_data *fdata, void *criterion)
2473 {
2474   cbs_t         *info = criterion;
2475   const char    *ascii_text = info->data;
2476   size_t        textlen = info->data_len;
2477   gboolean      frame_matched;
2478   guint32       buf_len;
2479   guint32       i;
2480   guint8        c_char;
2481   size_t        c_match = 0;
2482
2483   frame_matched = FALSE;
2484   buf_len = fdata->pkt_len;
2485   for (i = 0; i < buf_len; i++) {
2486     c_char = cf->pd[i];
2487     if (cf->case_type)
2488       c_char = toupper(c_char);
2489     if (c_char != 0) {
2490       if (c_char == ascii_text[c_match]) {
2491         c_match++;
2492         if (c_match == textlen) {
2493           frame_matched = TRUE;
2494           break;
2495         }
2496       } else
2497         c_match = 0;
2498     }
2499   }
2500   return frame_matched;
2501 }
2502
2503 static gboolean
2504 match_ascii(capture_file *cf, frame_data *fdata, void *criterion)
2505 {
2506   cbs_t         *info = criterion;
2507   const char    *ascii_text = info->data;
2508   size_t        textlen = info->data_len;
2509   gboolean      frame_matched;
2510   guint32       buf_len;
2511   guint32       i;
2512   guint8        c_char;
2513   size_t        c_match = 0;
2514
2515   frame_matched = FALSE;
2516   buf_len = fdata->pkt_len;
2517   for (i = 0; i < buf_len; i++) {
2518     c_char = cf->pd[i];
2519     if (cf->case_type)
2520       c_char = toupper(c_char);
2521     if (c_char == ascii_text[c_match]) {
2522       c_match++;
2523       if (c_match == textlen) {
2524         frame_matched = TRUE;
2525         break;
2526       }
2527     } else
2528       c_match = 0;
2529   }
2530   return frame_matched;
2531 }
2532
2533 static gboolean
2534 match_unicode(capture_file *cf, frame_data *fdata, void *criterion)
2535 {
2536   cbs_t         *info = criterion;
2537   const char    *ascii_text = info->data;
2538   size_t        textlen = info->data_len;
2539   gboolean      frame_matched;
2540   guint32       buf_len;
2541   guint32       i;
2542   guint8        c_char;
2543   size_t        c_match = 0;
2544
2545   frame_matched = FALSE;
2546   buf_len = fdata->pkt_len;
2547   for (i = 0; i < buf_len; i++) {
2548     c_char = cf->pd[i];
2549     if (cf->case_type)
2550       c_char = toupper(c_char);
2551     if (c_char == ascii_text[c_match]) {
2552       c_match++;
2553       i++;
2554       if (c_match == textlen) {
2555         frame_matched = TRUE;
2556         break;
2557       }
2558     } else
2559       c_match = 0;
2560   }
2561   return frame_matched;
2562 }
2563
2564 static gboolean
2565 match_binary(capture_file *cf, frame_data *fdata, void *criterion)
2566 {
2567   cbs_t         *info = criterion;
2568   const guint8  *binary_data = info->data;
2569   size_t        datalen = info->data_len;
2570   gboolean      frame_matched;
2571   guint32       buf_len;
2572   guint32       i;
2573   size_t        c_match = 0;
2574
2575   frame_matched = FALSE;
2576   buf_len = fdata->pkt_len;
2577   for (i = 0; i < buf_len; i++) {
2578     if (cf->pd[i] == binary_data[c_match]) {
2579       c_match++;
2580       if (c_match == datalen) {
2581         frame_matched = TRUE;
2582         break;
2583       }
2584     } else
2585       c_match = 0;
2586   }
2587   return frame_matched;
2588 }
2589
2590 gboolean
2591 cf_find_packet_dfilter(capture_file *cf, dfilter_t *sfcode)
2592 {
2593   return find_packet(cf, match_dfilter, sfcode);
2594 }
2595
2596 static gboolean
2597 match_dfilter(capture_file *cf, frame_data *fdata, void *criterion)
2598 {
2599   dfilter_t             *sfcode = criterion;
2600   epan_dissect_t        *edt;
2601   gboolean              frame_matched;
2602
2603   edt = epan_dissect_new(TRUE, FALSE);
2604   epan_dissect_prime_dfilter(edt, sfcode);
2605   epan_dissect_run(edt, &cf->pseudo_header, cf->pd, fdata, NULL);
2606   frame_matched = dfilter_apply_edt(sfcode, edt);
2607   epan_dissect_free(edt);
2608   return frame_matched;
2609 }
2610
2611 static gboolean
2612 find_packet(capture_file *cf,
2613             gboolean (*match_function)(capture_file *, frame_data *, void *),
2614             void *criterion)
2615 {
2616   frame_data *start_fd;
2617   frame_data *fdata;
2618   frame_data *new_fd = NULL;
2619   progdlg_t  *progbar = NULL;
2620   gboolean    stop_flag;
2621   int         count;
2622   int         err;
2623   gchar      *err_info;
2624   int         row;
2625   float       prog_val;
2626   GTimeVal    start_time;
2627   gchar       status_str[100];
2628   int         progbar_nextstep;
2629   int         progbar_quantum;
2630
2631   start_fd = cf->current_frame;
2632   if (start_fd != NULL)  {
2633     /* Iterate through the list of packets, starting at the packet we've
2634        picked, calling a routine to run the filter on the packet, see if
2635        it matches, and stop if so.  */
2636     count = 0;
2637     fdata = start_fd;
2638
2639     progbar_nextstep = 0;
2640     /* When we reach the value that triggers a progress bar update,
2641        bump that value by this amount. */
2642     progbar_quantum = cf->count/N_PROGBAR_UPDATES;
2643
2644     stop_flag = FALSE;
2645     g_get_current_time(&start_time);
2646
2647     fdata = start_fd;
2648     for (;;) {
2649       /* Update the progress bar, but do it only N_PROGBAR_UPDATES times;
2650          when we update it, we have to run the GTK+ main loop to get it
2651          to repaint what's pending, and doing so may involve an "ioctl()"
2652          to see if there's any pending input from an X server, and doing
2653          that for every packet can be costly, especially on a big file. */
2654       if (count >= progbar_nextstep) {
2655         /* let's not divide by zero. I should never be started
2656          * with count == 0, so let's assert that
2657          */
2658         g_assert(cf->count > 0);
2659
2660         prog_val = (gfloat) count / cf->count;
2661
2662         /* Create the progress bar if necessary */
2663         if (progbar == NULL)
2664            progbar = delayed_create_progress_dlg("Searching", cf->sfilter, 
2665              &stop_flag, &start_time, prog_val);
2666
2667         if (progbar != NULL) {
2668           g_snprintf(status_str, sizeof(status_str),
2669                      "%4u of %u packets", count, cf->count);
2670           update_progress_dlg(progbar, prog_val, status_str);
2671         }
2672
2673         progbar_nextstep += progbar_quantum;
2674       }
2675
2676       if (stop_flag) {
2677         /* Well, the user decided to abort the search.  Go back to the
2678            frame where we started. */
2679         new_fd = start_fd;
2680         break;
2681       }
2682
2683       /* Go past the current frame. */
2684       if (cf->sbackward) {
2685         /* Go on to the previous frame. */
2686         fdata = fdata->prev;
2687         if (fdata == NULL) {
2688           /*
2689            * XXX - other apps have a bit more of a detailed message
2690            * for this, and instead of offering "OK" and "Cancel",
2691            * they offer things such as "Continue" and "Cancel";
2692            * we need an API for popping up alert boxes with
2693            * {Verb} and "Cancel".
2694            */
2695
2696           if (prefs.gui_find_wrap)
2697           {
2698               simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
2699                             "%sBeginning of capture exceeded!%s\n\n"
2700                             "Search is continued from the end of the capture.",
2701                             simple_dialog_primary_start(), simple_dialog_primary_end());
2702               fdata = cf->plist_end;    /* wrap around */
2703           }
2704           else
2705           {
2706               simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
2707                             "%sBeginning of capture exceeded!%s\n\n"
2708                             "Try searching forwards.",
2709                             simple_dialog_primary_start(), simple_dialog_primary_end());
2710               fdata = start_fd;        /* stay on previous packet */
2711           }
2712         }
2713       } else {
2714         /* Go on to the next frame. */
2715         fdata = fdata->next;
2716         if (fdata == NULL) {
2717           if (prefs.gui_find_wrap)
2718           {
2719               simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
2720                             "%sEnd of capture exceeded!%s\n\n"
2721                             "Search is continued from the start of the capture.",
2722                             simple_dialog_primary_start(), simple_dialog_primary_end());
2723               fdata = cf->plist;        /* wrap around */
2724           }
2725           else
2726           {
2727               simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
2728                             "%sEnd of capture exceeded!%s\n\n"
2729                             "Try searching backwards.",
2730                             simple_dialog_primary_start(), simple_dialog_primary_end());
2731               fdata = start_fd;     /* stay on previous packet */
2732           }
2733         }
2734       }
2735
2736       count++;
2737
2738       /* Is this packet in the display? */
2739       if (fdata->flags.passed_dfilter) {
2740         /* Yes.  Load its data. */
2741         if (!wtap_seek_read(cf->wth, fdata->file_off, &cf->pseudo_header,
2742                         cf->pd, fdata->cap_len, &err, &err_info)) {
2743           /* Read error.  Report the error, and go back to the frame
2744              where we started. */
2745           simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
2746                         cf_read_error_message(err, err_info), cf->filename);
2747           new_fd = start_fd;
2748           break;
2749         }
2750
2751         /* Does it match the search criterion? */
2752         if ((*match_function)(cf, fdata, criterion)) {
2753           new_fd = fdata;
2754           break;        /* found it! */
2755         }
2756       }
2757
2758       if (fdata == start_fd) {
2759         /* We're back to the frame we were on originally, and that frame
2760            doesn't match the search filter.  The search failed. */
2761         break;
2762       }
2763     }
2764
2765     /* We're done scanning the packets; destroy the progress bar if it
2766        was created. */
2767     if (progbar != NULL)
2768       destroy_progress_dlg(progbar);
2769   }
2770
2771   if (new_fd != NULL) {
2772     /* We found a frame.  Find what row it's in. */
2773     row = packet_list_find_row_from_data(new_fd);
2774     g_assert(row != -1);
2775
2776     /* Select that row, make it the focus row, and make it visible. */
2777     packet_list_set_selected_row(row);
2778     return TRUE;        /* success */
2779   } else
2780     return FALSE;       /* failure */
2781 }
2782
2783 gboolean
2784 cf_goto_frame(capture_file *cf, guint fnumber)
2785 {
2786   frame_data *fdata;
2787   int row;
2788
2789   for (fdata = cf->plist; fdata != NULL && fdata->num < fnumber; fdata = fdata->next)
2790     ;
2791
2792   if (fdata == NULL) {
2793     /* we didn't find a packet with that packet number */
2794     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
2795                   "There is no packet with the packet number %u.", fnumber);
2796     return FALSE;       /* we failed to go to that packet */
2797   }
2798   if (!fdata->flags.passed_dfilter) {
2799     /* that packet currently isn't displayed */
2800     /* XXX - add it to the set of displayed packets? */
2801     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
2802                   "The packet number %u isn't currently being displayed.", fnumber);
2803     return FALSE;       /* we failed to go to that packet */
2804   }
2805
2806   /* We found that packet, and it's currently being displayed.
2807      Find what row it's in. */
2808   row = packet_list_find_row_from_data(fdata);
2809   g_assert(row != -1);
2810
2811   /* Select that row, make it the focus row, and make it visible. */
2812   packet_list_set_selected_row(row);
2813   return TRUE;  /* we got to that packet */
2814 }
2815
2816 gboolean
2817 cf_goto_top_frame(capture_file *cf)
2818 {
2819   frame_data *fdata;
2820   int row;
2821   frame_data *lowest_fdata = NULL;
2822
2823   for (fdata = cf->plist; fdata != NULL; fdata = fdata->next) {
2824     if (fdata->flags.passed_dfilter) {
2825         lowest_fdata = fdata;
2826         break;
2827     }
2828   }
2829
2830   if (lowest_fdata == NULL) {
2831       return FALSE;
2832   }
2833
2834   /* We found that packet, and it's currently being displayed.
2835      Find what row it's in. */
2836   row = packet_list_find_row_from_data(lowest_fdata);
2837   g_assert(row != -1);
2838
2839   /* Select that row, make it the focus row, and make it visible. */
2840   packet_list_set_selected_row(row);
2841   return TRUE;  /* we got to that packet */
2842 }
2843
2844 gboolean
2845 cf_goto_bottom_frame(capture_file *cf)
2846 {
2847   frame_data *fdata;
2848   int row;
2849   frame_data *highest_fdata = NULL;
2850
2851   for (fdata = cf->plist; fdata != NULL; fdata = fdata->next) {
2852     if (fdata->flags.passed_dfilter) {
2853         highest_fdata = fdata;
2854     }
2855   }
2856
2857   if (highest_fdata == NULL) {
2858       return FALSE;
2859   }
2860
2861   /* We found that packet, and it's currently being displayed.
2862      Find what row it's in. */
2863   row = packet_list_find_row_from_data(highest_fdata);
2864   g_assert(row != -1);
2865
2866   /* Select that row, make it the focus row, and make it visible. */
2867   packet_list_set_selected_row(row);
2868   return TRUE;  /* we got to that packet */
2869 }
2870
2871 /*
2872  * Go to frame specified by currently selected protocol tree item.
2873  */
2874 gboolean
2875 cf_goto_framenum(capture_file *cf)
2876 {
2877   header_field_info       *hfinfo;
2878   guint32                 framenum;
2879
2880   if (cf->finfo_selected) {
2881     hfinfo = cf->finfo_selected->hfinfo;
2882     g_assert(hfinfo);
2883     if (hfinfo->type == FT_FRAMENUM) {
2884       framenum = fvalue_get_integer(&cf->finfo_selected->value);
2885       if (framenum != 0)
2886         return cf_goto_frame(cf, framenum);
2887       }
2888   }
2889
2890   return FALSE;
2891 }
2892
2893 /* Select the packet on a given row. */
2894 void
2895 cf_select_packet(capture_file *cf, int row)
2896 {
2897   frame_data *fdata;
2898   int err;
2899   gchar *err_info;
2900
2901   /* Get the frame data struct pointer for this frame */
2902   fdata = (frame_data *)packet_list_get_row_data(row);
2903
2904   if (fdata == NULL) {
2905     /* XXX - if a GtkCList's selection mode is GTK_SELECTION_BROWSE, when
2906        the first entry is added to it by "real_insert_row()", that row
2907        is selected (see "real_insert_row()", in "gtk/gtkclist.c", in both
2908        our version and the vanilla GTK+ version).
2909
2910        This means that a "select-row" signal is emitted; this causes
2911        "packet_list_select_cb()" to be called, which causes "cf_select_packet()"
2912        to be called.
2913
2914        "cf_select_packet()" fetches, above, the data associated with the
2915        row that was selected; however, as "gtk_clist_append()", which
2916        called "real_insert_row()", hasn't yet returned, we haven't yet
2917        associated any data with that row, so we get back a null pointer.
2918
2919        We can't assume that there's only one frame in the frame list,
2920        either, as we may be filtering the display.
2921
2922        We therefore assume that, if "row" is 0, i.e. the first row
2923        is being selected, and "cf->first_displayed" equals
2924        "cf->last_displayed", i.e. there's only one frame being
2925        displayed, that frame is the frame we want.
2926
2927        This means we have to set "cf->first_displayed" and
2928        "cf->last_displayed" before adding the row to the
2929        GtkCList; see the comment in "add_packet_to_packet_list()". */
2930
2931        if (row == 0 && cf->first_displayed == cf->last_displayed)
2932          fdata = cf->first_displayed;
2933   }
2934
2935   /* Get the data in that frame. */
2936   if (!wtap_seek_read (cf->wth, fdata->file_off, &cf->pseudo_header,
2937                        cf->pd, fdata->cap_len, &err, &err_info)) {
2938     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
2939                   cf_read_error_message(err, err_info), cf->filename);
2940     return;
2941   }
2942
2943   /* Record that this frame is the current frame. */
2944   cf->current_frame = fdata;
2945
2946   /* Create the logical protocol tree. */
2947   if (cf->edt != NULL) {
2948     epan_dissect_free(cf->edt);
2949     cf->edt = NULL;
2950   }
2951   /* We don't need the columns here. */
2952   cf->edt = epan_dissect_new(TRUE, TRUE);
2953   epan_dissect_run(cf->edt, &cf->pseudo_header, cf->pd, cf->current_frame,
2954           NULL);
2955
2956   cf_callback_invoke(cf_cb_packet_selected, cf);
2957 }
2958
2959 /* Unselect the selected packet, if any. */
2960 void
2961 cf_unselect_packet(capture_file *cf)
2962 {
2963   /* Destroy the epan_dissect_t for the unselected packet. */
2964   if (cf->edt != NULL) {
2965     epan_dissect_free(cf->edt);
2966     cf->edt = NULL;
2967   }
2968
2969   /* No packet is selected. */
2970   cf->current_frame = NULL;
2971
2972   cf_callback_invoke(cf_cb_packet_unselected, cf);
2973
2974   /* No protocol tree means no selected field. */
2975   cf_unselect_field(cf);
2976 }
2977
2978 /* Unset the selected protocol tree field, if any. */
2979 void
2980 cf_unselect_field(capture_file *cf)
2981 {
2982   cf->finfo_selected = NULL;
2983
2984   cf_callback_invoke(cf_cb_field_unselected, cf);
2985 }
2986
2987 /*
2988  * Mark a particular frame.
2989  */
2990 void
2991 cf_mark_frame(capture_file *cf, frame_data *frame)
2992 {
2993   if (! frame->flags.marked) {
2994     frame->flags.marked = TRUE;
2995     if (cf->count > cf->marked_count)
2996       cf->marked_count++;
2997   }
2998 }
2999
3000 /*
3001  * Unmark a particular frame.
3002  */
3003 void
3004 cf_unmark_frame(capture_file *cf, frame_data *frame)
3005 {
3006   if (frame->flags.marked) {
3007     frame->flags.marked = FALSE;
3008     if (cf->marked_count > 0)
3009       cf->marked_count--;
3010   }
3011 }
3012
3013 typedef struct {
3014   wtap_dumper *pdh;
3015   const char  *fname;
3016 } save_callback_args_t;
3017
3018 /*
3019  * Save a capture to a file, in a particular format, saving either
3020  * all packets, all currently-displayed packets, or all marked packets.
3021  *
3022  * Returns TRUE if it succeeds, FALSE otherwise; if it fails, it pops
3023  * up a message box for the failure.
3024  */
3025 static gboolean
3026 save_packet(capture_file *cf _U_, frame_data *fdata,
3027             union wtap_pseudo_header *pseudo_header, const guint8 *pd,
3028             void *argsp)
3029 {
3030   save_callback_args_t *args = argsp;
3031   struct wtap_pkthdr hdr;
3032   int           err;
3033
3034   /* init the wtap header for saving */
3035   hdr.ts.tv_sec  = fdata->abs_secs;
3036   hdr.ts.tv_usec = fdata->abs_usecs;
3037   hdr.caplen     = fdata->cap_len;
3038   hdr.len        = fdata->pkt_len;
3039   hdr.pkt_encap  = fdata->lnk_t;
3040
3041   /* and save the packet */
3042   if (!wtap_dump(args->pdh, &hdr, pseudo_header, pd, &err)) {
3043     cf_write_failure_alert_box(args->fname, err);
3044     return FALSE;
3045   }
3046   return TRUE;
3047 }
3048
3049 cf_status_t
3050 cf_save(capture_file *cf, const char *fname, packet_range_t *range, guint save_format)
3051 {
3052   gchar        *from_filename;
3053   int           err;
3054   gboolean      do_copy;
3055   wtap_dumper  *pdh;
3056   save_callback_args_t callback_args;
3057
3058   cf_callback_invoke(cf_cb_file_safe_started, (gpointer) fname);
3059
3060   /* don't write over an existing file. */
3061   /* this should've been already checked by our caller, just to be sure... */
3062   if (file_exists(fname)) {
3063     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3064       "%sCapture file: \"%s\" already exists!%s\n\n"
3065       "Please choose a different filename.",
3066       simple_dialog_primary_start(), fname, simple_dialog_primary_end());
3067     goto fail;
3068   }
3069
3070   packet_range_process_init(range);
3071
3072   /* Used to be :
3073    * if (!save_filtered && !save_marked && !save_manual_range && 
3074    *     !save_marked_range && !save_curr && save_format == cf->cd_t) {
3075    */ 
3076         
3077   if (packet_range_process_all(range) && save_format == cf->cd_t) {
3078     /* We're not filtering packets, and we're saving it in the format
3079        it's already in, so we can just move or copy the raw data. */
3080
3081     if (cf->is_tempfile) {
3082       /* The file being saved is a temporary file from a live
3083          capture, so it doesn't need to stay around under that name;
3084          first, try renaming the capture buffer file to the new name. */
3085 #ifndef _WIN32
3086       if (rename(cf->filename, fname) == 0) {
3087         /* That succeeded - there's no need to copy the source file. */
3088         from_filename = NULL;
3089         do_copy = FALSE;
3090       } else {
3091         if (errno == EXDEV) {
3092           /* They're on different file systems, so we have to copy the
3093              file. */
3094           do_copy = TRUE;
3095           from_filename = cf->filename;
3096         } else {
3097           /* The rename failed, but not because they're on different
3098              file systems - put up an error message.  (Or should we
3099              just punt and try to copy?  The only reason why I'd
3100              expect the rename to fail and the copy to succeed would
3101              be if we didn't have permission to remove the file from
3102              the temporary directory, and that might be fixable - but
3103              is it worth requiring the user to go off and fix it?) */
3104           simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3105                                 file_rename_error_message(errno), fname);
3106           goto fail;
3107         }
3108       }
3109 #else
3110       do_copy = TRUE;
3111       from_filename = cf->filename;
3112 #endif
3113     } else {
3114       /* It's a permanent file, so we should copy it, and not remove the
3115          original. */
3116       do_copy = TRUE;
3117       from_filename = cf->filename;
3118     }
3119
3120     if (do_copy) {
3121       /* Copy the file, if we haven't moved it. */
3122       if (!copy_binary_file(from_filename, fname))
3123         goto fail;
3124     }
3125   } else {
3126     /* Either we're filtering packets, or we're saving in a different
3127        format; we can't do that by copying or moving the capture file,
3128        we have to do it by writing the packets out in Wiretap. */
3129     pdh = wtap_dump_open(fname, save_format, cf->lnk_t, cf->snap, &err);
3130     if (pdh == NULL) {
3131       cf_open_failure_alert_box(fname, err, NULL, TRUE, save_format);
3132       goto fail;
3133     }
3134
3135     /* XXX - we let the user save a subset of the packets.
3136
3137        If we do that, should we make that file the current file?  If so,
3138        it means we can no longer get at the other packets.  What does
3139        NetMon do? */
3140
3141     /* Iterate through the list of packets, processing the packets we were
3142        told to process.
3143
3144        XXX - we've already called "packet_range_process_init(range)", but
3145        "process_specified_packets()" will do it again.  Fortunately,
3146        that's harmless in this case, as we haven't done anything to
3147        "range" since we initialized it. */
3148     callback_args.pdh = pdh;
3149     callback_args.fname = fname;
3150     switch (process_specified_packets(cf, range, "Saving",
3151                                       "selected packets", save_packet,
3152                                       &callback_args)) {
3153
3154     case PSP_FINISHED:
3155       /* Completed successfully. */
3156       break;
3157
3158     case PSP_STOPPED:
3159       /* The user decided to abort the saving.
3160          XXX - remove the output file? */
3161       break;
3162
3163     case PSP_FAILED:
3164       /* Error while saving. */
3165       wtap_dump_close(pdh, &err);
3166       goto fail;
3167     }
3168
3169     if (!wtap_dump_close(pdh, &err)) {
3170       cf_close_failure_alert_box(fname, err);
3171       goto fail;
3172     }
3173   }
3174
3175   cf_callback_invoke(cf_cb_file_safe_finished, NULL);
3176
3177   if (packet_range_process_all(range)) {
3178     /* We saved the entire capture, not just some packets from it.
3179        Open and read the file we saved it to.
3180
3181        XXX - this is somewhat of a waste; we already have the
3182        packets, all this gets us is updated file type information
3183        (which we could just stuff into "cf"), and having the new
3184        file be the one we have opened and from which we're reading
3185        the data, and it means we have to spend time opening and
3186        reading the file, which could be a significant amount of
3187        time if the file is large. */
3188     cf->user_saved = TRUE;
3189
3190     if ((cf_open(cf, fname, FALSE, &err)) == CF_OK) {
3191       /* XXX - report errors if this fails?
3192          What should we return if it fails or is aborted? */
3193       switch (cf_read(cf)) {
3194
3195       case CF_READ_OK:
3196       case CF_READ_ERROR:
3197         /* Just because we got an error, that doesn't mean we were unable
3198            to read any of the file; we handle what we could get from the
3199            file. */
3200         break;
3201
3202       case CF_READ_ABORTED:
3203         /* The user bailed out of re-reading the capture file; the
3204            capture file has been closed - just return (without
3205            changing any menu settings; "cf_close()" set them
3206            correctly for the "no capture file open" state). */
3207         break;
3208       }
3209       cf_callback_invoke(cf_cb_file_safe_reload_finished, NULL);
3210     }
3211   }
3212   return CF_OK;
3213
3214 fail:
3215   cf_callback_invoke(cf_cb_file_safe_failed, NULL);
3216   return CF_ERROR;
3217 }
3218
3219 static void
3220 cf_open_failure_alert_box(const char *filename, int err, gchar *err_info,
3221                           gboolean for_writing, int file_type)
3222 {
3223   if (err < 0) {
3224     /* Wiretap error. */
3225     switch (err) {
3226
3227     case WTAP_ERR_NOT_REGULAR_FILE:
3228       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3229                     "The file \"%s\" is a \"special file\" or socket or other non-regular file.",
3230                     filename);
3231       break;
3232
3233     case WTAP_ERR_RANDOM_OPEN_PIPE:
3234       /* Seen only when opening a capture file for reading. */
3235       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3236                     "The file \"%s\" is a pipe or FIFO; Ethereal can't read pipe or FIFO files.",
3237                     filename);
3238       break;
3239
3240     case WTAP_ERR_FILE_UNKNOWN_FORMAT:
3241       /* Seen only when opening a capture file for reading. */
3242       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3243                     "The file \"%s\" isn't a capture file in a format Ethereal understands.",
3244                     filename);
3245       break;
3246
3247     case WTAP_ERR_UNSUPPORTED:
3248       /* Seen only when opening a capture file for reading. */
3249       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3250                     "The file \"%s\" isn't a capture file in a format Ethereal understands.\n"
3251                     "(%s)",
3252                     filename, err_info);
3253       g_free(err_info);
3254       break;
3255
3256     case WTAP_ERR_CANT_WRITE_TO_PIPE:
3257       /* Seen only when opening a capture file for writing. */
3258       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3259                     "The file \"%s\" is a pipe, and %s capture files can't be "
3260                     "written to a pipe.",
3261                     filename, wtap_file_type_string(file_type));
3262       break;
3263
3264     case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
3265       /* Seen only when opening a capture file for writing. */
3266       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3267                     "Ethereal doesn't support writing capture files in that format.");
3268       break;
3269
3270     case WTAP_ERR_UNSUPPORTED_ENCAP:
3271       if (for_writing) {
3272         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3273                       "Ethereal can't save this capture in that format.");
3274       } else {
3275         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3276                       "The file \"%s\" is a capture for a network type that Ethereal doesn't support.\n"
3277                       "(%s)",
3278                       filename, err_info);
3279         g_free(err_info);
3280       }
3281       break;
3282
3283     case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
3284       if (for_writing) {
3285         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3286                       "Ethereal can't save this capture in that format.");
3287       } else {
3288         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3289                       "The file \"%s\" is a capture for a network type that Ethereal doesn't support.",
3290                       filename);
3291       }
3292       break;
3293
3294     case WTAP_ERR_BAD_RECORD:
3295       /* Seen only when opening a capture file for reading. */
3296       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3297                     "The file \"%s\" appears to be damaged or corrupt.\n"
3298                     "(%s)",
3299                     filename, err_info);
3300       g_free(err_info);
3301       break;
3302
3303     case WTAP_ERR_CANT_OPEN:
3304       if (for_writing) {
3305         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3306                       "The file \"%s\" could not be created for some unknown reason.",
3307                       filename);
3308       } else {
3309         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3310                       "The file \"%s\" could not be opened for some unknown reason.",
3311                       filename);
3312       }
3313       break;
3314
3315     case WTAP_ERR_SHORT_READ:
3316       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3317                     "The file \"%s\" appears to have been cut short"
3318                     " in the middle of a packet or other data.",
3319                     filename);
3320       break;
3321
3322     case WTAP_ERR_SHORT_WRITE:
3323       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3324                     "A full header couldn't be written to the file \"%s\".",
3325                     filename);
3326       break;
3327
3328     default:
3329       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3330                     "The file \"%s\" could not be %s: %s.",
3331                     filename,
3332                     for_writing ? "created" : "opened",
3333                     wtap_strerror(err));
3334       break;
3335     }
3336   } else {
3337     /* OS error. */
3338     open_failure_alert_box(filename, err, for_writing);
3339   }
3340 }
3341
3342 static const char *
3343 file_rename_error_message(int err)
3344 {
3345   const char *errmsg;
3346   static char errmsg_errno[1024+1];
3347
3348   switch (err) {
3349
3350   case ENOENT:
3351     errmsg = "The path to the file \"%s\" doesn't exist.";
3352     break;
3353
3354   case EACCES:
3355     errmsg = "You don't have permission to move the capture file to \"%s\".";
3356     break;
3357
3358   default:
3359     g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3360                     "The file \"%%s\" could not be moved: %s.",
3361                                 wtap_strerror(err));
3362     errmsg = errmsg_errno;
3363     break;
3364   }
3365   return errmsg;
3366 }
3367
3368 char *
3369 cf_read_error_message(int err, const gchar *err_info)
3370 {
3371   static char errmsg_errno[1024+1];
3372
3373   switch (err) {
3374
3375   case WTAP_ERR_UNSUPPORTED_ENCAP:
3376       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3377                "The file \"%%s\" has a packet with a network type that Ethereal doesn't support.\n(%s)",
3378                err_info);
3379       break;
3380
3381   case WTAP_ERR_BAD_RECORD:
3382     g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3383              "An error occurred while reading from the file \"%%s\": %s.\n(%s)",
3384              wtap_strerror(err), err_info);
3385     break;
3386
3387   default:
3388     g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3389              "An error occurred while reading from the file \"%%s\": %s.",
3390              wtap_strerror(err));
3391     break;
3392   }
3393   return errmsg_errno;
3394 }
3395
3396 static void
3397 cf_write_failure_alert_box(const char *filename, int err)
3398 {
3399   if (err < 0) {
3400     /* Wiretap error. */
3401     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3402                   "An error occurred while writing to the file \"%s\": %s.",
3403                   filename, wtap_strerror(err));
3404   } else {
3405     /* OS error. */
3406     write_failure_alert_box(filename, err);
3407   }
3408 }
3409
3410 /* Check for write errors - if the file is being written to an NFS server,
3411    a write error may not show up until the file is closed, as NFS clients
3412    might not send writes to the server until the "write()" call finishes,
3413    so that the write may fail on the server but the "write()" may succeed. */
3414 static void
3415 cf_close_failure_alert_box(const char *filename, int err)
3416 {
3417   if (err < 0) {
3418     /* Wiretap error. */
3419     switch (err) {
3420
3421     case WTAP_ERR_CANT_CLOSE:
3422       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3423                     "The file \"%s\" couldn't be closed for some unknown reason.",
3424                     filename);
3425       break;
3426
3427     case WTAP_ERR_SHORT_WRITE:
3428       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3429                     "Not all the packets could be written to the file \"%s\".",
3430                     filename);
3431       break;
3432
3433     default:
3434       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3435                     "An error occurred while closing the file \"%s\": %s.",
3436                     filename, wtap_strerror(err));
3437       break;
3438     }
3439   } else {
3440     /* OS error.
3441        We assume that a close error from the OS is really a write error. */
3442     write_failure_alert_box(filename, err);
3443   }
3444 }
3445
3446 /* Reload the current capture file. */
3447 void
3448 cf_reload(capture_file *cf) {
3449   gchar *filename;
3450   gboolean is_tempfile;
3451   int err;
3452
3453   /* If the file could be opened, "cf_open()" calls "cf_close()"
3454      to get rid of state for the old capture file before filling in state
3455      for the new capture file.  "cf_close()" will remove the file if
3456      it's a temporary file; we don't want that to happen (for one thing,
3457      it'd prevent subsequent reopens from working).  Remember whether it's
3458      a temporary file, mark it as not being a temporary file, and then
3459      reopen it as the type of file it was.
3460
3461      Also, "cf_close()" will free "cf->filename", so we must make
3462      a copy of it first. */
3463   filename = g_strdup(cf->filename);
3464   is_tempfile = cf->is_tempfile;
3465   cf->is_tempfile = FALSE;
3466   if (cf_open(cf, filename, is_tempfile, &err) == CF_OK) {
3467     switch (cf_read(cf)) {
3468
3469     case CF_READ_OK:
3470     case CF_READ_ERROR:
3471       /* Just because we got an error, that doesn't mean we were unable
3472          to read any of the file; we handle what we could get from the
3473          file. */
3474       break;
3475
3476     case CF_READ_ABORTED:
3477       /* The user bailed out of re-reading the capture file; the
3478          capture file has been closed - just free the capture file name
3479          string and return (without changing the last containing
3480          directory). */
3481       g_free(filename);
3482       return;
3483     }
3484   } else {
3485     /* The open failed, so "cf->is_tempfile" wasn't set to "is_tempfile".
3486        Instead, the file was left open, so we should restore "cf->is_tempfile"
3487        ourselves.
3488
3489        XXX - change the menu?  Presumably "cf_open()" will do that;
3490        make sure it does! */
3491     cf->is_tempfile = is_tempfile;
3492   }
3493   /* "cf_open()" made a copy of the file name we handed it, so
3494      we should free up our copy. */
3495   g_free(filename);
3496 }
3497
3498 /* Copies a file in binary mode, for those operating systems that care about
3499  * such things.
3500  * Returns TRUE on success, FALSE on failure. If a failure, it also
3501  * displays a simple dialog window with the error message.
3502  */
3503 static gboolean
3504 copy_binary_file(const char *from_filename, const char *to_filename)
3505 {
3506   int           from_fd, to_fd, nread, nwritten, err;
3507   guint8        pd[65536];
3508
3509   /* Copy the raw bytes of the file. */
3510   from_fd = open(from_filename, O_RDONLY | O_BINARY);
3511   if (from_fd < 0) {
3512     open_failure_alert_box(from_filename, errno, FALSE);
3513     goto done;
3514   }
3515
3516   /* Use open() instead of creat() so that we can pass the O_BINARY
3517      flag, which is relevant on Win32; it appears that "creat()"
3518      may open the file in text mode, not binary mode, but we want
3519      to copy the raw bytes of the file, so we need the output file
3520      to be open in binary mode. */
3521   to_fd = open(to_filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
3522   if (to_fd < 0) {
3523     open_failure_alert_box(to_filename, errno, TRUE);
3524     close(from_fd);
3525     goto done;
3526   }
3527
3528   while ((nread = read(from_fd, pd, sizeof pd)) > 0) {
3529     nwritten = write(to_fd, pd, nread);
3530     if (nwritten < nread) {
3531       if (nwritten < 0)
3532         err = errno;
3533       else
3534         err = WTAP_ERR_SHORT_WRITE;
3535       write_failure_alert_box(to_filename, err);
3536       close(from_fd);
3537       close(to_fd);
3538       goto done;
3539     }
3540   }
3541   if (nread < 0) {
3542     err = errno;
3543     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
3544                   "An error occurred while reading from the file \"%s\": %s.",
3545                   from_filename, strerror(err));
3546     close(from_fd);
3547     close(to_fd);
3548     goto done;
3549   }
3550   close(from_fd);
3551   if (close(to_fd) < 0) {
3552     write_failure_alert_box(to_filename, errno);
3553     goto done;
3554   }
3555
3556   return TRUE;
3557
3558 done:
3559   return FALSE;
3560 }