From Harald Welte:
[obnox/wireshark/wip.git] / ringbuffer.c
index cc633eab3c1cdb12fc7216611d174ce874e71812..9319cf9f5132d557579a50ae1a47c022cd423377 100644 (file)
@@ -3,8 +3,8 @@
  *
  * $Id$
  *
- * Ethereal - Network traffic analyzer
- * By Gerald Combs <gerald@ethereal.com>
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
  * Copyright 1998 Gerald Combs
  *
  * This program is free software; you can redistribute it and/or
  * <laurent.deniel@free.fr>
  *
  * Almost completely rewritten in order to:
- * 
+ *
  * - be able to use a unlimited number of ringbuffer files
  * - close the current file and open (truncating) the next file at switch
  * - set the final file name once open (or reopen)
  * - avoid the deletion of files that could not be truncated (can't arise now)
  *   and do not erase empty files
  *
- * The idea behind that is to remove the limitation of the maximum # of 
+ * The idea behind that is to remove the limitation of the maximum # of
  * ringbuffer files being less than the maximum # of open fd per process
  * and to be able to reduce the amount of virtual memory usage (having only
  * one file open at most) or the amount of file system usage (by truncating
- * the files at switch and not the capture stop, and by closing them which 
+ * the files at switch and not the capture stop, and by closing them which
  * makes possible their move or deletion after a switch).
  *
  */
 
 #ifdef HAVE_LIBPCAP
 
-#ifdef HAVE_IO_H
-#include <io.h>
-#endif
-
 #ifdef HAVE_FCNTL_H
 #include <fcntl.h>
 #endif
 
-#ifdef HAVE_SYS_STAT_H
-#include <sys/stat.h>
-#endif
-
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #include <time.h>
 #include <errno.h>
 
-#ifdef NEED_SNPRINTF_H
-#include "snprintf.h"
-#endif
+#include <pcap.h>
 
-#include "wiretap/wtap.h"
+#include <glib.h>
+
+#include "pcapio.h"
 #include "ringbuffer.h"
+#include <wsutil/file_util.h>
 
-/* Win32 needs the O_BINARY flag for open() */
-#ifndef O_BINARY
-#define O_BINARY       0
-#endif
 
 /* Ringbuffer file structure */
 typedef struct _rb_file {
@@ -89,24 +78,22 @@ typedef struct _rb_file {
 /* Ringbuffer data structure */
 typedef struct _ringbuf_data {
   rb_file      *files;
-  guint         num_files;           /* Number of ringbuffer files */
-  guint         curr_file_num;       /* Number of the current file */
+  guint         num_files;           /* Number of ringbuffer files (1 to ...) */
+  guint         curr_file_num;       /* Number of the current file (ever increasing) */
   gchar        *fprefix;             /* Filename prefix */
   gchar        *fsuffix;             /* Filename suffix */
   gboolean      unlimited;           /* TRUE if unlimited number of files */
-  int           filetype;
-  int           linktype;
-  int           snaplen;
 
   int           fd;                 /* Current ringbuffer file descriptor */
-  wtap_dumper  *pdh;  
+  FILE         *pdh;
+  gboolean      group_read_access;   /* TRUE if files need to be opened with group read access */
 } ringbuf_data;
 
 static ringbuf_data rb_data;
 
 
 /*
- * create the next filename and open a new binary file with that name 
+ * create the next filename and open a new binary file with that name
  */
 static int ringbuf_open_file(rb_file *rfile, int *err)
 {
@@ -117,7 +104,7 @@ static int ringbuf_open_file(rb_file *rfile, int *err)
   if (rfile->name != NULL) {
     if (rb_data.unlimited == FALSE) {
       /* remove old file (if any, so ignore error) */
-      unlink(rfile->name);
+      ws_unlink(rfile->name);
     }
     g_free(rfile->name);
   }
@@ -127,7 +114,7 @@ static int ringbuf_open_file(rb_file *rfile, int *err)
 #endif
   current_time = time(NULL);
 
-  snprintf(filenum, sizeof(filenum), "%05d", rb_data.curr_file_num + 1 /*.number*/);
+  g_snprintf(filenum, sizeof(filenum), "%05u", (rb_data.curr_file_num + 1) % RINGBUFFER_MAX_NUM_FILES);
   strftime(timestr, sizeof(timestr), "%Y%m%d%H%M%S", localtime(&current_time));
   rfile->name = g_strconcat(rb_data.fprefix, "_", filenum, "_", timestr,
                            rb_data.fsuffix, NULL);
@@ -137,7 +124,8 @@ static int ringbuf_open_file(rb_file *rfile, int *err)
     return -1;
   }
 
-  rb_data.fd = open(rfile->name, O_RDWR|O_BINARY|O_TRUNC|O_CREAT, 0600);
+  rb_data.fd = ws_open(rfile->name, O_RDWR|O_BINARY|O_TRUNC|O_CREAT, 
+                            rb_data.group_read_access ? 0640 : 0600);
 
   if (rb_data.fd == -1 && err != NULL) {
     *err = errno;
@@ -150,7 +138,7 @@ static int ringbuf_open_file(rb_file *rfile, int *err)
  * Initialize the ringbuffer data structures
  */
 int
-ringbuf_init(const char *capfile_name, guint num_files)
+ringbuf_init(const char *capfile_name, guint num_files, gboolean group_read_access)
 {
   unsigned int i;
   char        *pfx, *last_pathsep;
@@ -163,6 +151,7 @@ ringbuf_init(const char *capfile_name, guint num_files)
   rb_data.unlimited = FALSE;
   rb_data.fd = -1;
   rb_data.pdh = NULL;
+  rb_data.group_read_access = group_read_access;
 
   /* just to be sure ... */
   if (num_files <= RINGBUFFER_MAX_NUM_FILES) {
@@ -214,7 +203,7 @@ ringbuf_init(const char *capfile_name, guint num_files)
     rb_data.num_files = 1;
   }
 
-  rb_data.files = g_malloc(rb_data.num_files * sizeof(rb_file));
+  rb_data.files = (rb_file *)g_malloc(rb_data.num_files * sizeof(rb_file));
   if (rb_data.files == NULL) {
     return -1;
   }
@@ -232,19 +221,19 @@ ringbuf_init(const char *capfile_name, guint num_files)
   return rb_data.fd;
 }
 
+
+const gchar *ringbuf_current_filename(void)
+{
+  return rb_data.files[rb_data.curr_file_num % rb_data.num_files].name;
+}
+
 /*
- * Calls wtap_dump_fdopen() for the current ringbuffer file
+ * Calls libpcap_fdopen() for the current ringbuffer file
  */
-wtap_dumper*
-ringbuf_init_wtap_dump_fdopen(int filetype, int linktype, int snaplen, int *err)
+FILE *
+ringbuf_init_libpcap_fdopen(int *err)
 {
-
-  rb_data.filetype = filetype;
-  rb_data.linktype = linktype;
-  rb_data.snaplen  = snaplen;
-
-  rb_data.pdh = wtap_dump_fdopen(rb_data.fd, filetype, linktype, snaplen, err);
-
+  rb_data.pdh = libpcap_fdopen(rb_data.fd, err);
   return rb_data.pdh;
 }
 
@@ -252,15 +241,15 @@ ringbuf_init_wtap_dump_fdopen(int filetype, int linktype, int snaplen, int *err)
  * Switches to the next ringbuffer file
  */
 gboolean
-ringbuf_switch_file(capture_file *cf, wtap_dumper **pdh, int *err)
+ringbuf_switch_file(FILE **pdh, gchar **save_file, int *save_file_fd, int *err)
 {
-  int     next_file_num;
+  int     next_file_index;
   rb_file *next_rfile = NULL;
 
   /* close current file */
 
-  if (!wtap_dump_close(rb_data.pdh, err)) {
-    close(rb_data.fd); /* XXX - the above should have closed this already */
+  if (!libpcap_dump_close(rb_data.pdh, err)) {
+    ws_close(rb_data.fd);      /* XXX - the above should have closed this already */
     rb_data.pdh = NULL;        /* it's still closed, we just got an error while closing */
     rb_data.fd = -1;
     return FALSE;
@@ -271,39 +260,38 @@ ringbuf_switch_file(capture_file *cf, wtap_dumper **pdh, int *err)
 
   /* get the next file number and open it */
 
-  next_file_num = (rb_data.curr_file_num + 1) % rb_data.num_files;  
-  next_rfile = &rb_data.files[next_file_num];
+  rb_data.curr_file_num++ /* = next_file_num*/;
+  next_file_index = (rb_data.curr_file_num) % rb_data.num_files;
+  next_rfile = &rb_data.files[next_file_index];
 
   if (ringbuf_open_file(next_rfile, err) == -1) {
     return FALSE;
   }
 
-  if (ringbuf_init_wtap_dump_fdopen(rb_data.filetype, rb_data.linktype,
-                                   rb_data.snaplen, err) == NULL) {
+  if (ringbuf_init_libpcap_fdopen(err) == NULL) {
     return FALSE;
   }
 
   /* switch to the new file */
-  rb_data.curr_file_num = next_file_num;
-  cf->save_file = next_rfile->name;
-  cf->save_file_fd = rb_data.fd;
+  *save_file = next_rfile->name;
+  *save_file_fd = rb_data.fd;
   (*pdh) = rb_data.pdh;
 
   return TRUE;
 }
 
 /*
- * Calls wtap_dump_close() for the current ringbuffer file
+ * Calls libpcap_dump_close() for the current ringbuffer file
  */
 gboolean
-ringbuf_wtap_dump_close(capture_file *cf, int *err)
+ringbuf_libpcap_dump_close(gchar **save_file, int *err)
 {
   gboolean  ret_val = TRUE;
 
   /* close current file, if it's open */
   if (rb_data.pdh != NULL) {
-    if (!wtap_dump_close(rb_data.pdh, err)) {
-      close(rb_data.fd);
+    if (!libpcap_dump_close(rb_data.pdh, err)) {
+      ws_close(rb_data.fd);
       ret_val = FALSE;
     }
 
@@ -312,7 +300,7 @@ ringbuf_wtap_dump_close(capture_file *cf, int *err)
   }
 
   /* set the save file name to the current file */
-  cf->save_file = rb_data.files[rb_data.curr_file_num].name;
+  *save_file = rb_data.files[rb_data.curr_file_num % rb_data.num_files].name;
   return ret_val;
 }
 
@@ -320,7 +308,7 @@ ringbuf_wtap_dump_close(capture_file *cf, int *err)
  * Frees all memory allocated by the ringbuffer
  */
 void
-ringbuf_free()
+ringbuf_free(void)
 {
   unsigned int i;
 
@@ -354,24 +342,24 @@ ringbuf_error_cleanup(void)
 
   /* try to close via wtap */
   if (rb_data.pdh != NULL) {
-    if (wtap_dump_close(rb_data.pdh, NULL)) {
+    if (libpcap_dump_close(rb_data.pdh, NULL)) {
       rb_data.fd = -1;
     }
     rb_data.pdh = NULL;
   }
 
   /* close directly if still open */
-  /* XXX - it shouldn't still be open; "wtap_dump_close()" should leave the
+  /* XXX - it shouldn't still be open; "libpcap_dump_close()" should leave the
      file closed even if it fails */
   if (rb_data.fd != -1) {
-    close(rb_data.fd);
+    ws_close(rb_data.fd);
     rb_data.fd = -1;
   }
 
   if (rb_data.files != NULL) {
     for (i=0; i < rb_data.num_files; i++) {
       if (rb_data.files[i].name != NULL) {
-        unlink(rb_data.files[i].name);
+        ws_unlink(rb_data.files[i].name);
       }
     }
   }