ringbuffer.c

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