2 * Routines for packet capture windows
6 * Ethereal - Network traffic analyzer
7 * By Gerald Combs <gerald@ethereal.com>
8 * Copyright 1998 Gerald Combs
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.
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.
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.
26 * <laurent.deniel@free.fr>
28 * Almost completely rewritten in order to:
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
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).
64 #include <wiretap/wtap.h>
65 #include "ringbuffer.h"
66 #include "file_util.h"
69 /* Ringbuffer file structure */
70 typedef struct _rb_file {
74 /* Ringbuffer data structure */
75 typedef struct _ringbuf_data {
77 guint num_files; /* Number of ringbuffer files (1 to ...) */
78 guint curr_file_num; /* Number of the current file (ever increasing) */
79 gchar *fprefix; /* Filename prefix */
80 gchar *fsuffix; /* Filename suffix */
81 gboolean unlimited; /* TRUE if unlimited number of files */
86 int fd; /* Current ringbuffer file descriptor */
90 static ringbuf_data rb_data;
94 * create the next filename and open a new binary file with that name
96 static int ringbuf_open_file(rb_file *rfile, int *err)
102 if (rfile->name != NULL) {
103 if (rb_data.unlimited == FALSE) {
104 /* remove old file (if any, so ignore error) */
105 eth_unlink(rfile->name);
113 current_time = time(NULL);
115 g_snprintf(filenum, sizeof(filenum), "%05d", rb_data.curr_file_num + 1 /*.number*/);
116 strftime(timestr, sizeof(timestr), "%Y%m%d%H%M%S", localtime(¤t_time));
117 rfile->name = g_strconcat(rb_data.fprefix, "_", filenum, "_", timestr,
118 rb_data.fsuffix, NULL);
120 if (rfile->name == NULL) {
125 rb_data.fd = eth_open(rfile->name, O_RDWR|O_BINARY|O_TRUNC|O_CREAT, 0600);
127 if (rb_data.fd == -1 && err != NULL) {
135 * Initialize the ringbuffer data structures
138 ringbuf_init(const char *capfile_name, guint num_files)
141 char *pfx, *last_pathsep;
144 rb_data.files = NULL;
145 rb_data.curr_file_num = 0;
146 rb_data.fprefix = NULL;
147 rb_data.fsuffix = NULL;
148 rb_data.unlimited = FALSE;
152 /* just to be sure ... */
153 if (num_files <= RINGBUFFER_MAX_NUM_FILES) {
154 rb_data.num_files = num_files;
156 rb_data.num_files = RINGBUFFER_MAX_NUM_FILES;
159 /* Check file name */
160 if (capfile_name == NULL) {
161 /* ringbuffer does not work with temporary files! */
165 /* set file name prefix/suffix */
167 save_file = g_strdup(capfile_name);
168 last_pathsep = strrchr(save_file, G_DIR_SEPARATOR);
169 pfx = strrchr(save_file,'.');
170 if (pfx != NULL && (last_pathsep == NULL || pfx > last_pathsep)) {
171 /* The pathname has a "." in it, and it's in the last component
172 of the pathname (because there is either only one component,
173 i.e. last_pathsep is null as there are no path separators,
174 or the "." is after the path separator before the last
177 Treat it as a separator between the rest of the file name and
178 the file name suffix, and arrange that the names given to the
179 ring buffer files have the specified suffix, i.e. put the
180 changing part of the name *before* the suffix. */
182 rb_data.fprefix = g_strdup(save_file);
183 pfx[0] = '.'; /* restore capfile_name */
184 rb_data.fsuffix = g_strdup(pfx);
186 /* Either there's no "." in the pathname, or it's in a directory
187 component, so the last component has no suffix. */
188 rb_data.fprefix = g_strdup(save_file);
189 rb_data.fsuffix = NULL;
194 /* allocate rb_file structures (only one if unlimited since there is no
195 need to save all file names in that case) */
197 if (num_files == RINGBUFFER_UNLIMITED_FILES) {
198 rb_data.unlimited = TRUE;
199 rb_data.num_files = 1;
202 rb_data.files = g_malloc(rb_data.num_files * sizeof(rb_file));
203 if (rb_data.files == NULL) {
207 for (i=0; i < rb_data.num_files; i++) {
208 rb_data.files[i].name = NULL;
211 /* create the first file */
212 if (ringbuf_open_file(&rb_data.files[0], NULL) == -1) {
213 ringbuf_error_cleanup();
221 const gchar *ringbuf_current_filename(void)
223 return rb_data.files[rb_data.curr_file_num % rb_data.num_files].name;
227 * Calls wtap_dump_fdopen() for the current ringbuffer file
230 ringbuf_init_wtap_dump_fdopen(int filetype, int linktype, int snaplen, int *err)
233 rb_data.filetype = filetype;
234 rb_data.linktype = linktype;
235 rb_data.snaplen = snaplen;
237 rb_data.pdh = wtap_dump_fdopen(rb_data.fd, filetype, linktype, snaplen, FALSE /* compressed */, err);
243 * Switches to the next ringbuffer file
246 ringbuf_switch_file(wtap_dumper **pdh, gchar **save_file, int *save_file_fd, int *err)
249 rb_file *next_rfile = NULL;
251 /* close current file */
253 if (!wtap_dump_close(rb_data.pdh, err)) {
254 eth_close(rb_data.fd); /* XXX - the above should have closed this already */
255 rb_data.pdh = NULL; /* it's still closed, we just got an error while closing */
263 /* get the next file number and open it */
265 rb_data.curr_file_num++ /* = next_file_num*/;
266 next_file_num = (rb_data.curr_file_num) % rb_data.num_files;
267 next_rfile = &rb_data.files[next_file_num];
269 if (ringbuf_open_file(next_rfile, err) == -1) {
273 if (ringbuf_init_wtap_dump_fdopen(rb_data.filetype, rb_data.linktype,
274 rb_data.snaplen, err) == NULL) {
278 /* switch to the new file */
279 *save_file = next_rfile->name;
280 *save_file_fd = rb_data.fd;
281 (*pdh) = rb_data.pdh;
287 * Calls wtap_dump_close() for the current ringbuffer file
290 ringbuf_wtap_dump_close(gchar **save_file, int *err)
292 gboolean ret_val = TRUE;
294 /* close current file, if it's open */
295 if (rb_data.pdh != NULL) {
296 if (!wtap_dump_close(rb_data.pdh, err)) {
297 eth_close(rb_data.fd);
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;
311 * Frees all memory allocated by the ringbuffer
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;
325 g_free(rb_data.files);
326 rb_data.files = NULL;
328 if (rb_data.fprefix != NULL) {
329 g_free(rb_data.fprefix);
330 rb_data.fprefix = NULL;
332 if (rb_data.fsuffix != NULL) {
333 g_free(rb_data.fsuffix);
334 rb_data.fsuffix = NULL;
339 * Frees all memory allocated by the ringbuffer
342 ringbuf_error_cleanup(void)
346 /* try to close via wtap */
347 if (rb_data.pdh != NULL) {
348 if (wtap_dump_close(rb_data.pdh, NULL)) {
354 /* close directly if still open */
355 /* XXX - it shouldn't still be open; "wtap_dump_close()" should leave the
356 file closed even if it fails */
357 if (rb_data.fd != -1) {
358 eth_close(rb_data.fd);
362 if (rb_data.files != NULL) {
363 for (i=0; i < rb_data.num_files; i++) {
364 if (rb_data.files[i].name != NULL) {
365 eth_unlink(rb_data.files[i].name);
369 /* free the memory */
373 #endif /* HAVE_LIBPCAP */