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