2001-12-04 08:45:04 +00:00
|
|
|
/* ringbuffer.c
|
|
|
|
* Routines for packet capture windows
|
|
|
|
*
|
2006-05-21 05:12:17 +00:00
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
2001-12-04 08:45:04 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2001-12-04 08:45:04 +00:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2001-12-04 08:45:04 +00:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2001-12-04 08:45:04 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
2012-06-28 22:56:06 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
2001-12-04 08:45:04 +00:00
|
|
|
*/
|
|
|
|
|
2003-06-22 16:09:04 +00:00
|
|
|
/*
|
|
|
|
* <laurent.deniel@free.fr>
|
|
|
|
*
|
|
|
|
* Almost completely rewritten in order to:
|
2008-05-22 15:46:27 +00:00
|
|
|
*
|
2003-06-22 16:09:04 +00:00
|
|
|
* - be able to use a unlimited number of ringbuffer files
|
|
|
|
* - close the current file and open (truncating) the next file at switch
|
|
|
|
* - set the final file name once open (or reopen)
|
|
|
|
* - avoid the deletion of files that could not be truncated (can't arise now)
|
|
|
|
* and do not erase empty files
|
|
|
|
*
|
2008-05-22 15:46:27 +00:00
|
|
|
* The idea behind that is to remove the limitation of the maximum # of
|
2003-06-22 16:09:04 +00:00
|
|
|
* ringbuffer files being less than the maximum # of open fd per process
|
|
|
|
* and to be able to reduce the amount of virtual memory usage (having only
|
|
|
|
* one file open at most) or the amount of file system usage (by truncating
|
2008-05-22 15:46:27 +00:00
|
|
|
* the files at switch and not the capture stop, and by closing them which
|
2003-06-22 16:09:04 +00:00
|
|
|
* makes possible their move or deletion after a switch).
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2014-08-22 21:13:05 +00:00
|
|
|
#include <config.h>
|
2001-12-04 08:45:04 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_LIBPCAP
|
|
|
|
|
|
|
|
#ifdef HAVE_FCNTL_H
|
|
|
|
#include <fcntl.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <errno.h>
|
|
|
|
|
2006-03-04 22:33:04 +00:00
|
|
|
#include <pcap.h>
|
|
|
|
|
|
|
|
#include <glib.h>
|
|
|
|
|
2001-12-04 08:45:04 +00:00
|
|
|
#include "ringbuffer.h"
|
2008-05-22 15:46:27 +00:00
|
|
|
#include <wsutil/file_util.h>
|
2001-12-04 08:45:04 +00:00
|
|
|
|
2004-06-30 06:58:59 +00:00
|
|
|
|
2001-12-04 08:45:04 +00:00
|
|
|
/* Ringbuffer file structure */
|
|
|
|
typedef struct _rb_file {
|
2014-10-12 18:56:12 +00:00
|
|
|
gchar *name;
|
2001-12-04 08:45:04 +00:00
|
|
|
} rb_file;
|
|
|
|
|
|
|
|
/* Ringbuffer data structure */
|
|
|
|
typedef struct _ringbuf_data {
|
2003-06-22 16:09:04 +00:00
|
|
|
rb_file *files;
|
2005-08-19 21:13:49 +00:00
|
|
|
guint num_files; /* Number of ringbuffer files (1 to ...) */
|
|
|
|
guint curr_file_num; /* Number of the current file (ever increasing) */
|
2003-06-22 16:09:04 +00:00
|
|
|
gchar *fprefix; /* Filename prefix */
|
|
|
|
gchar *fsuffix; /* Filename suffix */
|
|
|
|
gboolean unlimited; /* TRUE if unlimited number of files */
|
2005-01-12 21:41:30 +00:00
|
|
|
|
2014-10-12 18:56:12 +00:00
|
|
|
int fd; /* Current ringbuffer file descriptor */
|
2006-03-04 22:33:04 +00:00
|
|
|
FILE *pdh;
|
2010-08-28 11:05:51 +00:00
|
|
|
gboolean group_read_access; /* TRUE if files need to be opened with group read access */
|
2002-08-28 21:04:11 +00:00
|
|
|
} ringbuf_data;
|
2001-12-04 08:45:04 +00:00
|
|
|
|
|
|
|
static ringbuf_data rb_data;
|
|
|
|
|
2005-01-12 21:41:30 +00:00
|
|
|
|
|
|
|
/*
|
2008-05-22 15:46:27 +00:00
|
|
|
* create the next filename and open a new binary file with that name
|
2005-01-12 21:41:30 +00:00
|
|
|
*/
|
2003-06-22 16:09:04 +00:00
|
|
|
static int ringbuf_open_file(rb_file *rfile, int *err)
|
|
|
|
{
|
|
|
|
char filenum[5+1];
|
|
|
|
char timestr[14+1];
|
|
|
|
time_t current_time;
|
|
|
|
|
|
|
|
if (rfile->name != NULL) {
|
|
|
|
if (rb_data.unlimited == FALSE) {
|
|
|
|
/* remove old file (if any, so ignore error) */
|
2008-05-22 15:46:27 +00:00
|
|
|
ws_unlink(rfile->name);
|
2003-06-22 16:09:04 +00:00
|
|
|
}
|
|
|
|
g_free(rfile->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
_tzset();
|
|
|
|
#endif
|
|
|
|
current_time = time(NULL);
|
|
|
|
|
2010-05-27 18:00:46 +00:00
|
|
|
g_snprintf(filenum, sizeof(filenum), "%05u", (rb_data.curr_file_num + 1) % RINGBUFFER_MAX_NUM_FILES);
|
2003-06-22 16:09:04 +00:00
|
|
|
strftime(timestr, sizeof(timestr), "%Y%m%d%H%M%S", localtime(¤t_time));
|
|
|
|
rfile->name = g_strconcat(rb_data.fprefix, "_", filenum, "_", timestr,
|
2014-10-12 18:56:12 +00:00
|
|
|
rb_data.fsuffix, NULL);
|
2003-06-22 16:09:04 +00:00
|
|
|
|
2013-03-31 16:19:53 +00:00
|
|
|
if (rfile->name == NULL) {
|
|
|
|
if (err != NULL)
|
|
|
|
*err = ENOMEM;
|
2003-06-22 16:09:04 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2014-02-25 20:42:35 +00:00
|
|
|
rb_data.fd = ws_open(rfile->name, O_RDWR|O_BINARY|O_TRUNC|O_CREAT,
|
2010-08-28 11:05:51 +00:00
|
|
|
rb_data.group_read_access ? 0640 : 0600);
|
2003-06-22 16:09:04 +00:00
|
|
|
|
|
|
|
if (rb_data.fd == -1 && err != NULL) {
|
|
|
|
*err = errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rb_data.fd;
|
|
|
|
}
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
/*
|
2003-06-22 16:09:04 +00:00
|
|
|
* Initialize the ringbuffer data structures
|
2001-12-04 08:45:04 +00:00
|
|
|
*/
|
2002-08-28 21:04:11 +00:00
|
|
|
int
|
2010-08-28 11:05:51 +00:00
|
|
|
ringbuf_init(const char *capfile_name, guint num_files, gboolean group_read_access)
|
2001-12-04 08:45:04 +00:00
|
|
|
{
|
|
|
|
unsigned int i;
|
2004-02-25 05:52:37 +00:00
|
|
|
char *pfx, *last_pathsep;
|
2001-12-04 08:45:04 +00:00
|
|
|
gchar *save_file;
|
2003-06-22 16:09:04 +00:00
|
|
|
|
|
|
|
rb_data.files = NULL;
|
|
|
|
rb_data.curr_file_num = 0;
|
|
|
|
rb_data.fprefix = NULL;
|
|
|
|
rb_data.fsuffix = NULL;
|
|
|
|
rb_data.unlimited = FALSE;
|
|
|
|
rb_data.fd = -1;
|
|
|
|
rb_data.pdh = NULL;
|
2010-08-28 11:05:51 +00:00
|
|
|
rb_data.group_read_access = group_read_access;
|
2001-12-04 08:45:04 +00:00
|
|
|
|
|
|
|
/* just to be sure ... */
|
|
|
|
if (num_files <= RINGBUFFER_MAX_NUM_FILES) {
|
|
|
|
rb_data.num_files = num_files;
|
|
|
|
} else {
|
|
|
|
rb_data.num_files = RINGBUFFER_MAX_NUM_FILES;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check file name */
|
|
|
|
if (capfile_name == NULL) {
|
|
|
|
/* ringbuffer does not work with temporary files! */
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2003-06-22 16:09:04 +00:00
|
|
|
/* set file name prefix/suffix */
|
2001-12-04 08:45:04 +00:00
|
|
|
|
|
|
|
save_file = g_strdup(capfile_name);
|
2004-02-25 05:52:37 +00:00
|
|
|
last_pathsep = strrchr(save_file, G_DIR_SEPARATOR);
|
2001-12-04 08:45:04 +00:00
|
|
|
pfx = strrchr(save_file,'.');
|
2004-02-25 05:52:37 +00:00
|
|
|
if (pfx != NULL && (last_pathsep == NULL || pfx > last_pathsep)) {
|
|
|
|
/* The pathname has a "." in it, and it's in the last component
|
|
|
|
of the pathname (because there is either only one component,
|
|
|
|
i.e. last_pathsep is null as there are no path separators,
|
|
|
|
or the "." is after the path separator before the last
|
|
|
|
component.
|
|
|
|
|
|
|
|
Treat it as a separator between the rest of the file name and
|
|
|
|
the file name suffix, and arrange that the names given to the
|
|
|
|
ring buffer files have the specified suffix, i.e. put the
|
|
|
|
changing part of the name *before* the suffix. */
|
2001-12-04 08:45:04 +00:00
|
|
|
pfx[0] = '\0';
|
|
|
|
rb_data.fprefix = g_strdup(save_file);
|
|
|
|
pfx[0] = '.'; /* restore capfile_name */
|
|
|
|
rb_data.fsuffix = g_strdup(pfx);
|
|
|
|
} else {
|
2004-02-25 05:52:37 +00:00
|
|
|
/* Either there's no "." in the pathname, or it's in a directory
|
|
|
|
component, so the last component has no suffix. */
|
2001-12-04 08:45:04 +00:00
|
|
|
rb_data.fprefix = g_strdup(save_file);
|
|
|
|
rb_data.fsuffix = NULL;
|
|
|
|
}
|
|
|
|
g_free(save_file);
|
|
|
|
save_file = NULL;
|
|
|
|
|
2003-06-22 16:09:04 +00:00
|
|
|
/* allocate rb_file structures (only one if unlimited since there is no
|
|
|
|
need to save all file names in that case) */
|
|
|
|
|
|
|
|
if (num_files == RINGBUFFER_UNLIMITED_FILES) {
|
|
|
|
rb_data.unlimited = TRUE;
|
|
|
|
rb_data.num_files = 1;
|
2001-12-04 08:45:04 +00:00
|
|
|
}
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2010-03-11 00:36:45 +00:00
|
|
|
rb_data.files = (rb_file *)g_malloc(rb_data.num_files * sizeof(rb_file));
|
2003-06-22 16:09:04 +00:00
|
|
|
if (rb_data.files == NULL) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i=0; i < rb_data.num_files; i++) {
|
|
|
|
rb_data.files[i].name = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* create the first file */
|
|
|
|
if (ringbuf_open_file(&rb_data.files[0], NULL) == -1) {
|
|
|
|
ringbuf_error_cleanup();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rb_data.fd;
|
2001-12-04 08:45:04 +00:00
|
|
|
}
|
|
|
|
|
2005-03-28 00:19:02 +00:00
|
|
|
|
|
|
|
const gchar *ringbuf_current_filename(void)
|
|
|
|
{
|
|
|
|
return rb_data.files[rb_data.curr_file_num % rb_data.num_files].name;
|
|
|
|
}
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
/*
|
2012-12-20 14:53:09 +00:00
|
|
|
* Calls ws_fdopen() for the current ringbuffer file
|
2001-12-04 08:45:04 +00:00
|
|
|
*/
|
2006-03-04 22:33:04 +00:00
|
|
|
FILE *
|
2009-04-26 15:51:25 +00:00
|
|
|
ringbuf_init_libpcap_fdopen(int *err)
|
2001-12-04 08:45:04 +00:00
|
|
|
{
|
2012-12-20 14:53:09 +00:00
|
|
|
rb_data.pdh = ws_fdopen(rb_data.fd, "wb");
|
|
|
|
if (rb_data.pdh == NULL) {
|
|
|
|
if (err != NULL) {
|
|
|
|
*err = errno;
|
|
|
|
}
|
|
|
|
}
|
2003-06-22 16:09:04 +00:00
|
|
|
return rb_data.pdh;
|
2001-12-04 08:45:04 +00:00
|
|
|
}
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
/*
|
2001-12-04 08:45:04 +00:00
|
|
|
* Switches to the next ringbuffer file
|
|
|
|
*/
|
|
|
|
gboolean
|
2009-04-26 15:51:25 +00:00
|
|
|
ringbuf_switch_file(FILE **pdh, gchar **save_file, int *save_file_fd, int *err)
|
2001-12-04 08:45:04 +00:00
|
|
|
{
|
2007-05-15 07:53:37 +00:00
|
|
|
int next_file_index;
|
2003-06-22 16:09:04 +00:00
|
|
|
rb_file *next_rfile = NULL;
|
|
|
|
|
|
|
|
/* close current file */
|
|
|
|
|
2012-12-20 20:00:06 +00:00
|
|
|
if (fclose(rb_data.pdh) == EOF) {
|
2012-12-20 14:53:09 +00:00
|
|
|
if (err != NULL) {
|
|
|
|
*err = errno;
|
|
|
|
}
|
2014-10-12 18:56:12 +00:00
|
|
|
ws_close(rb_data.fd); /* XXX - the above should have closed this already */
|
|
|
|
rb_data.pdh = NULL; /* it's still closed, we just got an error while closing */
|
2003-06-22 16:09:04 +00:00
|
|
|
rb_data.fd = -1;
|
2002-05-04 10:10:42 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2003-06-22 16:09:04 +00:00
|
|
|
rb_data.pdh = NULL;
|
|
|
|
rb_data.fd = -1;
|
|
|
|
|
|
|
|
/* get the next file number and open it */
|
|
|
|
|
2005-08-19 21:13:49 +00:00
|
|
|
rb_data.curr_file_num++ /* = next_file_num*/;
|
2007-05-15 07:53:37 +00:00
|
|
|
next_file_index = (rb_data.curr_file_num) % rb_data.num_files;
|
|
|
|
next_rfile = &rb_data.files[next_file_index];
|
2003-06-22 16:09:04 +00:00
|
|
|
|
|
|
|
if (ringbuf_open_file(next_rfile, err) == -1) {
|
|
|
|
return FALSE;
|
2001-12-04 08:45:04 +00:00
|
|
|
}
|
|
|
|
|
2009-04-26 15:51:25 +00:00
|
|
|
if (ringbuf_init_libpcap_fdopen(err) == NULL) {
|
2002-06-23 20:30:01 +00:00
|
|
|
return FALSE;
|
2003-06-22 16:09:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* switch to the new file */
|
2005-02-03 21:58:33 +00:00
|
|
|
*save_file = next_rfile->name;
|
|
|
|
*save_file_fd = rb_data.fd;
|
2003-06-22 16:09:04 +00:00
|
|
|
(*pdh) = rb_data.pdh;
|
2002-06-23 20:30:01 +00:00
|
|
|
|
2001-12-04 08:45:04 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
/*
|
2012-12-20 20:00:06 +00:00
|
|
|
* Calls fclose() for the current ringbuffer file
|
2001-12-04 08:45:04 +00:00
|
|
|
*/
|
|
|
|
gboolean
|
2006-03-04 22:33:04 +00:00
|
|
|
ringbuf_libpcap_dump_close(gchar **save_file, int *err)
|
2001-12-04 08:45:04 +00:00
|
|
|
{
|
2003-06-22 16:09:04 +00:00
|
|
|
gboolean ret_val = TRUE;
|
2002-05-04 10:10:42 +00:00
|
|
|
|
If, when rotating capture files, the attempt to close the current file
fails, set "rb_data.pdh" to NULL, so we know it's not open (if
"wtap_dump_close()" fails, the wtap_dumper_t is still closed - and the
file descriptor for it is probably closed, too, as, if "close()" fails,
the FD is probably closed; the Single UNIX Specification Version 3 says
the state of the FD is unspecified, but in practice most OSes probably
still close it).
If we try to close the current file, first check to make sure it's open,
i.e. that "rb_data.pdh" is non-null. (Or perhaps we should avoid trying
to close it if the open *or* the most recent attempt to rotate the
capture files failed.)
Note that if "wtap_dump_close()" fails we might not need to close the
underlying file descriptor (and, even if we do, there's no guarantee
that attempt won't also fail and leave the FD still open - which is why
I suspect that a failed "close()" leaves the FD closed on most OSes).
svn path=/trunk/; revision=11075
2004-06-02 18:49:40 +00:00
|
|
|
/* close current file, if it's open */
|
|
|
|
if (rb_data.pdh != NULL) {
|
2012-12-20 20:00:06 +00:00
|
|
|
if (fclose(rb_data.pdh) == EOF) {
|
2012-12-20 14:53:09 +00:00
|
|
|
if (err != NULL) {
|
|
|
|
*err = errno;
|
|
|
|
}
|
2008-05-22 15:46:27 +00:00
|
|
|
ws_close(rb_data.fd);
|
If, when rotating capture files, the attempt to close the current file
fails, set "rb_data.pdh" to NULL, so we know it's not open (if
"wtap_dump_close()" fails, the wtap_dumper_t is still closed - and the
file descriptor for it is probably closed, too, as, if "close()" fails,
the FD is probably closed; the Single UNIX Specification Version 3 says
the state of the FD is unspecified, but in practice most OSes probably
still close it).
If we try to close the current file, first check to make sure it's open,
i.e. that "rb_data.pdh" is non-null. (Or perhaps we should avoid trying
to close it if the open *or* the most recent attempt to rotate the
capture files failed.)
Note that if "wtap_dump_close()" fails we might not need to close the
underlying file descriptor (and, even if we do, there's no guarantee
that attempt won't also fail and leave the FD still open - which is why
I suspect that a failed "close()" leaves the FD closed on most OSes).
svn path=/trunk/; revision=11075
2004-06-02 18:49:40 +00:00
|
|
|
ret_val = FALSE;
|
|
|
|
}
|
|
|
|
rb_data.pdh = NULL;
|
|
|
|
rb_data.fd = -1;
|
2001-12-04 08:45:04 +00:00
|
|
|
}
|
2002-09-22 16:17:41 +00:00
|
|
|
|
If, when rotating capture files, the attempt to close the current file
fails, set "rb_data.pdh" to NULL, so we know it's not open (if
"wtap_dump_close()" fails, the wtap_dumper_t is still closed - and the
file descriptor for it is probably closed, too, as, if "close()" fails,
the FD is probably closed; the Single UNIX Specification Version 3 says
the state of the FD is unspecified, but in practice most OSes probably
still close it).
If we try to close the current file, first check to make sure it's open,
i.e. that "rb_data.pdh" is non-null. (Or perhaps we should avoid trying
to close it if the open *or* the most recent attempt to rotate the
capture files failed.)
Note that if "wtap_dump_close()" fails we might not need to close the
underlying file descriptor (and, even if we do, there's no guarantee
that attempt won't also fail and leave the FD still open - which is why
I suspect that a failed "close()" leaves the FD closed on most OSes).
svn path=/trunk/; revision=11075
2004-06-02 18:49:40 +00:00
|
|
|
/* set the save file name to the current file */
|
2005-08-19 21:13:49 +00:00
|
|
|
*save_file = rb_data.files[rb_data.curr_file_num % rb_data.num_files].name;
|
2001-12-04 08:45:04 +00:00
|
|
|
return ret_val;
|
|
|
|
}
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
/*
|
2001-12-04 08:45:04 +00:00
|
|
|
* Frees all memory allocated by the ringbuffer
|
|
|
|
*/
|
|
|
|
void
|
2011-05-17 23:35:12 +00:00
|
|
|
ringbuf_free(void)
|
2002-08-28 21:04:11 +00:00
|
|
|
{
|
2001-12-04 08:45:04 +00:00
|
|
|
unsigned int i;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2001-12-04 08:45:04 +00:00
|
|
|
if (rb_data.files != NULL) {
|
|
|
|
for (i=0; i < rb_data.num_files; i++) {
|
2003-06-22 16:09:04 +00:00
|
|
|
if (rb_data.files[i].name != NULL) {
|
2014-10-12 18:56:12 +00:00
|
|
|
g_free(rb_data.files[i].name);
|
|
|
|
rb_data.files[i].name = NULL;
|
2003-06-22 16:09:04 +00:00
|
|
|
}
|
2001-12-04 08:45:04 +00:00
|
|
|
}
|
2003-06-22 16:09:04 +00:00
|
|
|
g_free(rb_data.files);
|
2001-12-04 08:45:04 +00:00
|
|
|
rb_data.files = NULL;
|
|
|
|
}
|
2003-06-22 16:09:04 +00:00
|
|
|
if (rb_data.fprefix != NULL) {
|
|
|
|
g_free(rb_data.fprefix);
|
|
|
|
rb_data.fprefix = NULL;
|
|
|
|
}
|
|
|
|
if (rb_data.fsuffix != NULL) {
|
|
|
|
g_free(rb_data.fsuffix);
|
|
|
|
rb_data.fsuffix = NULL;
|
|
|
|
}
|
2001-12-04 08:45:04 +00:00
|
|
|
}
|
|
|
|
|
2002-08-28 21:04:11 +00:00
|
|
|
/*
|
2001-12-04 08:45:04 +00:00
|
|
|
* Frees all memory allocated by the ringbuffer
|
|
|
|
*/
|
2002-08-28 21:04:11 +00:00
|
|
|
void
|
2002-05-04 10:10:42 +00:00
|
|
|
ringbuf_error_cleanup(void)
|
2001-12-04 08:45:04 +00:00
|
|
|
{
|
|
|
|
unsigned int i;
|
2002-08-28 21:04:11 +00:00
|
|
|
|
2003-06-22 16:09:04 +00:00
|
|
|
/* try to close via wtap */
|
|
|
|
if (rb_data.pdh != NULL) {
|
2012-12-20 20:00:06 +00:00
|
|
|
if (fclose(rb_data.pdh) == 0) {
|
2003-06-22 16:09:04 +00:00
|
|
|
rb_data.fd = -1;
|
|
|
|
}
|
|
|
|
rb_data.pdh = NULL;
|
2001-12-04 08:45:04 +00:00
|
|
|
}
|
|
|
|
|
2003-06-22 16:09:04 +00:00
|
|
|
/* close directly if still open */
|
|
|
|
if (rb_data.fd != -1) {
|
2008-05-22 15:46:27 +00:00
|
|
|
ws_close(rb_data.fd);
|
2003-06-22 16:09:04 +00:00
|
|
|
rb_data.fd = -1;
|
|
|
|
}
|
|
|
|
|
2004-02-25 05:21:08 +00:00
|
|
|
if (rb_data.files != NULL) {
|
|
|
|
for (i=0; i < rb_data.num_files; i++) {
|
|
|
|
if (rb_data.files[i].name != NULL) {
|
2008-05-22 15:46:27 +00:00
|
|
|
ws_unlink(rb_data.files[i].name);
|
2004-02-25 05:21:08 +00:00
|
|
|
}
|
2001-12-04 08:45:04 +00:00
|
|
|
}
|
|
|
|
}
|
2002-08-28 21:04:11 +00:00
|
|
|
/* free the memory */
|
2001-12-04 08:45:04 +00:00
|
|
|
ringbuf_free();
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* HAVE_LIBPCAP */
|
2014-10-12 18:56:12 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Editor modelines - http://www.wireshark.org/tools/modelines.html
|
|
|
|
*
|
|
|
|
* Local Variables:
|
|
|
|
* c-basic-offset: 2
|
|
|
|
* tab-width: 8
|
|
|
|
* indent-tabs-mode: nil
|
|
|
|
* End:
|
|
|
|
*
|
|
|
|
* ex: set shiftwidth=2 tabstop=8 expandtab:
|
|
|
|
* :indentSize=2:tabSize=8:noTabs=true:
|
|
|
|
*/
|