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 <wsutil/wspcap.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   struct tm *tm;
  91
  92   if (rfile->name != NULL) {
  93     if (rb_data.unlimited == FALSE) {
  94       /* remove old file (if any, so ignore error) */
  95       ws_unlink(rfile->name);
  96     }
  97     g_free(rfile->name);
  98   }
  99
 100 #ifdef _WIN32
 101   _tzset();
 102 #endif
 103   current_time = time(NULL);
 104
 105   g_snprintf(filenum, sizeof(filenum), "%05u", (rb_data.curr_file_num + 1) % RINGBUFFER_MAX_NUM_FILES);
 106   tm = localtime(&current_time);
 107   if (tm != NULL)
 108     strftime(timestr, sizeof(timestr), "%Y%m%d%H%M%S", tm);
 109   else
 110     g_strlcpy(timestr, "196912312359", sizeof(timestr)); /* second before the Epoch */
 111   rfile->name = g_strconcat(rb_data.fprefix, "_", filenum, "_", timestr,
 112                             rb_data.fsuffix, NULL);
 113
 114   if (rfile->name == NULL) {
 115     if (err != NULL)
 116       *err = ENOMEM;
 117     return -1;
 118   }
 119
 120   rb_data.fd = ws_open(rfile->name, O_RDWR|O_BINARY|O_TRUNC|O_CREAT,
 121                             rb_data.group_read_access ? 0640 : 0600);
 122
 123   if (rb_data.fd == -1 && err != NULL) {
 124     *err = errno;
 125   }
 126
 127   return rb_data.fd;
 128 }
 129
 130 /*
 131  * Initialize the ringbuffer data structures
 132  */
 133 int
 134 ringbuf_init(const char *capfile_name, guint num_files, gboolean group_read_access)
 135 {
 136   unsigned int i;
 137   char        *pfx, *last_pathsep;
 138   gchar       *save_file;
 139
 140   rb_data.files = NULL;
 141   rb_data.curr_file_num = 0;
 142   rb_data.fprefix = NULL;
 143   rb_data.fsuffix = NULL;
 144   rb_data.unlimited = FALSE;
 145   rb_data.fd = -1;
 146   rb_data.pdh = NULL;
 147   rb_data.group_read_access = group_read_access;
 148
 149   /* just to be sure ... */
 150   if (num_files <= RINGBUFFER_MAX_NUM_FILES) {
 151     rb_data.num_files = num_files;
 152   } else {
 153     rb_data.num_files = RINGBUFFER_MAX_NUM_FILES;
 154   }
 155
 156   /* Check file name */
 157   if (capfile_name == NULL) {
 158     /* ringbuffer does not work with temporary files! */
 159     return -1;
 160   }
 161
 162   /* set file name prefix/suffix */
 163
 164   save_file = g_strdup(capfile_name);
 165   last_pathsep = strrchr(save_file, G_DIR_SEPARATOR);
 166   pfx = strrchr(save_file,'.');
 167   if (pfx != NULL && (last_pathsep == NULL || pfx > last_pathsep)) {
 168     /* The pathname has a "." in it, and it's in the last component
 169        of the pathname (because there is either only one component,
 170        i.e. last_pathsep is null as there are no path separators,
 171        or the "." is after the path separator before the last
 172        component.
 173
 174        Treat it as a separator between the rest of the file name and
 175        the file name suffix, and arrange that the names given to the
 176        ring buffer files have the specified suffix, i.e. put the
 177        changing part of the name *before* the suffix. */
 178     pfx[0] = '\0';
 179     rb_data.fprefix = g_strdup(save_file);
 180     pfx[0] = '.'; /* restore capfile_name */
 181     rb_data.fsuffix = g_strdup(pfx);
 182   } else {
 183     /* Either there's no "." in the pathname, or it's in a directory
 184        component, so the last component has no suffix. */
 185     rb_data.fprefix = g_strdup(save_file);
 186     rb_data.fsuffix = NULL;
 187   }
 188   g_free(save_file);
 189   save_file = NULL;
 190
 191   /* allocate rb_file structures (only one if unlimited since there is no
 192      need to save all file names in that case) */
 193
 194   if (num_files == RINGBUFFER_UNLIMITED_FILES) {
 195     rb_data.unlimited = TRUE;
 196     rb_data.num_files = 1;
 197   }
 198
 199   rb_data.files = (rb_file *)g_malloc(rb_data.num_files * sizeof(rb_file));
 200   if (rb_data.files == NULL) {
 201     return -1;
 202   }
 203
 204   for (i=0; i < rb_data.num_files; i++) {
 205     rb_data.files[i].name = NULL;
 206   }
 207
 208   /* create the first file */
 209   if (ringbuf_open_file(&rb_data.files[0], NULL) == -1) {
 210     ringbuf_error_cleanup();
 211     return -1;
 212   }
 213
 214   return rb_data.fd;
 215 }
 216
 217
 218 const gchar *ringbuf_current_filename(void)
 219 {
 220   return rb_data.files[rb_data.curr_file_num % rb_data.num_files].name;
 221 }
 222
 223 /*
 224  * Calls ws_fdopen() for the current ringbuffer file
 225  */
 226 FILE *
 227 ringbuf_init_libpcap_fdopen(int *err)
 228 {
 229   rb_data.pdh = ws_fdopen(rb_data.fd, "wb");
 230   if (rb_data.pdh == NULL) {
 231     if (err != NULL) {
 232       *err = errno;
 233     }
 234   }
 235   return rb_data.pdh;
 236 }
 237
 238 /*
 239  * Switches to the next ringbuffer file
 240  */
 241 gboolean
 242 ringbuf_switch_file(FILE **pdh, gchar **save_file, int *save_file_fd, int *err)
 243 {
 244   int     next_file_index;
 245   rb_file *next_rfile = NULL;
 246
 247   /* close current file */
 248
 249   if (fclose(rb_data.pdh) == EOF) {
 250     if (err != NULL) {
 251       *err = errno;
 252     }
 253     ws_close(rb_data.fd);  /* XXX - the above should have closed this already */
 254     rb_data.pdh = NULL;    /* it's still closed, we just got an error while closing */
 255     rb_data.fd = -1;
 256     return FALSE;
 257   }
 258
 259   rb_data.pdh = NULL;
 260   rb_data.fd  = -1;
 261
 262   /* get the next file number and open it */
 263
 264   rb_data.curr_file_num++ /* = next_file_num*/;
 265   next_file_index = (rb_data.curr_file_num) % rb_data.num_files;
 266   next_rfile = &rb_data.files[next_file_index];
 267
 268   if (ringbuf_open_file(next_rfile, err) == -1) {
 269     return FALSE;
 270   }
 271
 272   if (ringbuf_init_libpcap_fdopen(err) == NULL) {
 273     return FALSE;
 274   }
 275
 276   /* switch to the new file */
 277   *save_file = next_rfile->name;
 278   *save_file_fd = rb_data.fd;
 279   (*pdh) = rb_data.pdh;
 280
 281   return TRUE;
 282 }
 283
 284 /*
 285  * Calls fclose() for the current ringbuffer file
 286  */
 287 gboolean
 288 ringbuf_libpcap_dump_close(gchar **save_file, int *err)
 289 {
 290   gboolean  ret_val = TRUE;
 291
 292   /* close current file, if it's open */
 293   if (rb_data.pdh != NULL) {
 294     if (fclose(rb_data.pdh) == EOF) {
 295       if (err != NULL) {
 296         *err = errno;
 297       }
 298       ws_close(rb_data.fd);
 299       ret_val = FALSE;
 300     }
 301     rb_data.pdh = NULL;
 302     rb_data.fd  = -1;
 303   }
 304
 305   /* set the save file name to the current file */
 306   *save_file = rb_data.files[rb_data.curr_file_num % rb_data.num_files].name;
 307   return ret_val;
 308 }
 309
 310 /*
 311  * Frees all memory allocated by the ringbuffer
 312  */
 313 void
 314 ringbuf_free(void)
 315 {
 316   unsigned int i;
 317
 318   if (rb_data.files != NULL) {
 319     for (i=0; i < rb_data.num_files; i++) {
 320       if (rb_data.files[i].name != NULL) {
 321         g_free(rb_data.files[i].name);
 322         rb_data.files[i].name = NULL;
 323       }
 324     }
 325     g_free(rb_data.files);
 326     rb_data.files = NULL;
 327   }
 328   if (rb_data.fprefix != NULL) {
 329     g_free(rb_data.fprefix);
 330     rb_data.fprefix = NULL;
 331   }
 332   if (rb_data.fsuffix != NULL) {
 333     g_free(rb_data.fsuffix);
 334     rb_data.fsuffix = NULL;
 335   }
 336 }
 337
 338 /*
 339  * Frees all memory allocated by the ringbuffer
 340  */
 341 void
 342 ringbuf_error_cleanup(void)
 343 {
 344   unsigned int i;
 345
 346   /* try to close via wtap */
 347   if (rb_data.pdh != NULL) {
 348     if (fclose(rb_data.pdh) == 0) {
 349       rb_data.fd = -1;
 350     }
 351     rb_data.pdh = NULL;
 352   }
 353
 354   /* close directly if still open */
 355   if (rb_data.fd != -1) {
 356     ws_close(rb_data.fd);
 357     rb_data.fd = -1;
 358   }
 359
 360   if (rb_data.files != NULL) {
 361     for (i=0; i < rb_data.num_files; i++) {
 362       if (rb_data.files[i].name != NULL) {
 363         ws_unlink(rb_data.files[i].name);
 364       }
 365     }
 366   }
 367   /* free the memory */
 368   ringbuf_free();
 369 }
 370
 371 #endif /* HAVE_LIBPCAP */
 372
 373 /*
 374  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
 375  *
 376  * Local Variables:
 377  * c-basic-offset: 2
 378  * tab-width: 8
 379  * indent-tabs-mode: nil
 380  * End:
 381  *
 382  * ex: set shiftwidth=2 tabstop=8 expandtab:
 383  * :indentSize=2:tabSize=8:noTabs=true:
 384  */