ringbuffer.c

   1 /* ringbuffer.c
   2  * Routines for packet capture windows
   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 /*
  26  * <laurent.deniel@free.fr>
  27  *
  28  * Almost completely rewritten in order to:
  29  *
  30  * - be able to use a unlimited number of ringbuffer files
  31  * - close the current file and open (truncating) the next file at switch
  32  * - set the final file name once open (or reopen)
  33  * - avoid the deletion of files that could not be truncated (can't arise now)
  34  *   and do not erase empty files
  35  *
  36  * The idea behind that is to remove the limitation of the maximum # of
  37  * ringbuffer files being less than the maximum # of open fd per process
  38  * and to be able to reduce the amount of virtual memory usage (having only
  39  * one file open at most) or the amount of file system usage (by truncating
  40  * the files at switch and not the capture stop, and by closing them which
  41  * makes possible their move or deletion after a switch).
  42  *
  43  */
  44
  45 #ifdef HAVE_CONFIG_H
  46 #include "config.h"
  47 #endif
  48
  49 #ifdef HAVE_LIBPCAP
  50
  51 #ifdef HAVE_FCNTL_H
  52 #include <fcntl.h>
  53 #endif
  54
  55 #ifdef HAVE_UNISTD_H
  56 #include <unistd.h>
  57 #endif
  58
  59 #include <stdio.h>
  60 #include <string.h>
  61 #include <time.h>
  62 #include <errno.h>
  63
  64 #include <pcap.h>
  65
  66 #include <glib.h>
  67
  68 #include "pcapio.h"
  69 #include "ringbuffer.h"
  70 #include <wsutil/file_util.h>
  71
  72
  73 /* Ringbuffer file structure */
  74 typedef struct _rb_file {
  75   gchar         *name;
  76 } rb_file;
  77
  78 /* Ringbuffer data structure */
  79 typedef struct _ringbuf_data {
  80   rb_file      *files;
  81   guint         num_files;           /* Number of ringbuffer files (1 to ...) */
  82   guint         curr_file_num;       /* Number of the current file (ever increasing) */
  83   gchar        *fprefix;             /* Filename prefix */
  84   gchar        *fsuffix;             /* Filename suffix */
  85   gboolean      unlimited;           /* TRUE if unlimited number of files */
  86
  87   int           fd;                  /* Current ringbuffer file descriptor */
  88   FILE         *pdh;
  89   gboolean      group_read_access;   /* TRUE if files need to be opened with group read access */
  90 } ringbuf_data;
  91
  92 static ringbuf_data rb_data;
  93
  94
  95 /*
  96  * create the next filename and open a new binary file with that name
  97  */
  98 static int ringbuf_open_file(rb_file *rfile, int *err)
  99 {
 100   char    filenum[5+1];
 101   char    timestr[14+1];
 102   time_t  current_time;
 103
 104   if (rfile->name != NULL) {
 105     if (rb_data.unlimited == FALSE) {
 106       /* remove old file (if any, so ignore error) */
 107       ws_unlink(rfile->name);
 108     }
 109     g_free(rfile->name);
 110   }
 111
 112 #ifdef _WIN32
 113   _tzset();
 114 #endif
 115   current_time = time(NULL);
 116
 117   g_snprintf(filenum, sizeof(filenum), "%05u", (rb_data.curr_file_num + 1) % RINGBUFFER_MAX_NUM_FILES);
 118   strftime(timestr, sizeof(timestr), "%Y%m%d%H%M%S", localtime(&current_time));
 119   rfile->name = g_strconcat(rb_data.fprefix, "_", filenum, "_", timestr,
 120                             rb_data.fsuffix, NULL);
 121
 122   if (rfile->name == NULL) {
 123     *err = ENOMEM;
 124     return -1;
 125   }
 126
 127   rb_data.fd = ws_open(rfile->name, O_RDWR|O_BINARY|O_TRUNC|O_CREAT,
 128                             rb_data.group_read_access ? 0640 : 0600);
 129
 130   if (rb_data.fd == -1 && err != NULL) {
 131     *err = errno;
 132   }
 133
 134   return rb_data.fd;
 135 }
 136
 137 /*
 138  * Initialize the ringbuffer data structures
 139  */
 140 int
 141 ringbuf_init(const char *capfile_name, guint num_files, gboolean group_read_access)
 142 {
 143   unsigned int i;
 144   char        *pfx, *last_pathsep;
 145   gchar       *save_file;
 146
 147   rb_data.files = NULL;
 148   rb_data.curr_file_num = 0;
 149   rb_data.fprefix = NULL;
 150   rb_data.fsuffix = NULL;
 151   rb_data.unlimited = FALSE;
 152   rb_data.fd = -1;
 153   rb_data.pdh = NULL;
 154   rb_data.group_read_access = group_read_access;
 155
 156   /* just to be sure ... */
 157   if (num_files <= RINGBUFFER_MAX_NUM_FILES) {
 158     rb_data.num_files = num_files;
 159   } else {
 160     rb_data.num_files = RINGBUFFER_MAX_NUM_FILES;
 161   }
 162
 163   /* Check file name */
 164   if (capfile_name == NULL) {
 165     /* ringbuffer does not work with temporary files! */
 166     return -1;
 167   }
 168
 169   /* set file name prefix/suffix */
 170
 171   save_file = g_strdup(capfile_name);
 172   last_pathsep = strrchr(save_file, G_DIR_SEPARATOR);
 173   pfx = strrchr(save_file,'.');
 174   if (pfx != NULL && (last_pathsep == NULL || pfx > last_pathsep)) {
 175     /* The pathname has a "." in it, and it's in the last component
 176        of the pathname (because there is either only one component,
 177        i.e. last_pathsep is null as there are no path separators,
 178        or the "." is after the path separator before the last
 179        component.
 180
 181        Treat it as a separator between the rest of the file name and
 182        the file name suffix, and arrange that the names given to the
 183        ring buffer files have the specified suffix, i.e. put the
 184        changing part of the name *before* the suffix. */
 185     pfx[0] = '\0';
 186     rb_data.fprefix = g_strdup(save_file);
 187     pfx[0] = '.'; /* restore capfile_name */
 188     rb_data.fsuffix = g_strdup(pfx);
 189   } else {
 190     /* Either there's no "." in the pathname, or it's in a directory
 191        component, so the last component has no suffix. */
 192     rb_data.fprefix = g_strdup(save_file);
 193     rb_data.fsuffix = NULL;
 194   }
 195   g_free(save_file);
 196   save_file = NULL;
 197
 198   /* allocate rb_file structures (only one if unlimited since there is no
 199      need to save all file names in that case) */
 200
 201   if (num_files == RINGBUFFER_UNLIMITED_FILES) {
 202     rb_data.unlimited = TRUE;
 203     rb_data.num_files = 1;
 204   }
 205
 206   rb_data.files = (rb_file *)g_malloc(rb_data.num_files * sizeof(rb_file));
 207   if (rb_data.files == NULL) {
 208     return -1;
 209   }
 210
 211   for (i=0; i < rb_data.num_files; i++) {
 212     rb_data.files[i].name = NULL;
 213   }
 214
 215   /* create the first file */
 216   if (ringbuf_open_file(&rb_data.files[0], NULL) == -1) {
 217     ringbuf_error_cleanup();
 218     return -1;
 219   }
 220
 221   return rb_data.fd;
 222 }
 223
 224
 225 const gchar *ringbuf_current_filename(void)
 226 {
 227   return rb_data.files[rb_data.curr_file_num % rb_data.num_files].name;
 228 }
 229
 230 /*
 231  * Calls libpcap_fdopen() for the current ringbuffer file
 232  */
 233 FILE *
 234 ringbuf_init_libpcap_fdopen(int *err)
 235 {
 236   rb_data.pdh = libpcap_fdopen(rb_data.fd, err);
 237   return rb_data.pdh;
 238 }
 239
 240 /*
 241  * Switches to the next ringbuffer file
 242  */
 243 gboolean
 244 ringbuf_switch_file(FILE **pdh, gchar **save_file, int *save_file_fd, int *err)
 245 {
 246   int     next_file_index;
 247   rb_file *next_rfile = NULL;
 248
 249   /* close current file */
 250
 251   if (!libpcap_dump_close(rb_data.pdh, err)) {
 252     ws_close(rb_data.fd);       /* XXX - the above should have closed this already */
 253     rb_data.pdh = NULL; /* it's still closed, we just got an error while closing */
 254     rb_data.fd = -1;
 255     return FALSE;
 256   }
 257
 258   rb_data.pdh = NULL;
 259   rb_data.fd  = -1;
 260
 261   /* get the next file number and open it */
 262
 263   rb_data.curr_file_num++ /* = next_file_num*/;
 264   next_file_index = (rb_data.curr_file_num) % rb_data.num_files;
 265   next_rfile = &rb_data.files[next_file_index];
 266
 267   if (ringbuf_open_file(next_rfile, err) == -1) {
 268     return FALSE;
 269   }
 270
 271   if (ringbuf_init_libpcap_fdopen(err) == NULL) {
 272     return FALSE;
 273   }
 274
 275   /* switch to the new file */
 276   *save_file = next_rfile->name;
 277   *save_file_fd = rb_data.fd;
 278   (*pdh) = rb_data.pdh;
 279
 280   return TRUE;
 281 }
 282
 283 /*
 284  * Calls libpcap_dump_close() for the current ringbuffer file
 285  */
 286 gboolean
 287 ringbuf_libpcap_dump_close(gchar **save_file, int *err)
 288 {
 289   gboolean  ret_val = TRUE;
 290
 291   /* close current file, if it's open */
 292   if (rb_data.pdh != NULL) {
 293     if (!libpcap_dump_close(rb_data.pdh, err)) {
 294       ws_close(rb_data.fd);
 295       ret_val = FALSE;
 296     }
 297
 298     rb_data.pdh = NULL;
 299     rb_data.fd  = -1;
 300   }
 301
 302   /* set the save file name to the current file */
 303   *save_file = rb_data.files[rb_data.curr_file_num % rb_data.num_files].name;
 304   return ret_val;
 305 }
 306
 307 /*
 308  * Frees all memory allocated by the ringbuffer
 309  */
 310 void
 311 ringbuf_free()
 312 {
 313   unsigned int i;
 314
 315   if (rb_data.files != NULL) {
 316     for (i=0; i < rb_data.num_files; i++) {
 317       if (rb_data.files[i].name != NULL) {
 318         g_free(rb_data.files[i].name);
 319         rb_data.files[i].name = NULL;
 320       }
 321     }
 322     g_free(rb_data.files);
 323     rb_data.files = NULL;
 324   }
 325   if (rb_data.fprefix != NULL) {
 326     g_free(rb_data.fprefix);
 327     rb_data.fprefix = NULL;
 328   }
 329   if (rb_data.fsuffix != NULL) {
 330     g_free(rb_data.fsuffix);
 331     rb_data.fsuffix = NULL;
 332   }
 333 }
 334
 335 /*
 336  * Frees all memory allocated by the ringbuffer
 337  */
 338 void
 339 ringbuf_error_cleanup(void)
 340 {
 341   unsigned int i;
 342
 343   /* try to close via wtap */
 344   if (rb_data.pdh != NULL) {
 345     if (libpcap_dump_close(rb_data.pdh, NULL)) {
 346       rb_data.fd = -1;
 347     }
 348     rb_data.pdh = NULL;
 349   }
 350
 351   /* close directly if still open */
 352   /* XXX - it shouldn't still be open; "libpcap_dump_close()" should leave the
 353      file closed even if it fails */
 354   if (rb_data.fd != -1) {
 355     ws_close(rb_data.fd);
 356     rb_data.fd = -1;
 357   }
 358
 359   if (rb_data.files != NULL) {
 360     for (i=0; i < rb_data.num_files; i++) {
 361       if (rb_data.files[i].name != NULL) {
 362         ws_unlink(rb_data.files[i].name);
 363       }
 364     }
 365   }
 366   /* free the memory */
 367   ringbuf_free();
 368 }
 369
 370 #endif /* HAVE_LIBPCAP */