ringbuffer.c

   1 /* ringbuffer.c
   2  * Routines for packet capture windows
   3  *
   4  * $Id$
   5  *
   6  * Ethereal - Network traffic analyzer
   7  * By Gerald Combs <gerald@ethereal.com>
   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_IO_H
  52 #include <io.h>
  53 #endif
  54
  55 #ifdef HAVE_FCNTL_H
  56 #include <fcntl.h>
  57 #endif
  58
  59 #ifdef HAVE_SYS_STAT_H
  60 #include <sys/stat.h>
  61 #endif
  62
  63 #ifdef HAVE_UNISTD_H
  64 #include <unistd.h>
  65 #endif
  66
  67 #include <stdio.h>
  68 #include <string.h>
  69 #include <time.h>
  70 #include <errno.h>
  71
  72 #include "wiretap/wtap.h"
  73 #include "ringbuffer.h"
  74
  75 /* Win32 needs the O_BINARY flag for open() */
  76 #ifndef O_BINARY
  77 #define O_BINARY        0
  78 #endif
  79
  80 /* Ringbuffer file structure */
  81 typedef struct _rb_file {
  82   gchar         *name;
  83 } rb_file;
  84
  85 /* Ringbuffer data structure */
  86 typedef struct _ringbuf_data {
  87   rb_file      *files;
  88   guint         num_files;           /* Number of ringbuffer files */
  89   guint         curr_file_num;       /* Number of the current file */
  90   gchar        *fprefix;             /* Filename prefix */
  91   gchar        *fsuffix;             /* Filename suffix */
  92   gboolean      unlimited;           /* TRUE if unlimited number of files */
  93   int           filetype;
  94   int           linktype;
  95   int           snaplen;
  96
  97   int           fd;                  /* Current ringbuffer file descriptor */
  98   wtap_dumper  *pdh;
  99 } ringbuf_data;
 100
 101 static ringbuf_data rb_data;
 102
 103
 104 /*
 105  * create the next filename and open a new binary file with that name
 106  */
 107 static int ringbuf_open_file(rb_file *rfile, int *err)
 108 {
 109   char    filenum[5+1];
 110   char    timestr[14+1];
 111   time_t  current_time;
 112
 113   if (rfile->name != NULL) {
 114     if (rb_data.unlimited == FALSE) {
 115       /* remove old file (if any, so ignore error) */
 116       unlink(rfile->name);
 117     }
 118     g_free(rfile->name);
 119   }
 120
 121 #ifdef _WIN32
 122   _tzset();
 123 #endif
 124   current_time = time(NULL);
 125
 126   g_snprintf(filenum, sizeof(filenum), "%05d", rb_data.curr_file_num + 1 /*.number*/);
 127   strftime(timestr, sizeof(timestr), "%Y%m%d%H%M%S", localtime(&current_time));
 128   rfile->name = g_strconcat(rb_data.fprefix, "_", filenum, "_", timestr,
 129                             rb_data.fsuffix, NULL);
 130
 131   if (rfile->name == NULL) {
 132     *err = ENOMEM;
 133     return -1;
 134   }
 135
 136   rb_data.fd = open(rfile->name, O_RDWR|O_BINARY|O_TRUNC|O_CREAT, 0600);
 137
 138   if (rb_data.fd == -1 && err != NULL) {
 139     *err = errno;
 140   }
 141
 142   return rb_data.fd;
 143 }
 144
 145 /*
 146  * Initialize the ringbuffer data structures
 147  */
 148 int
 149 ringbuf_init(const char *capfile_name, guint num_files)
 150 {
 151   unsigned int i;
 152   char        *pfx, *last_pathsep;
 153   gchar       *save_file;
 154
 155   rb_data.files = NULL;
 156   rb_data.curr_file_num = 0;
 157   rb_data.fprefix = NULL;
 158   rb_data.fsuffix = NULL;
 159   rb_data.unlimited = FALSE;
 160   rb_data.fd = -1;
 161   rb_data.pdh = NULL;
 162
 163   /* just to be sure ... */
 164   if (num_files <= RINGBUFFER_MAX_NUM_FILES) {
 165     rb_data.num_files = num_files;
 166   } else {
 167     rb_data.num_files = RINGBUFFER_MAX_NUM_FILES;
 168   }
 169
 170   /* Check file name */
 171   if (capfile_name == NULL) {
 172     /* ringbuffer does not work with temporary files! */
 173     return -1;
 174   }
 175
 176   /* set file name prefix/suffix */
 177
 178   save_file = g_strdup(capfile_name);
 179   last_pathsep = strrchr(save_file, G_DIR_SEPARATOR);
 180   pfx = strrchr(save_file,'.');
 181   if (pfx != NULL && (last_pathsep == NULL || pfx > last_pathsep)) {
 182     /* The pathname has a "." in it, and it's in the last component
 183        of the pathname (because there is either only one component,
 184        i.e. last_pathsep is null as there are no path separators,
 185        or the "." is after the path separator before the last
 186        component.
 187
 188        Treat it as a separator between the rest of the file name and
 189        the file name suffix, and arrange that the names given to the
 190        ring buffer files have the specified suffix, i.e. put the
 191        changing part of the name *before* the suffix. */
 192     pfx[0] = '\0';
 193     rb_data.fprefix = g_strdup(save_file);
 194     pfx[0] = '.'; /* restore capfile_name */
 195     rb_data.fsuffix = g_strdup(pfx);
 196   } else {
 197     /* Either there's no "." in the pathname, or it's in a directory
 198        component, so the last component has no suffix. */
 199     rb_data.fprefix = g_strdup(save_file);
 200     rb_data.fsuffix = NULL;
 201   }
 202   g_free(save_file);
 203   save_file = NULL;
 204
 205   /* allocate rb_file structures (only one if unlimited since there is no
 206      need to save all file names in that case) */
 207
 208   if (num_files == RINGBUFFER_UNLIMITED_FILES) {
 209     rb_data.unlimited = TRUE;
 210     rb_data.num_files = 1;
 211   }
 212
 213   rb_data.files = g_malloc(rb_data.num_files * sizeof(rb_file));
 214   if (rb_data.files == NULL) {
 215     return -1;
 216   }
 217
 218   for (i=0; i < rb_data.num_files; i++) {
 219     rb_data.files[i].name = NULL;
 220   }
 221
 222   /* create the first file */
 223   if (ringbuf_open_file(&rb_data.files[0], NULL) == -1) {
 224     ringbuf_error_cleanup();
 225     return -1;
 226   }
 227
 228   return rb_data.fd;
 229 }
 230
 231
 232 const gchar *ringbuf_current_filename(void)
 233 {
 234   return rb_data.files[rb_data.curr_file_num % rb_data.num_files].name;
 235 }
 236
 237 /*
 238  * Calls wtap_dump_fdopen() for the current ringbuffer file
 239  */
 240 wtap_dumper*
 241 ringbuf_init_wtap_dump_fdopen(int filetype, int linktype, int snaplen, int *err)
 242 {
 243
 244   rb_data.filetype = filetype;
 245   rb_data.linktype = linktype;
 246   rb_data.snaplen  = snaplen;
 247
 248   rb_data.pdh = wtap_dump_fdopen(rb_data.fd, filetype, linktype, snaplen, err);
 249
 250   return rb_data.pdh;
 251 }
 252
 253 /*
 254  * Switches to the next ringbuffer file
 255  */
 256 gboolean
 257 ringbuf_switch_file(wtap_dumper **pdh, gchar **save_file, int *save_file_fd, int *err)
 258 {
 259   int     next_file_num;
 260   rb_file *next_rfile = NULL;
 261
 262   /* close current file */
 263
 264   if (!wtap_dump_close(rb_data.pdh, err)) {
 265     close(rb_data.fd);  /* XXX - the above should have closed this already */
 266     rb_data.pdh = NULL; /* it's still closed, we just got an error while closing */
 267     rb_data.fd = -1;
 268     return FALSE;
 269   }
 270
 271   rb_data.pdh = NULL;
 272   rb_data.fd  = -1;
 273
 274   /* get the next file number and open it */
 275
 276   next_file_num = (rb_data.curr_file_num + 1) % rb_data.num_files;
 277   next_rfile = &rb_data.files[next_file_num];
 278
 279   if (ringbuf_open_file(next_rfile, err) == -1) {
 280     return FALSE;
 281   }
 282
 283   if (ringbuf_init_wtap_dump_fdopen(rb_data.filetype, rb_data.linktype,
 284                                     rb_data.snaplen, err) == NULL) {
 285     return FALSE;
 286   }
 287
 288   /* switch to the new file */
 289   rb_data.curr_file_num = next_file_num;
 290   *save_file = next_rfile->name;
 291   *save_file_fd = rb_data.fd;
 292   (*pdh) = rb_data.pdh;
 293
 294   return TRUE;
 295 }
 296
 297 /*
 298  * Calls wtap_dump_close() for the current ringbuffer file
 299  */
 300 gboolean
 301 ringbuf_wtap_dump_close(gchar **save_file, int *err)
 302 {
 303   gboolean  ret_val = TRUE;
 304
 305   /* close current file, if it's open */
 306   if (rb_data.pdh != NULL) {
 307     if (!wtap_dump_close(rb_data.pdh, err)) {
 308       close(rb_data.fd);
 309       ret_val = FALSE;
 310     }
 311
 312     rb_data.pdh = NULL;
 313     rb_data.fd  = -1;
 314   }
 315
 316   /* set the save file name to the current file */
 317   *save_file = rb_data.files[rb_data.curr_file_num].name;
 318   return ret_val;
 319 }
 320
 321 /*
 322  * Frees all memory allocated by the ringbuffer
 323  */
 324 void
 325 ringbuf_free()
 326 {
 327   unsigned int i;
 328
 329   if (rb_data.files != NULL) {
 330     for (i=0; i < rb_data.num_files; i++) {
 331       if (rb_data.files[i].name != NULL) {
 332         g_free(rb_data.files[i].name);
 333         rb_data.files[i].name = NULL;
 334       }
 335     }
 336     g_free(rb_data.files);
 337     rb_data.files = NULL;
 338   }
 339   if (rb_data.fprefix != NULL) {
 340     g_free(rb_data.fprefix);
 341     rb_data.fprefix = NULL;
 342   }
 343   if (rb_data.fsuffix != NULL) {
 344     g_free(rb_data.fsuffix);
 345     rb_data.fsuffix = NULL;
 346   }
 347 }
 348
 349 /*
 350  * Frees all memory allocated by the ringbuffer
 351  */
 352 void
 353 ringbuf_error_cleanup(void)
 354 {
 355   unsigned int i;
 356
 357   /* try to close via wtap */
 358   if (rb_data.pdh != NULL) {
 359     if (wtap_dump_close(rb_data.pdh, NULL)) {
 360       rb_data.fd = -1;
 361     }
 362     rb_data.pdh = NULL;
 363   }
 364
 365   /* close directly if still open */
 366   /* XXX - it shouldn't still be open; "wtap_dump_close()" should leave the
 367      file closed even if it fails */
 368   if (rb_data.fd != -1) {
 369     close(rb_data.fd);
 370     rb_data.fd = -1;
 371   }
 372
 373   if (rb_data.files != NULL) {
 374     for (i=0; i < rb_data.num_files; i++) {
 375       if (rb_data.files[i].name != NULL) {
 376         unlink(rb_data.files[i].name);
 377       }
 378     }
 379   }
 380   /* free the memory */
 381   ringbuf_free();
 382 }
 383
 384 #endif /* HAVE_LIBPCAP */