Don't use a global capture_opts in the capturing engine (this isn't a good idea)...
[obnox/wireshark/wip.git] / capture.c
1 /* capture.c
2  * Routines for packet capture windows
3  *
4  * $Id$
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 /* With MSVC and a libethereal.dll this file needs to import some variables 
26    in a special way. Therefore _NEED_VAR_IMPORT_ is defined. */
27 #define _NEED_VAR_IMPORT_
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #ifdef HAVE_LIBPCAP
34
35 #include <stdlib.h>
36 #include <string.h>
37
38 #ifdef HAVE_FCNTL_H
39 #include <fcntl.h>
40 #endif
41
42 #ifdef HAVE_IO_H
43 # include <io.h>
44 #endif
45
46 #include <signal.h>
47 #include <errno.h>
48
49 #include <pcap.h>
50
51 #include <glib.h>
52
53 #include <epan/packet.h>
54 #include <epan/dfilter/dfilter.h>
55 #include "file.h"
56 #include "capture.h"
57 #include "capture_sync.h"
58 #include "util.h"
59 #include "pcap-util.h"
60 #include "alert_box.h"
61 #include "simple_dialog.h"
62 #include <epan/prefs.h>
63 #include "globals.h"
64 #include "conditions.h"
65 #include "ringbuffer.h"
66
67 #ifdef _WIN32
68 #include "capture-wpcap.h"
69 #endif
70 #include "ui_util.h"
71
72 /*
73  * Capture options.
74  */
75 gboolean capture_child;         /* if this is the child for "-S" */
76
77
78 /* Win32 needs the O_BINARY flag for open() */
79 #ifndef O_BINARY
80 #define O_BINARY        0
81 #endif
82
83 static gboolean normal_do_capture(capture_options *capture_opts, gboolean is_tempfile);
84 static void stop_capture_signal_handler(int signo);
85
86
87 /* open the output file (temporary/specified name/ringbuffer) and close the old one */
88 /* Returns TRUE if the file opened successfully, FALSE otherwise. */
89 static gboolean
90 capture_open_output(capture_options *capture_opts, const char *save_file, gboolean *is_tempfile) {
91   char tmpname[128+1];
92   gchar *capfile_name;
93
94
95   if (save_file != NULL) {
96     /* If the Sync option is set, we return to the caller while the capture
97      * is in progress.  Therefore we need to take a copy of save_file in
98      * case the caller destroys it after we return.
99      */
100     capfile_name = g_strdup(save_file);
101     if (capture_opts->multi_files_on) {
102       /* ringbuffer is enabled */
103       cfile.save_file_fd = ringbuf_init(capfile_name,
104           (capture_opts->has_ring_num_files) ? capture_opts->ring_num_files : 0);
105     } else {
106       /* Try to open/create the specified file for use as a capture buffer. */
107       cfile.save_file_fd = open(capfile_name, O_RDWR|O_BINARY|O_TRUNC|O_CREAT,
108                                 0600);
109     }
110     *is_tempfile = FALSE;
111   } else {
112     /* Choose a random name for the temporary capture buffer */
113     cfile.save_file_fd = create_tempfile(tmpname, sizeof tmpname, "ether");
114     capfile_name = g_strdup(tmpname);
115     *is_tempfile = TRUE;
116   }
117
118   /* did we fail to open the output file? */
119   if (cfile.save_file_fd == -1) {
120     if (is_tempfile) {
121       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
122         "The temporary file to which the capture would be saved (\"%s\")"
123         "could not be opened: %s.", capfile_name, strerror(errno));
124     } else {
125       if (capture_opts->multi_files_on) {
126         ringbuf_error_cleanup();
127       }
128       open_failure_alert_box(capfile_name, errno, TRUE);
129     }
130     g_free(capfile_name);
131     return FALSE;
132   }
133
134   /* close the old file */
135   cf_close(&cfile);
136   g_assert(cfile.save_file == NULL);
137   cfile.save_file = capfile_name;
138   /* cfile.save_file is "g_free"ed later, which is equivalent to
139      "g_free(capfile_name)". */
140
141   return TRUE;
142 }
143
144
145 /* Open a specified file, or create a temporary file, and start a capture
146    to the file in question.  */
147 /* Returns TRUE if the capture starts successfully, FALSE otherwise. */
148 gboolean
149 do_capture(capture_options *capture_opts, const char *save_file)
150 {
151   gboolean is_tempfile;
152   gboolean ret;
153
154
155   /* open the output file (temporary/specified name/ringbuffer) and close the old one */
156   if(!capture_open_output(capture_opts, save_file, &is_tempfile)) {
157     return FALSE;
158   }
159
160   if (capture_opts->sync_mode) {        
161     /* sync mode: do the capture in a child process */
162     ret = sync_pipe_do_capture(capture_opts, is_tempfile);
163     /* capture is still running */
164     set_main_window_name("(Live Capture in Progress) - Ethereal");
165   } else {
166     /* normal mode: do the capture synchronously */
167     set_main_window_name("(Live Capture in Progress) - Ethereal");
168     ret = normal_do_capture(capture_opts, is_tempfile);
169     /* capture is finished here */
170   }
171
172   return ret;
173 }
174
175
176 /* start a normal capture session */
177 static gboolean
178 normal_do_capture(capture_options *capture_opts, gboolean is_tempfile)
179 {
180     int capture_succeeded;
181     gboolean stats_known;
182     struct pcap_stat stats;
183     int err;
184
185     /* Not sync mode. */
186     capture_succeeded = capture_start(capture_opts, &stats_known, &stats);
187     if (capture_opts->quit_after_cap) {
188       /* DON'T unlink the save file.  Presumably someone wants it. */
189         main_window_exit();
190     }
191     if (!capture_succeeded) {
192       /* We didn't succeed in doing the capture, so we don't have a save
193          file. */
194       if (capture_opts->multi_files_on) {
195         ringbuf_free();
196       } else {
197         g_free(cfile.save_file);
198       }
199       cfile.save_file = NULL;
200       return FALSE;
201     }
202     /* Capture succeeded; attempt to read in the capture file. */
203     if ((err = cf_open(cfile.save_file, is_tempfile, &cfile)) != 0) {
204       /* We're not doing a capture any more, so we don't have a save
205          file. */
206       if (capture_opts->multi_files_on) {
207         ringbuf_free();
208       } else {
209         g_free(cfile.save_file);
210       }
211       cfile.save_file = NULL;
212       return FALSE;
213     }
214
215     /* Set the read filter to NULL. */
216     cfile.rfcode = NULL;
217
218     /* Get the packet-drop statistics.
219
220        XXX - there are currently no packet-drop statistics stored
221        in libpcap captures, and that's what we're reading.
222
223        At some point, we will add support in Wiretap to return
224        packet-drop statistics for capture file formats that store it,
225        and will make "cf_read()" get those statistics from Wiretap.
226        We clear the statistics (marking them as "not known") in
227        "cf_open()", and "cf_read()" will only fetch them and mark
228        them as known if Wiretap supplies them, so if we get the
229        statistics now, after calling "cf_open()" but before calling
230        "cf_read()", the values we store will be used by "cf_read()".
231
232        If a future libpcap capture file format stores the statistics,
233        we'll put them into the capture file that we write, and will
234        thus not have to set them here - "cf_read()" will get them from
235        the file and use them. */
236     if (stats_known) {
237       cfile.drops_known = TRUE;
238
239       /* XXX - on some systems, libpcap doesn't bother filling in
240          "ps_ifdrop" - it doesn't even set it to zero - so we don't
241          bother looking at it.
242
243          Ideally, libpcap would have an interface that gave us
244          several statistics - perhaps including various interface
245          error statistics - and would tell us which of them it
246          supplies, allowing us to display only the ones it does. */
247       cfile.drops = stats.ps_drop;
248     }
249     switch (cf_read(&cfile)) {
250
251     case READ_SUCCESS:
252     case READ_ERROR:
253       /* Just because we got an error, that doesn't mean we were unable
254          to read any of the file; we handle what we could get from the
255          file. */
256       break;
257
258     case READ_ABORTED:
259       /* Exit by leaving the main loop, so that any quit functions
260          we registered get called. */
261       main_window_nested_quit();
262       return FALSE;
263     }
264
265     /* We're not doing a capture any more, so we don't have a save
266        file. */
267     if (capture_opts->multi_files_on) {
268       ringbuf_free();
269     } else {
270       g_free(cfile.save_file);
271     }
272     cfile.save_file = NULL;
273
274     /* if we didn't captured even a single packet, close the file again */
275     if(cfile.count == 0) {
276       simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK, 
277       "%sNo packets captured!%s\n\n"
278       "As no data was captured, closing the %scapture file!",
279       simple_dialog_primary_start(), simple_dialog_primary_end(),
280       (cfile.is_tempfile) ? "temporary " : "");
281       cf_close(&cfile);
282     }
283   return TRUE;
284 }
285
286
287 static void
288 stop_capture_signal_handler(int signo _U_)
289 {
290   capture_loop_stop();
291 }
292
293
294 int  
295 capture_start(capture_options *capture_opts, gboolean *stats_known, struct pcap_stat *stats)
296 {
297 #ifndef _WIN32
298   /*
299    * Catch SIGUSR1, so that we exit cleanly if the parent process
300    * kills us with it due to the user selecting "Capture->Stop".
301    */
302   if (capture_child)
303     signal(SIGUSR1, stop_capture_signal_handler);
304 #endif
305
306   return capture_loop_start(capture_opts, stats_known, stats);
307 }
308
309 void
310 capture_stop(gboolean sync_mode)
311 {
312
313   if (sync_mode) {      
314     sync_pipe_stop();
315   }
316     
317   capture_loop_stop();
318 }
319
320 void
321 kill_capture_child(gboolean sync_mode)
322 {
323   if (sync_mode) {      
324     sync_pipe_kill();
325   }
326 }
327
328
329 #endif /* HAVE_LIBPCAP */