(some) redesign of capture data structures.
authorulfl <ulfl@f5534014-38df-0310-8fa8-9805f1628bb7>
Fri, 4 Feb 2005 01:29:29 +0000 (01:29 +0000)
committerulfl <ulfl@f5534014-38df-0310-8fa8-9805f1628bb7>
Fri, 4 Feb 2005 01:29:29 +0000 (01:29 +0000)
don't use global cfile at all but only an untpyed handle to call the cf_... functions in file.c
move the save_file member from capture_file to capture_opts, as it's only used while capturing and while preparing it

git-svn-id: http://anonsvn.wireshark.org/wireshark/trunk@13276 f5534014-38df-0310-8fa8-9805f1628bb7

13 files changed:
capture.c
capture.h
capture_loop.c
capture_sync.c
capture_sync.h
cfile.c
cfile.h
file.c
file.h
gtk/capture_dlg.c
gtk/capture_info_dlg.c
gtk/main.c
tethereal.c

index 066a4a6055eeb59d47874de1ef9077bfe5409f95..a94430591e5d8a0e4acb4040a7fd130a03155653 100644 (file)
--- a/capture.c
+++ b/capture.c
@@ -129,8 +129,8 @@ capture_open_output(capture_options *capture_opts, const char *save_file, gboole
 
   /* close the old file */
   cf_close(&cfile);
-  g_assert(cfile.save_file == NULL);
-  cfile.save_file = capfile_name;
+  g_assert(capture_opts->save_file == NULL);
+  capture_opts->save_file = capfile_name;
   /* cfile.save_file is "g_free"ed later, which is equivalent to
      "g_free(capfile_name)". */
 
@@ -193,21 +193,21 @@ normal_do_capture(capture_options *capture_opts, gboolean is_tempfile)
       if (capture_opts->multi_files_on) {
        ringbuf_free();
       } else {
-       g_free(cfile.save_file);
+       g_free(capture_opts->save_file);
       }
-      cfile.save_file = NULL;
+      capture_opts->save_file = NULL;
       return FALSE;
     }
     /* Capture succeeded; attempt to read in the capture file. */
