ringbuffer.c

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