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