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