-    if ((err = cf_open(cfile.save_file, is_tempfile, &cfile)) != 0) {
+    if ((err = cf_open(capture_opts->save_file, is_tempfile, &cfile)) != 0) {
       /* We're not doing a capture any more, so we don't have a save
         file. */
       if (capture_opts->multi_files_on) {
        ringbuf_free();
       } else {
-       g_free(cfile.save_file);
+       g_free(capture_opts->save_file);
       }
-      cfile.save_file = NULL;
+      capture_opts->save_file = NULL;
       return FALSE;
     }
 
@@ -266,9 +266,9 @@ normal_do_capture(capture_options *capture_opts, gboolean is_tempfile)
     if (capture_opts->multi_files_on) {
       ringbuf_free();
     } else {
-      g_free(cfile.save_file);
+      g_free(capture_opts->save_file);
     }
-    cfile.save_file = NULL;
+    capture_opts->save_file = NULL;
 
     /* if we didn't captured even a single packet, close the file again */
     if(cfile.count == 0) {
@@ -306,21 +306,21 @@ capture_start(capture_options *capture_opts, gboolean *stats_known, struct pcap_
 }
 
 void
-capture_stop(gboolean sync_mode)
+capture_stop(capture_options *capture_opts)
 {
 
-  if (sync_mode) {     
-    sync_pipe_stop();
+  if (capture_opts->sync_mode) {       
+    sync_pipe_stop(capture_opts);
   }
     
   capture_loop_stop();
 }
 
 void
-kill_capture_child(gboolean sync_mode)
+kill_capture_child(capture_options *capture_opts)
 {
-  if (sync_mode) {     
-    sync_pipe_kill();
+  if (capture_opts->sync_mode) {       
+    sync_pipe_kill(capture_opts);
   }
 }
 
index 0d1c9d83399ba77140dee33f9c99df46ac3f3aaf..8e16b791e1e9c090dfddb5292e6282bf29ecb967 100644 (file)
--- a/capture.h
+++ b/capture.h
@@ -37,6 +37,7 @@
 /** Capture options coming from user interface */
 typedef struct capture_options_tag {
     /* general */
+    void *cf;               /**< handle to cfile (note: untyped handle) */
 #ifdef _WIN32
     int buffer_size;        /**< the capture buffer size (MB) */
 #endif
@@ -47,6 +48,7 @@ typedef struct capture_options_tag {
        int linktype;                   /**< Data link type to use, or -1 for
                                           "use default" */
        gboolean capture_child; /**< True if this is the child for "-S" */
+    gchar    *save_file;    /**< File that user saved capture to */
     int      save_file_fd;  /**< File descriptor for saved file */
 
     /* GUI related */
@@ -77,6 +79,9 @@ typedef struct capture_options_tag {
        gboolean has_autostop_duration; /**< TRUE if maximum capture duration
                                           is specified */
        gint32 autostop_duration;       /**< Maximum capture duration */
+
+    /* internally used (don't touch from outside) */
+    int fork_child;                /**< If not -1, in parent, process ID of child */
 } capture_options;
 
 
@@ -90,10 +95,10 @@ extern gboolean do_capture(capture_options *capture_opts, const char *save_file)
 extern int  capture_start(capture_options *capture_opts, gboolean *stats_known, struct pcap_stat *stats);
 
 /** Stop a capture from a menu item. */
-extern void capture_stop(gboolean sync_mode);
+extern void capture_stop(capture_options *capture_opts);
 
 /** Terminate the capture child cleanly when exiting. */
-extern void kill_capture_child(gboolean sync_mode);
+extern void kill_capture_child(capture_options *capture_opts);
 
 /** Do the low-level work of a capture. */
 extern int  capture_loop_start(capture_options *capture_opts, gboolean *stats_known, struct pcap_stat *stats);
index 912152bbe759e1b50d37afe548929642d912c9f9..3baf06af64650a1f75b0e8dd8fd9eca1eac30e83 100644 (file)
@@ -822,12 +822,12 @@ static int capture_loop_open_wiretap_output(capture_options *capture_opts, loop_
         g_snprintf(errmsg, errmsg_len,
                     "The file to which the capture would be"
                      " saved (\"%s\") could not be opened: Error %d.",
-                       cfile.save_file, err);
+                       capture_opts->save_file, err);
       } else {
         g_snprintf(errmsg, errmsg_len,
                     "The file to which the capture would be"
                      " saved (\"%s\") could not be opened: %s.",
-                       cfile.save_file, strerror(err));
+                       capture_opts->save_file, strerror(err));
       }
       break;
     }
@@ -840,7 +840,7 @@ static int capture_loop_open_wiretap_output(capture_options *capture_opts, loop_
 
 static gboolean capture_loop_close_output(capture_options *capture_opts, loop_data *ld, int *err_close) {
   if (capture_opts->multi_files_on) {
-    return ringbuf_wtap_dump_close(&cfile.save_file, err_close);
+    return ringbuf_wtap_dump_close(&capture_opts->save_file, err_close);
   } else {
     return wtap_dump_close(ld->wtap_pdh, err_close);
   }
@@ -1106,7 +1106,7 @@ capture_loop_start(capture_options *capture_opts, gboolean *stats_known, struct
           }
 
           /* Switch to the next ringbuffer file */
-          if (ringbuf_switch_file(&ld.wtap_pdh, &cfile.save_file, &capture_opts->save_file_fd, &ld.err)) {
+          if (ringbuf_switch_file(&ld.wtap_pdh, &capture_opts->save_file, &capture_opts->save_file_fd, &ld.err)) {
             /* File switch succeeded: reset the conditions */
             cnd_reset(cnd_autostop_size);
             if (cnd_file_duration) {
@@ -1175,7 +1175,7 @@ capture_loop_start(capture_options *capture_opts, gboolean *stats_known, struct
           }
 
           /* Switch to the next ringbuffer file */
-          if (ringbuf_switch_file(&ld.wtap_pdh, &cfile.save_file, &capture_opts->save_file_fd, &ld.err)) {
+          if (ringbuf_switch_file(&ld.wtap_pdh, &capture_opts->save_file, &capture_opts->save_file_fd, &ld.err)) {
             /* file switch succeeded: reset the conditions */
             cnd_reset(cnd_file_duration);
             if(cnd_autostop_size)
@@ -1225,7 +1225,7 @@ capture_loop_start(capture_options *capture_opts, gboolean *stats_known, struct
   if (ld.err == 0) {
     write_ok = TRUE;
   } else {
-    capture_loop_get_errmsg(errmsg, sizeof(errmsg), cfile.save_file, ld.err,
+    capture_loop_get_errmsg(errmsg, sizeof(errmsg), capture_opts->save_file, ld.err,
                              FALSE);
     capture_loop_popup_errmsg(capture_opts, errmsg);
     write_ok = FALSE;
@@ -1237,7 +1237,7 @@ capture_loop_start(capture_options *capture_opts, gboolean *stats_known, struct
   /* If we've displayed a message about a write error, there's no point
      in displaying another message about an error on close. */
   if (!close_ok && write_ok) {
-    capture_loop_get_errmsg(errmsg, sizeof(errmsg), cfile.save_file, err_close,
+    capture_loop_get_errmsg(errmsg, sizeof(errmsg), capture_opts->save_file, err_close,
                TRUE);
     capture_loop_popup_errmsg(capture_opts, errmsg);
   }
@@ -1287,10 +1287,10 @@ error:
 
     /* We couldn't even start the capture, so get rid of the capture
        file. */
-    unlink(cfile.save_file); /* silently ignore error */
-    g_free(cfile.save_file);
+    unlink(capture_opts->save_file); /* silently ignore error */
+    g_free(capture_opts->save_file);
   }
-  cfile.save_file = NULL;
+  capture_opts->save_file = NULL;
   capture_loop_popup_errmsg(capture_opts, errmsg);
 
   /* close the input file (pcap or cap_pipe) */
index 6a88e9fcf9612da3df165e9ecefcf9167b805f40..d39a87ff21743ffa1fafb3b866fa40afc81ebbfe 100644 (file)
@@ -95,8 +95,6 @@
 # include <io.h>
 #endif
 
-int fork_child = -1;       /* If not -1, in parent, process ID of child */
-
 #ifdef _WIN32
 #include <process.h>    /* For spawning child process */
 #endif
@@ -113,7 +111,7 @@ static char *sync_pipe_signame(int);
 
 
 static gboolean sync_pipe_input_cb(gint source, gpointer user_data);
-static void sync_pipe_wait_for_child(gboolean always_report);
+static void sync_pipe_wait_for_child(int fork_child, gboolean always_report);
 
 /* Size of buffer to hold decimal representation of
    signed/unsigned 64-bit int */
@@ -233,7 +231,7 @@ sync_pipe_do_capture(capture_options *capture_opts, gboolean is_tempfile) {
     int sync_pipe[2];                       /* pipes used to sync between instances */
 
 
-    fork_child = -1;
+    capture_opts->fork_child = -1;
 
     /* Allocate the string pointer array with enough space for the
        terminating NULL pointer. */
@@ -248,7 +246,7 @@ sync_pipe_do_capture(capture_options *capture_opts, gboolean is_tempfile) {
     argv = sync_pipe_add_arg(argv, &argc, cfile.iface);
 
     argv = sync_pipe_add_arg(argv, &argc, "-w");
-    argv = sync_pipe_add_arg(argv, &argc, cfile.save_file);
+    argv = sync_pipe_add_arg(argv, &argc, capture_opts->save_file);
 
     argv = sync_pipe_add_arg(argv, &argc, "-W");
     sprintf(save_file_fd,"%d",capture_opts->save_file_fd);     /* in lieu of itoa */
@@ -302,9 +300,9 @@ sync_pipe_do_capture(capture_options *capture_opts, gboolean is_tempfile) {
     if(_pipe(sync_pipe, 512, O_BINARY) < 0) {
       /* Couldn't create the pipe between parent and child. */
       error = errno;
-      unlink(cfile.save_file);
-      g_free(cfile.save_file);
-      cfile.save_file = NULL;
+      unlink(capture_opts->save_file);
+      g_free(capture_opts->save_file);
+      capture_opts->save_file = NULL;
       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Couldn't create sync pipe: %s",
                         strerror(error));
       return FALSE;
@@ -329,7 +327,7 @@ sync_pipe_do_capture(capture_options *capture_opts, gboolean is_tempfile) {
     }
 
     /* Spawn process */
-    fork_child = spawnvp(_P_NOWAIT, ethereal_path, argv);
+    capture_opts->fork_child = spawnvp(_P_NOWAIT, ethereal_path, argv);
     g_free(fontstring);
     if (filterstring) {
       g_free(filterstring);
@@ -398,13 +396,13 @@ sync_pipe_do_capture(capture_options *capture_opts, gboolean is_tempfile) {
        it and reading the save file through Wiretap. */
     close(capture_opts->save_file_fd);
 
-    if (fork_child == -1) {
+    if (capture_opts->fork_child == -1) {
       /* We couldn't even create the child process. */
       error = errno;
       close(sync_pipe[PIPE_READ]);
-      unlink(cfile.save_file);
-      g_free(cfile.save_file);
-      cfile.save_file = NULL;
+      unlink(capture_opts->save_file);
+      g_free(capture_opts->save_file);
+      capture_opts->save_file = NULL;
       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
                        "Couldn't create child process: %s", strerror(error));
       return FALSE;
@@ -423,10 +421,10 @@ sync_pipe_do_capture(capture_options *capture_opts, gboolean is_tempfile) {
           Close the read side of the sync pipe, remove the capture file,
           and report the failure. */
        close(sync_pipe[PIPE_READ]);
-       unlink(cfile.save_file);
-       g_free(cfile.save_file);
-       cfile.save_file = NULL;
-       sync_pipe_wait_for_child(TRUE);
+       unlink(capture_opts->save_file);
+       g_free(capture_opts->save_file);
+       capture_opts->save_file = NULL;
+       sync_pipe_wait_for_child(capture_opts->fork_child, TRUE);
        return FALSE;
       }
       if (c == SP_CAPSTART || c == SP_ERROR_MSG)
@@ -436,9 +434,9 @@ sync_pipe_do_capture(capture_options *capture_opts, gboolean is_tempfile) {
           Close the read side of the sync pipe, remove the capture file,
           and report the failure. */
        close(sync_pipe[PIPE_READ]);
-       unlink(cfile.save_file);
-       g_free(cfile.save_file);
-       cfile.save_file = NULL;
+       unlink(capture_opts->save_file);
+       g_free(capture_opts->save_file);
+       capture_opts->save_file = NULL;
        simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
                        "Capture child process sent us a bad message");
        return FALSE;
@@ -467,7 +465,7 @@ sync_pipe_do_capture(capture_options *capture_opts, gboolean is_tempfile) {
          } else if (i == 0) {
            simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
                  "Capture child process failed: EOF reading its error message.");
-           sync_pipe_wait_for_child(FALSE);
+           sync_pipe_wait_for_child(capture_opts->fork_child, FALSE);
          } else
            simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, msg);
          g_free(msg);
@@ -477,16 +475,16 @@ sync_pipe_do_capture(capture_options *capture_opts, gboolean is_tempfile) {
        close(sync_pipe[PIPE_READ]);
 
        /* Get rid of the save file - the capture never started. */
-       unlink(cfile.save_file);
-       g_free(cfile.save_file);
-       cfile.save_file = NULL;
+       unlink(capture_opts->save_file);
+       g_free(capture_opts->save_file);
+       capture_opts->save_file = NULL;
       }
       return FALSE;
     }
 
     /* The child process started a capture.
        Attempt to open the capture file and set up to read it. */
-    err = cf_start_tail(cfile.save_file, is_tempfile, &cfile);
+    err = cf_start_tail(capture_opts->save_file, is_tempfile, &cfile);
     if (err != 0) {
       /* We weren't able to open the capture file; user has been
         alerted. Close the sync pipe. */
@@ -495,15 +493,15 @@ sync_pipe_do_capture(capture_options *capture_opts, gboolean is_tempfile) {
 
       /* Don't unlink the save file - leave it around, for debugging
         purposes. */
-      g_free(cfile.save_file);
-      cfile.save_file = NULL;
+      g_free(capture_opts->save_file);
+      capture_opts->save_file = NULL;
       return FALSE;
     }
     /* We were able to open and set up to read the capture file;
        arrange that our callback be called whenever it's possible
        to read from the sync pipe, so that it's called when
        the child process wants to tell us something. */
-    pipe_input_set_handler(sync_pipe[PIPE_READ], (gpointer) &cfile, &fork_child, sync_pipe_input_cb);
+    pipe_input_set_handler(sync_pipe[PIPE_READ], (gpointer) capture_opts, &capture_opts->fork_child, sync_pipe_input_cb);
 
     return TRUE;
 }
@@ -515,7 +513,8 @@ sync_pipe_do_capture(capture_options *capture_opts, gboolean is_tempfile) {
 static gboolean 
 sync_pipe_input_cb(gint source, gpointer user_data)
 {
-  capture_file *cf = (capture_file *)user_data;
+  capture_options *capture_opts = (capture_options *)user_data;
+  gint fork_child = capture_opts->fork_child;
 #define BUFSIZE        4096
   char buffer[BUFSIZE+1], *p = buffer, *q = buffer, *msg, *r;
   int  nread, msglen, chars_to_copy;
@@ -527,20 +526,20 @@ sync_pipe_input_cb(gint source, gpointer user_data)
     /* The child has closed the sync pipe, meaning it's not going to be
        capturing any more packets.  Pick up its exit status, and
        complain if it did anything other than exit with status 0. */
-    sync_pipe_wait_for_child(FALSE);
+    sync_pipe_wait_for_child(fork_child, FALSE);
 
     /* Read what remains of the capture file, and finish the capture.
        XXX - do something if this fails? */
-    switch (cf_finish_tail(cf, &err)) {
+    switch (cf_finish_tail(capture_opts->cf, &err)) {
 
     case READ_SUCCESS:
-        if(cf->count == 0) {
+        if(cf_packet_count(capture_opts->cf) == 0) {
           simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK, 
           "%sNo packets captured!%s\n\n"
           "As no data was captured, closing the %scapture file!",
           simple_dialog_primary_start(), simple_dialog_primary_end(),
-          (cf->is_tempfile) ? "temporary " : "");
-          cf_close(cf);
+          cf_is_tempfile(capture_opts->cf) ? "temporary " : "");
+          cf_close(capture_opts->cf);
         }
         break;
     case READ_ERROR:
@@ -558,8 +557,8 @@ sync_pipe_input_cb(gint source, gpointer user_data)
 
     /* We're not doing a capture any more, so we don't have a save
        file. */
-    g_free(cf->save_file);
-    cf->save_file = NULL;
+    g_free(capture_opts->save_file);
+    capture_opts->save_file = NULL;
 
     return FALSE;
   }
@@ -576,8 +575,8 @@ sync_pipe_input_cb(gint source, gpointer user_data)
       nread--;
       break;
     case SP_DROPS :
-      cf->drops_known = TRUE;
-      cf->drops = atoi(p);
+      cf_set_drops_known(capture_opts->cf, TRUE);
+      cf_set_drops(capture_opts->cf, atoi(p));
       p = q + 1;
       q++;
       nread--;
@@ -622,7 +621,7 @@ sync_pipe_input_cb(gint source, gpointer user_data)
   /* Read from the capture file the number of records the child told us
      it added.
      XXX - do something if this fails? */
-  switch (cf_continue_tail(cf, to_read, &err)) {
+  switch (cf_continue_tail(capture_opts->cf, to_read, &err)) {
 
   case READ_SUCCESS:
   case READ_ERROR:
@@ -636,7 +635,7 @@ sync_pipe_input_cb(gint source, gpointer user_data)
   case READ_ABORTED:
     /* Kill the child capture process; the user wants to exit, and we
        shouldn't just leave it running. */
-    kill_capture_child(TRUE /* sync_mode */);
+    kill_capture_child(capture_opts);
     break;
   }
 
@@ -646,7 +645,7 @@ sync_pipe_input_cb(gint source, gpointer user_data)
 
 /* the child process is going down, wait until it's completely terminated */
 static void
-sync_pipe_wait_for_child(gboolean always_report)
+sync_pipe_wait_for_child(int fork_child, gboolean always_report)
 {
   int  wstatus;
 
@@ -789,11 +788,11 @@ sync_pipe_signame(int sig)
 
 
 void
-sync_pipe_stop(void)
+sync_pipe_stop(capture_options *capture_opts)
 {
-  if (fork_child != -1) {
+  if (capture_opts->fork_child != -1) {
 #ifndef _WIN32
-      kill(fork_child, SIGUSR1);
+      kill(capture_opts->fork_child, SIGUSR1);
 #else
       /* XXX: this is not the preferred method of closing a process!
        * the clean way would be getting the process id of the child process,
@@ -807,18 +806,18 @@ sync_pipe_stop(void)
        * running in the same console, I don't know if that is true for our case.
        * And this also will require to have the process id
        */
-      TerminateProcess((HANDLE) fork_child, 0);
+      TerminateProcess((HANDLE) (capture_opts->fork_child), 0);
 #endif
   }
 }
 
 
 void
-sync_pipe_kill(void)
+sync_pipe_kill(capture_options *capture_opts)
 {
-  if (fork_child != -1)
+  if (capture_opts->fork_child != -1)
 #ifndef _WIN32
-      kill(fork_child, SIGTERM);       /* SIGTERM so it can clean up if necessary */
+      kill(capture_opts->fork_child, SIGTERM); /* SIGTERM so it can clean up if necessary */
 #else
       /* XXX: this is not the preferred method of closing a process!
        * the clean way would be getting the process id of the child process,
@@ -832,7 +831,7 @@ sync_pipe_kill(void)
        * running in the same console, I don't know if that is true for our case.
        * And this also will require to have the process id
        */
-      TerminateProcess((HANDLE) fork_child, 0);
+      TerminateProcess((HANDLE) (capture_opts->fork_child), 0);
 #endif
 }
 
index 2daed7bc5c4ea195066b31d0418a9fdd91fe3303..2f8ec9c3fb86d1bb698a47bd06e952a33def9292 100644 (file)
@@ -50,11 +50,11 @@ sync_pipe_do_capture(capture_options *capture_opts, gboolean is_tempfile);
 
 /** User wants to stop capturing, gracefully close the capture child */
 extern void
-sync_pipe_stop(void);
+sync_pipe_stop(capture_options *capture_opts);
 
 /** We want to stop the program, just kill the child as soon as possible */
 extern void
-sync_pipe_kill(void);
+sync_pipe_kill(capture_options *capture_opts);
 
 
 /** the child will immediately start capturing, notify the parent */
diff --git a/cfile.c b/cfile.c
index 5b958f3252dac864ca43a124cffdf2edd40bd07f..225d88b863493fff3c26818deab56631d7746fcc 100644 (file)
--- a/cfile.c
+++ b/cfile.c
@@ -56,7 +56,6 @@ init_cap_file(capture_file *cf)
   cf->cfilter          = g_strdup("");
 #endif
   cf->iface            = NULL;
-  cf->save_file        = NULL;
   cf->has_snap = FALSE;
   cf->snap             = WTAP_MAX_PACKET_SIZE;
   cf->count            = 0;
diff --git a/cfile.h b/cfile.h
index 13c85489406443019f23382b855650b082e8a6b7..0a16fa23d22180ef0bed4c172bb9f1549299ded1 100644 (file)
--- a/cfile.h
+++ b/cfile.h
@@ -61,7 +61,6 @@ typedef struct _capture_file {
   gboolean     has_snap;  /* TRUE if maximum capture packet length is known */
   int          snap;      /* Maximum captured packet length */
   gchar       *iface;     /* Interface */
-  gchar       *save_file; /* File that user saved capture to */
   wtap        *wth;       /* Wiretap session */
   dfilter_t   *rfcode;    /* Compiled read filter program */
   gchar       *dfilter;   /* Display filter string */
diff --git a/file.c b/file.c
index a57bd0d033f42c60ff65358aac2363fa0b9a017b..6e446135a6ac1ce3021839bdb4febbdce09e13b7 100644 (file)
--- a/file.c
+++ b/file.c
@@ -707,6 +707,32 @@ cf_get_display_name(capture_file *cf)
   return displayname;
 }
 
+/* XXX - use a macro instead? */
+int
+cf_packet_count(capture_file *cf)
+{
+    return cf->count;
+}
+
+/* XXX - use a macro instead? */
+gboolean
+cf_is_tempfile(capture_file *cf)
+{
+    return cf->is_tempfile;
+}
+
+/* XXX - use a macro instead? */
+void cf_set_drops_known(capture_file *cf, gboolean drops_known)
+{
+    cf->drops_known = drops_known;
+}
+
+/* XXX - use a macro instead? */
+void cf_set_drops(capture_file *cf, guint32 drops)
+{
+    cf->drops = drops;
+}
+
 typedef struct {
   color_filter_t *colorf;
   epan_dissect_t *edt;
diff --git a/file.h b/file.h
index 0b91efff865e76a0ad95fa26c7696db73b44a93c..fb1b3f97d6b8869934a2303f7afc8ddc60f245bb 100644 (file)
--- a/file.h
+++ b/file.h
@@ -52,6 +52,10 @@ read_status_t cf_finish_tail(capture_file *, int *);
 /* size_t read_frame_header(capture_file *); */
 gboolean cf_save(char *fname, capture_file * cf, packet_range_t *range, guint save_format);
 const gchar *cf_get_display_name(capture_file *);
+int cf_packet_count(capture_file *cf);
+gboolean cf_is_tempfile(capture_file *cf);
+void cf_set_drops_known(capture_file *cf, gboolean drops_known);
+void cf_set_drops(capture_file *cf, guint32 drops);
 
 gboolean
 cf_merge_files(const char *out_filename, int out_fd, int in_file_count,
index e5b64255986ff64ce74ccd69bcfe0ba8d0b171fd..afe10a8e68aa0bb1f975906cb3a56d3fcfb74f46 100644 (file)
@@ -123,7 +123,7 @@ capture_prep_interface_changed_cb(GtkWidget *entry, gpointer parent_w);
 void
 capture_stop_cb(GtkWidget *w _U_, gpointer d _U_)
 {
-    capture_stop(capture_opts->sync_mode);
+    capture_stop(capture_opts);
 }
 
 /*
index 2a2e600d296a850e943acf77250ead17b779b2e5..b9d98901c79a0c13facd79fc661a9a05900e332a 100644 (file)
@@ -75,7 +75,7 @@ pct(gint num, gint denom) {
 
 static void
 capture_info_delete_cb(GtkWidget *w _U_, GdkEvent *event _U_, gpointer data _U_) {
-  capture_stop(capture_opts->sync_mode);
+  capture_stop(capture_opts);
 }
 
 
index 3084766b0a1c92952e2a7753a42f372dff560890..26fe478a3d41caa5f7d7a374040b74fd39eeb0db 100644 (file)
@@ -880,7 +880,7 @@ main_do_quit(void)
 
 #ifdef HAVE_LIBPCAP
        /* Nuke any child capture in progress. */
-       kill_capture_child(capture_opts->sync_mode);
+       kill_capture_child(capture_opts);
 #endif
 
        /* Are we in the middle of reading a capture? */
@@ -1847,6 +1847,7 @@ main(int argc, char *argv[])
   }
 #endif
 
+  capture_opts->cf = &cfile;
 #ifdef HAVE_LIBPCAP
   capture_opts->has_snaplen = FALSE;
   capture_opts->snaplen = MIN_PACKET_SIZE;
index d83ecee3909aaeb7b4805ba6de3d1454c3d642ab..b5b9584cc61a914e7fa9527cda62cc0120e04b5c 100644 (file)
@@ -167,48 +167,9 @@ typedef struct _loop_data {
 
 static loop_data ld;
 
-static int capture(int);
-static void capture_pcap_cb(guchar *, const struct pcap_pkthdr *,
-  const guchar *);
-static void report_counts(void);
-#ifdef _WIN32
-static BOOL WINAPI capture_cleanup(DWORD);
-#else /* _WIN32 */
-static void capture_cleanup(int);
-#ifdef SIGINFO
-static void report_counts_siginfo(int);
-#endif /* SIGINFO */
-#endif /* _WIN32 */
-#endif /* HAVE_LIBPCAP */
-
-static int load_cap_file(capture_file *, int);
-static gboolean process_packet(capture_file *cf, wtap_dumper *pdh, long offset,
-    const struct wtap_pkthdr *whdr, union wtap_pseudo_header *pseudo_header,
-    const guchar *pd, int *err);
-static void show_capture_file_io_error(const char *, int, gboolean);
-static void show_print_file_io_error(int err);
-static gboolean write_preamble(capture_file *cf);
-static gboolean print_packet(capture_file *cf, epan_dissect_t *edt);
-static gboolean write_finale(void);
-static char *cf_open_error_message(int err, gchar *err_info,
-    gboolean for_writing, int file_type);
-#ifdef HAVE_LIBPCAP
-#ifndef _WIN32
-static void adjust_header(loop_data *, struct pcap_hdr *, struct pcaprec_hdr *);
-static int pipe_open_live(char *, struct pcap_hdr *, loop_data *, char *, int);
-static int pipe_dispatch(int, loop_data *, struct pcap_hdr *, \
-                struct pcaprec_modified_hdr *, guchar *, char *, int);
-#endif /* _WIN32 */
-#endif
-
-static void open_failure_message(const char *filename, int err,
-    gboolean for_writing);
-static void failure_message(const char *msg_format, va_list ap);
-static void read_failure_message(const char *filename, int err);
-
-capture_file cfile;
 #ifdef HAVE_LIBPCAP
 typedef struct {
+    gchar    *save_file;    /* File that user saved capture to */
        int snaplen;                    /* Maximum captured packet length */
        int promisc_mode;               /* Capture in promiscuous mode */
        int autostop_count;             /* Maximum packet count */
@@ -227,6 +188,7 @@ typedef struct {
 } capture_options;
 
 static capture_options capture_opts = {
+    "",
        WTAP_MAX_PACKET_SIZE,           /* snapshot length - default is
                                           infinite, in effect */
        TRUE,                           /* promiscuous mode is the default */
@@ -254,6 +216,49 @@ static gboolean infoprint; /* if TRUE, print capture info after clearing infodel
 #endif /* SIGINFO */
 #endif /* HAVE_LIBPCAP */
 
+
+static int capture(int);
+static void capture_pcap_cb(guchar *, const struct pcap_pkthdr *,
+  const guchar *);
+static void report_counts(void);
+#ifdef _WIN32
+static BOOL WINAPI capture_cleanup(DWORD);
+#else /* _WIN32 */
+static void capture_cleanup(int);
+#ifdef SIGINFO
+static void report_counts_siginfo(int);
+#endif /* SIGINFO */
+#endif /* _WIN32 */
+#endif /* HAVE_LIBPCAP */
+
+static int load_cap_file(capture_file *, capture_options *capture_opts, int);
+static gboolean process_packet(capture_file *cf, wtap_dumper *pdh, long offset,
+    const struct wtap_pkthdr *whdr, union wtap_pseudo_header *pseudo_header,
+    const guchar *pd, int *err);
+static void show_capture_file_io_error(const char *, int, gboolean);
+static void show_print_file_io_error(int err);
+static gboolean write_preamble(capture_file *cf);
+static gboolean print_packet(capture_file *cf, epan_dissect_t *edt);
+static gboolean write_finale(void);
+static char *cf_open_error_message(int err, gchar *err_info,
+    gboolean for_writing, int file_type);
+#ifdef HAVE_LIBPCAP
+#ifndef _WIN32
+static void adjust_header(loop_data *, struct pcap_hdr *, struct pcaprec_hdr *);
+static int pipe_open_live(char *, struct pcap_hdr *, loop_data *, char *, int);
+static int pipe_dispatch(int, loop_data *, struct pcap_hdr *, \
+                struct pcaprec_modified_hdr *, guchar *, char *, int);
+#endif /* _WIN32 */
+#endif
+
+static void open_failure_message(const char *filename, int err,
+    gboolean for_writing);
+static void failure_message(const char *msg_format, va_list ap);
+static void read_failure_message(const char *filename, int err);
+
+capture_file cfile;
+
+
 static void
 print_usage(gboolean print_ver)
 {
@@ -1238,7 +1243,7 @@ main(int argc, char *argv[])
         exit(0);
         break;
       case 'w':        /* Write to capture file xxx */
-        cfile.save_file = g_strdup(optarg);
+        capture_opts.save_file = g_strdup(optarg);
        break;
       case 'V':        /* Verbose */
         verbose = TRUE;
@@ -1317,12 +1322,12 @@ main(int argc, char *argv[])
 #ifdef HAVE_LIBPCAP
   ld.output_to_pipe = FALSE;
 #endif
-  if (cfile.save_file != NULL) {
+  if (capture_opts.save_file != NULL) {
     /* We're writing to a capture file. */
-    if (strcmp(cfile.save_file, "-") == 0) {
+    if (strcmp(capture_opts.save_file, "-") == 0) {
       /* Write to the standard output. */
-      g_free(cfile.save_file);
-      cfile.save_file = g_strdup("");
+      g_free(capture_opts.save_file);
+      capture_opts.save_file = g_strdup("");
 #ifdef HAVE_LIBPCAP
       /* XXX - should we check whether it's a pipe?  It's arguably
          silly to do "-w - >output_file" rather than "-w output_file",
@@ -1333,7 +1338,7 @@ main(int argc, char *argv[])
     }
 #ifdef HAVE_LIBPCAP
     else {
-      err = test_for_fifo(cfile.save_file);
+      err = test_for_fifo(capture_opts.save_file);
       switch (err) {
 
       case ENOENT:     /* it doesn't exist, so we'll be creating it,
@@ -1406,7 +1411,7 @@ main(int argc, char *argv[])
   } else {
     /* If they didn't specify a "-w" flag, but specified a maximum capture
        file size, tell them that this doesn't work, and exit. */
-    if (capture_opts.has_autostop_filesize && cfile.save_file == NULL) {
+    if (capture_opts.has_autostop_filesize && capture_opts.save_file == NULL) {
       fprintf(stderr, "tethereal: Maximum capture file size specified, but "
         "capture isn't being saved to a file.\n");
       exit(1);
@@ -1420,7 +1425,7 @@ main(int argc, char *argv[])
         c) it makes no sense to enable the ring buffer if the maximum
            file size is set to "infinite";
         d) file must not be a pipe. */
-      if (cfile.save_file == NULL) {
+      if (capture_opts.save_file == NULL) {
        fprintf(stderr, "tethereal: Ring buffer requested, but "
          "capture isn't being saved to a file.\n");
        exit(1);
@@ -1578,7 +1583,7 @@ main(int argc, char *argv[])
       epan_cleanup();
       exit(2);
     }
-    err = load_cap_file(&cfile, out_file_type);
+    err = load_cap_file(&cfile, &capture_opts, out_file_type);
     if (err != 0) {
       epan_cleanup();
       exit(2);
@@ -1869,7 +1874,7 @@ capture(int out_file_type)
     file_snaplen = pcap_snapshot(ld.pch);
   }
   ld.linktype = wtap_pcap_encap_to_wtap_encap(pcap_encap);
-  if (cfile.save_file != NULL) {
+  if (capture_opts.save_file != NULL) {
     /* Set up to write to the capture file. */
     if (ld.linktype == WTAP_ENCAP_UNKNOWN) {
       strcpy(errmsg, "The network you're capturing from is of a type"
@@ -1877,7 +1882,7 @@ capture(int out_file_type)
       goto error;
     }
     if (capture_opts.ringbuffer_on) {
-      save_file_fd = ringbuf_init(cfile.save_file,
+      save_file_fd = ringbuf_init(capture_opts.save_file,
         capture_opts.ringbuffer_num_files);
       if (save_file_fd != -1) {
         ld.pdh = ringbuf_init_wtap_dump_fdopen(out_file_type, ld.linktype,
@@ -1887,14 +1892,14 @@ capture(int out_file_type)
         ld.pdh = NULL;
       }
     } else {
-      ld.pdh = wtap_dump_open(cfile.save_file, out_file_type,
+      ld.pdh = wtap_dump_open(capture_opts.save_file, out_file_type,
                 ld.linktype, file_snaplen, &err);
     }
 
     if (ld.pdh == NULL) {
       snprintf(errmsg, sizeof errmsg,
               cf_open_error_message(err, NULL, TRUE, out_file_type),
-              *cfile.save_file == '\0' ? "stdout" : cfile.save_file);
+              *capture_opts.save_file == '\0' ? "stdout" : capture_opts.save_file);
       goto error;
     }
   }
@@ -2035,7 +2040,7 @@ capture(int out_file_type)
            its maximum size. */
         if (capture_opts.ringbuffer_on) {
           /* Switch to the next ringbuffer file */
-          if (ringbuf_switch_file(&ld.pdh, &cfile.save_file, &save_file_fd, &loop_err)) {
+          if (ringbuf_switch_file(&ld.pdh, &capture_opts.save_file, &save_file_fd, &loop_err)) {
             /* File switch succeeded: reset the condition */
             cnd_reset(cnd_stop_capturesize);
            if (cnd_ring_timeout) {
@@ -2071,7 +2076,7 @@ capture(int out_file_type)
   if (cnd_ring_timeout != NULL)
     cnd_delete(cnd_ring_timeout);
 
-  if ((cfile.save_file != NULL) && !quiet) {
+  if ((capture_opts.save_file != NULL) && !quiet) {
     /* We're saving to a file, which means we're printing packet counts
        to stderr if we are not running silent and deep.
        Send a newline so that we move to the line after the packet count. */
@@ -2097,21 +2102,21 @@ capture(int out_file_type)
   if (volatile_err == 0)
     write_err = FALSE;
   else {
-    show_capture_file_io_error(cfile.save_file, volatile_err, FALSE);
+    show_capture_file_io_error(capture_opts.save_file, volatile_err, FALSE);
     write_err = TRUE;
   }
 
-  if (cfile.save_file != NULL) {
+  if (capture_opts.save_file != NULL) {
     /* We're saving to a file or files; close all files. */
     if (capture_opts.ringbuffer_on) {
-      dump_ok = ringbuf_wtap_dump_close(&cfile.save_file, &err);
+      dump_ok = ringbuf_wtap_dump_close(&capture_opts.save_file, &err);
     } else {
       dump_ok = wtap_dump_close(ld.pdh, &err);
     }
     /* If we've displayed a message about a write error, there's no point
        in displaying another message about an error on close. */
     if (!dump_ok && !write_err)
-      show_capture_file_io_error(cfile.save_file, err, TRUE);
+      show_capture_file_io_error(capture_opts.save_file, err, TRUE);
   }
 
 #ifndef _WIN32
@@ -2143,8 +2148,8 @@ error:
   if (capture_opts.ringbuffer_on) {
     ringbuf_error_cleanup();
   }
-  g_free(cfile.save_file);
-  cfile.save_file = NULL;
+  g_free(capture_opts.save_file);
+  capture_opts.save_file = NULL;
   fprintf(stderr, "tethereal: %s\n", errmsg);
 #ifndef _WIN32
   if (ld.from_pipe) {
@@ -2195,7 +2200,7 @@ capture_pcap_cb(guchar *user, const struct pcap_pkthdr *phdr,
    */
   if (cnd_ring_timeout != NULL && cnd_eval(cnd_ring_timeout)) {
     /* time elapsed for this ring file, switch to the next */
-    if (ringbuf_switch_file(&ldat->pdh, &cfile.save_file, &save_file_fd, &loop_err)) {
+    if (ringbuf_switch_file(&ldat->pdh, &capture_opts.save_file, &save_file_fd, &loop_err)) {
       /* File switch succeeded: reset the condition */
       cnd_reset(cnd_ring_timeout);
     } else {
@@ -2212,7 +2217,7 @@ capture_pcap_cb(guchar *user, const struct pcap_pkthdr *phdr,
          a count of packets captured; move to the line after the count. */
       fprintf(stderr, "\n");
     }
-    show_capture_file_io_error(cfile.save_file, err, FALSE);
+    show_capture_file_io_error(capture_opts.save_file, err, FALSE);
     pcap_close(ldat->pch);
     wtap_dump_close(ldat->pdh, &err);
     exit(2);
@@ -2311,7 +2316,7 @@ report_counts_siginfo(int signum _U_)
 #endif /* HAVE_LIBPCAP */
 
 static int
-load_cap_file(capture_file *cf, int out_file_type)
+load_cap_file(capture_file *cf, capture_options *capture_opts, int out_file_type)
 {
   gint         linktype;
   int          snapshot_length;
@@ -2321,14 +2326,14 @@ load_cap_file(capture_file *cf, int out_file_type)
   long         data_offset;
 
   linktype = wtap_file_encap(cf->wth);
-  if (cf->save_file != NULL) {
+  if (capture_opts->save_file != NULL) {
     /* Set up to write to the capture file. */
     snapshot_length = wtap_snapshot_length(cf->wth);
     if (snapshot_length == 0) {
       /* Snapshot length of input file not known. */
       snapshot_length = WTAP_MAX_PACKET_SIZE;
     }
-    pdh = wtap_dump_open(cf->save_file, out_file_type,
+    pdh = wtap_dump_open(capture_opts->save_file, out_file_type,
                linktype, snapshot_length, &err);
 
     if (pdh == NULL) {
@@ -2351,19 +2356,19 @@ load_cap_file(capture_file *cf, int out_file_type)
         fprintf(stderr,
           "tethereal: The file \"%s\" couldn't be created for some "
           "unknown reason.\n",
-            *cf->save_file == '\0' ? "stdout" : cf->save_file);
+            *capture_opts->save_file == '\0' ? "stdout" : capture_opts->save_file);
         break;
 
       case WTAP_ERR_SHORT_WRITE:
         fprintf(stderr,
           "tethereal: A full header couldn't be written to the file \"%s\".\n",
-               *cf->save_file == '\0' ? "stdout" : cf->save_file);
+               *capture_opts->save_file == '\0' ? "stdout" : capture_opts->save_file);
         break;
 
       default:
         fprintf(stderr,
           "tethereal: The file \"%s\" could not be created: %s\n.",
-               *cf->save_file == '\0' ? "stdout" : cf->save_file,
+               *capture_opts->save_file == '\0' ? "stdout" : capture_opts->save_file,
                wtap_strerror(err));
         break;
       }
@@ -2384,7 +2389,7 @@ load_cap_file(capture_file *cf, int out_file_type)
                         wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth),
                         &err)) {
       /* Error writing to a capture file */
-      show_capture_file_io_error(cf->save_file, err, FALSE);
+      show_capture_file_io_error(capture_opts->save_file, err, FALSE);
       wtap_dump_close(pdh, &err);
       exit(2);
     }
@@ -2423,16 +2428,16 @@ load_cap_file(capture_file *cf, int out_file_type)
        cf->filename, wtap_strerror(err));
       break;
     }
-    if (cf->save_file != NULL) {
+    if (capture_opts->save_file != NULL) {
       /* Now close the capture file. */
       if (!wtap_dump_close(pdh, &err))
-        show_capture_file_io_error(cfile.save_file, err, TRUE);
+        show_capture_file_io_error(capture_opts->save_file, err, TRUE);
     }
   } else {
-    if (cf->save_file != NULL) {
+    if (capture_opts->save_file != NULL) {
       /* Now close the capture file. */
       if (!wtap_dump_close(pdh, &err))
-        show_capture_file_io_error(cfile.save_file, err, TRUE);
+        show_capture_file_io_error(capture_opts->save_file, err, TRUE);
     } else {
       if (print_packet_info) {
         if (!write_finale()) {