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