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