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