On Windows, if we can't open a capture device, check whether WinPcap is
[obnox/wireshark/wip.git] / dumpcap.c
1 /* dumpcap.c
2  *
3  * $Id$
4  *
5  * Wireshark - Network traffic analyzer
6  * By Gerald Combs <gerald@wireshark.org>
7  * Copyright 1998 Gerald Combs
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version 2
12  * of the License, or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  */
23
24 #ifdef HAVE_CONFIG_H
25 # include "config.h"
26 #endif
27
28 #include <stdio.h>
29 #include <stdlib.h> /* for exit() */
30 #include <glib.h>
31
32 #include <string.h>
33 #include <ctype.h>
34
35 #ifdef HAVE_SYS_TYPES_H
36 # include <sys/types.h>
37 #endif
38
39 #ifdef HAVE_SYS_STAT_H
40 # include <sys/stat.h>
41 #endif
42
43 #ifdef HAVE_FCNTL_H
44 #include <fcntl.h>
45 #endif
46
47 #ifdef HAVE_UNISTD_H
48 #include <unistd.h>
49 #endif
50
51 #ifdef HAVE_ARPA_INET_H
52 #include <arpa/inet.h>
53 #endif
54
55 #if defined(__APPLE__) && defined(__LP64__)
56 #include <sys/utsname.h>
57 #endif
58
59 #include <signal.h>
60 #include <errno.h>
61
62 #ifndef HAVE_GETOPT
63 #include "wsutil/wsgetopt.h"
64 #endif
65
66 #ifdef HAVE_NETDB_H
67 #include <netdb.h>
68 #endif
69
70 #ifdef HAVE_LIBCAP
71 # include <sys/prctl.h>
72 # include <sys/capability.h>
73 #endif
74
75 #include "ringbuffer.h"
76 #include "clopts_common.h"
77 #include "console_io.h"
78 #include "cmdarg_err.h"
79 #include "version_info.h"
80
81 #include "capture-pcap-util.h"
82 #ifdef _WIN32
83 #include "capture-wpcap.h"
84 #include "capture_errs.h"
85 #endif /* _WIN32 */
86
87 #include "pcapio.h"
88
89 #ifdef _WIN32
90 #include "capture-wpcap.h"
91 #include <wsutil/unicode-utils.h>
92 #endif
93
94 #ifndef _WIN32
95 #include <sys/socket.h>
96 #include <sys/un.h>
97 #endif
98
99 #ifdef NEED_INET_V6DEFS_H
100 # include "wsutil/inet_v6defs.h"
101 #endif
102
103 #include <wsutil/privileges.h>
104
105 #include "sync_pipe.h"
106
107 #include "capture_opts.h"
108 #include "capture_ifinfo.h"
109 #include "capture_sync.h"
110
111 #include "conditions.h"
112 #include "capture_stop_conditions.h"
113
114 #include "tempfile.h"
115 #include "log.h"
116 #include "wsutil/file_util.h"
117
118 /*
119  * Get information about libpcap format from "wiretap/libpcap.h".
120  * XXX - can we just use pcap_open_offline() to read the pipe?
121  */
122 #include "wiretap/libpcap.h"
123
124 /**#define DEBUG_DUMPCAP**/
125 /**#define DEBUG_CHILD_DUMPCAP**/
126
127 #ifdef _WIN32
128 #ifdef DEBUG_DUMPCAP
129 #include <conio.h>          /* _getch() */
130 #endif
131 #endif
132
133 #ifdef DEBUG_CHILD_DUMPCAP
134 FILE *debug_log;   /* for logging debug messages to  */
135                    /*  a file if DEBUG_CHILD_DUMPCAP */
136                    /*  is defined                    */
137 #endif
138
139 static GAsyncQueue *pcap_queue;
140 static gint64 pcap_queue_bytes;
141 static gint64 pcap_queue_packets;
142 static gint64 pcap_queue_byte_limit = 1024 * 1024;
143 static gint64 pcap_queue_packet_limit = 1000;
144
145 static gboolean capture_child = FALSE; /* FALSE: standalone call, TRUE: this is an Wireshark capture child */
146 #ifdef _WIN32
147 static gchar *sig_pipe_name = NULL;
148 static HANDLE sig_pipe_handle = NULL;
149 static gboolean signal_pipe_check_running(void);
150 #endif
151
152 #ifdef SIGINFO
153 static gboolean infodelay;      /* if TRUE, don't print capture info in SIGINFO handler */
154 static gboolean infoprint;      /* if TRUE, print capture info after clearing infodelay */
155 #endif /* SIGINFO */
156
157 /** Stop a low-level capture (stops the capture child). */
158 static void capture_loop_stop(void);
159
160 #if !defined (__linux__)
161 #ifndef HAVE_PCAP_BREAKLOOP
162 /*
163  * We don't have pcap_breakloop(), which is the only way to ensure that
164  * pcap_dispatch(), pcap_loop(), or even pcap_next() or pcap_next_ex()
165  * won't, if the call to read the next packet or batch of packets is
166  * is interrupted by a signal on UN*X, just go back and try again to
167  * read again.
168  *
169  * On UN*X, we catch SIGINT as a "stop capturing" signal, and, in
170  * the signal handler, set a flag to stop capturing; however, without
171  * a guarantee of that sort, we can't guarantee that we'll stop capturing
172  * if the read will be retried and won't time out if no packets arrive.
173  *
174  * Therefore, on at least some platforms, we work around the lack of
175  * pcap_breakloop() by doing a select() on the pcap_t's file descriptor
176  * to wait for packets to arrive, so that we're probably going to be
177  * blocked in the select() when the signal arrives, and can just bail
178  * out of the loop at that point.
179  *
180  * However, we don't want to do that on BSD (because "select()" doesn't work
181  * correctly on BPF devices on at least some releases of some flavors of
182  * BSD), and we don't want to do it on Windows (because "select()" is
183  * something for sockets, not for arbitrary handles).  (Note that "Windows"
184  * here includes Cygwin; even in its pretend-it's-UNIX environment, we're
185  * using WinPcap, not a UNIX libpcap.)
186  *
187  * Fortunately, we don't need to do it on BSD, because the libpcap timeout
188  * on BSD times out even if no packets have arrived, so we'll eventually
189  * exit pcap_dispatch() with an indication that no packets have arrived,
190  * and will break out of the capture loop at that point.
191  *
192  * On Windows, we can't send a SIGINT to stop capturing, so none of this
193  * applies in any case.
194  *
195  * XXX - the various BSDs appear to define BSD in <sys/param.h>; we don't
196  * want to include it if it's not present on this platform, however.
197  */
198 # if !defined(__FreeBSD__) && !defined(__NetBSD__) && !defined(__OpenBSD__) && \
199     !defined(__bsdi__) && !defined(__APPLE__) && !defined(_WIN32) && \
200     !defined(__CYGWIN__)
201 #  define MUST_DO_SELECT
202 # endif /* avoid select */
203 #endif /* HAVE_PCAP_BREAKLOOP */
204 #else /* linux */
205 /* whatever the deal with pcap_breakloop, linux doesn't support timeouts
206  * in pcap_dispatch(); on the other hand, select() works just fine there.
207  * Hence we use a select for that come what may.
208  */
209 #define MUST_DO_SELECT
210 #endif
211
212 /** init the capture filter */
213 typedef enum {
214     INITFILTER_NO_ERROR,
215     INITFILTER_BAD_FILTER,
216     INITFILTER_OTHER_ERROR
217 } initfilter_status_t;
218
219 typedef struct _pcap_options {
220     guint32        received;
221     guint32        dropped;
222     pcap_t         *pcap_h;
223 #ifdef MUST_DO_SELECT
224     int            pcap_fd;               /* pcap file descriptor */
225 #endif
226     gboolean       pcap_err;
227     guint          interface_id;
228     GThread        *tid;
229     int            snaplen;
230     int            linktype;
231     /* capture pipe (unix only "input file") */
232     gboolean       from_cap_pipe;         /* TRUE if we are capturing data from a capture pipe */
233     struct pcap_hdr cap_pipe_hdr;         /* Pcap header when capturing from a pipe */
234     struct pcaprec_modified_hdr cap_pipe_rechdr;  /* Pcap record header when capturing from a pipe */
235 #ifdef _WIN32
236     HANDLE         cap_pipe_h;            /* The handle of the capture pipe */
237 #else
238     int            cap_pipe_fd;           /* the file descriptor of the capture pipe */
239 #endif
240     gboolean       cap_pipe_modified;     /* TRUE if data in the pipe uses modified pcap headers */
241     gboolean       cap_pipe_byte_swapped; /* TRUE if data in the pipe is byte swapped */
242 #if defined(_WIN32)
243     char *         cap_pipe_buf;          /* Pointer to the data buffer we read into */
244 #endif
245     int            cap_pipe_bytes_to_read;/* Used by cap_pipe_dispatch */
246     int            cap_pipe_bytes_read;   /* Used by cap_pipe_dispatch */
247     enum {
248         STATE_EXPECT_REC_HDR,
249         STATE_READ_REC_HDR,
250         STATE_EXPECT_DATA,
251         STATE_READ_DATA
252     } cap_pipe_state;
253     enum { PIPOK, PIPEOF, PIPERR, PIPNEXIST } cap_pipe_err;
254 #if defined(_WIN32)
255     GMutex *cap_pipe_read_mtx;
256     GAsyncQueue *cap_pipe_pending_q, *cap_pipe_done_q;
257 #endif
258 } pcap_options;
259
260 typedef struct _loop_data {
261     /* common */
262     gboolean       go;                    /* TRUE as long as we're supposed to keep capturing */
263     int            err;                   /* if non-zero, error seen while capturing */
264     gint           packet_count;          /* Number of packets we have already captured */
265     gint           packet_max;            /* Number of packets we're supposed to capture - 0 means infinite */
266     gint           inpkts_to_sync_pipe;   /* Packets not already send out to the sync_pipe */
267 #ifdef SIGINFO
268     gboolean       report_packet_count;   /* Set by SIGINFO handler; print packet count */
269 #endif
270     GArray         *pcaps;
271     /* output file(s) */
272     FILE          *pdh;
273     int            save_file_fd;
274     long           bytes_written;
275     guint32        autostop_files;
276 } loop_data;
277
278 typedef struct _pcap_queue_element {
279     pcap_options       *pcap_opts;
280     struct pcap_pkthdr phdr;
281     u_char             *pd;
282 } pcap_queue_element;
283
284 /*
285  * Standard secondary message for unexpected errors.
286  */
287 static const char please_report[] =
288     "Please report this to the Wireshark developers.\n"
289     "(This is not a crash; please do not report it as such.)";
290
291 /*
292  * This needs to be static, so that the SIGINT handler can clear the "go"
293  * flag.
294  */
295 static loop_data   global_ld;
296
297
298 /*
299  * Timeout, in milliseconds, for reads from the stream of captured packets
300  * from a capture device.
301  *
302  * A bug in Mac OS X 10.6 and 10.6.1 causes calls to pcap_open_live(), in
303  * 64-bit applications, with sub-second timeouts not to work.  The bug is
304  * fixed in 10.6.2, re-broken in 10.6.3, and again fixed in 10.6.5.
305  */
306 #if defined(__APPLE__) && defined(__LP64__)
307 static gboolean need_timeout_workaround;
308
309 #define CAP_READ_TIMEOUT        (need_timeout_workaround ? 1000 : 250)
310 #else
311 #define CAP_READ_TIMEOUT        250
312 #endif
313
314 /*
315  * Timeout, in microseconds, for reads from the stream of captured packets
316  * from a pipe.  Pipes don't have the same problem that BPF devices do
317  * in OS X 10.6, 10.6.1, 10.6.3, and 10.6.4, so we always use a timeout
318  * of 250ms, i.e. the same value as CAP_READ_TIMEOUT when not on one
319  * of the offending versions of Snow Leopard.
320  *
321  * On Windows this value is converted to milliseconds and passed to
322  * WaitForSingleObject. If it's less than 1000 WaitForSingleObject
323  * will return immediately.
324  */
325 #if defined(_WIN32)
326 #define PIPE_READ_TIMEOUT   100000
327 #else
328 #define PIPE_READ_TIMEOUT   250000
329 #endif
330
331 #define WRITER_THREAD_TIMEOUT 100000 /* usecs */
332
333 static void
334 console_log_handler(const char *log_domain, GLogLevelFlags log_level,
335                     const char *message, gpointer user_data _U_);
336
337 /* capture related options */
338 static capture_options global_capture_opts;
339 static gboolean quiet = FALSE;
340 static gboolean use_threads = FALSE;
341
342 static void capture_loop_write_packet_cb(u_char *pcap_opts_p, const struct pcap_pkthdr *phdr,
343                                          const u_char *pd);
344 static void capture_loop_queue_packet_cb(u_char *pcap_opts_p, const struct pcap_pkthdr *phdr,
345                                          const u_char *pd);
346 static void capture_loop_get_errmsg(char *errmsg, int errmsglen, const char *fname,
347                                     int err, gboolean is_close);
348
349 static void WS_MSVC_NORETURN exit_main(int err) G_GNUC_NORETURN;
350
351 static void report_new_capture_file(const char *filename);
352 static void report_packet_count(int packet_count);
353 static void report_packet_drops(guint32 received, guint32 drops, gchar *name);
354 static void report_capture_error(const char *error_msg, const char *secondary_error_msg);
355 static void report_cfilter_error(capture_options *capture_opts, guint i, const char *errmsg);
356
357 #define MSG_MAX_LENGTH 4096
358
359 static void
360 print_usage(gboolean print_ver)
361 {
362     FILE *output;
363
364     if (print_ver) {
365         output = stdout;
366         fprintf(output,
367                 "Dumpcap " VERSION "%s\n"
368                 "Capture network packets and dump them into a libpcap file.\n"
369                 "See http://www.wireshark.org for more information.\n",
370                 wireshark_svnversion);
371     } else {
372         output = stderr;
373     }
374     fprintf(output, "\nUsage: dumpcap [options] ...\n");
375     fprintf(output, "\n");
376     fprintf(output, "Capture interface:\n");
377     fprintf(output, "  -i <interface>           name or idx of interface (def: first non-loopback)\n");
378     fprintf(output, "  -f <capture filter>      packet filter in libpcap filter syntax\n");
379     fprintf(output, "  -s <snaplen>             packet snapshot length (def: 65535)\n");
380     fprintf(output, "  -p                       don't capture in promiscuous mode\n");
381 #ifdef HAVE_PCAP_CREATE
382     fprintf(output, "  -I                       capture in monitor mode, if available\n");
383 #endif
384 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
385     fprintf(output, "  -B <buffer size>         size of kernel buffer (def: 1MB)\n");
386 #endif
387     fprintf(output, "  -y <link type>           link layer type (def: first appropriate)\n");
388     fprintf(output, "  -D                       print list of interfaces and exit\n");
389     fprintf(output, "  -L                       print list of link-layer types of iface and exit\n");
390 #ifdef HAVE_BPF_IMAGE
391     fprintf(output, "  -d                       print generated BPF code for capture filter\n");
392 #endif
393     fprintf(output, "  -S                       print statistics for each interface once per second\n");
394     fprintf(output, "  -M                       for -D, -L, and -S, produce machine-readable output\n");
395     fprintf(output, "\n");
396 #ifdef HAVE_PCAP_REMOTE
397     fprintf(output, "RPCAP options:\n");
398     fprintf(output, "  -r                       don't ignore own RPCAP traffic in capture\n");
399     fprintf(output, "  -u                       use UDP for RPCAP data transfer\n");
400     fprintf(output, "  -A <user>:<password>     use RPCAP password authentication\n");
401 #ifdef HAVE_PCAP_SETSAMPLING
402     fprintf(output, "  -m <sampling type>       use packet sampling\n");
403     fprintf(output, "                           count:NUM - capture one packet of every NUM\n");
404     fprintf(output, "                           timer:NUM - capture no more than 1 packet in NUM ms\n");
405 #endif
406 #endif
407     fprintf(output, "Stop conditions:\n");
408     fprintf(output, "  -c <packet count>        stop after n packets (def: infinite)\n");
409     fprintf(output, "  -a <autostop cond.> ...  duration:NUM - stop after NUM seconds\n");
410     fprintf(output, "                           filesize:NUM - stop this file after NUM KB\n");
411     fprintf(output, "                              files:NUM - stop after NUM files\n");
412     /*fprintf(output, "\n");*/
413     fprintf(output, "Output (files):\n");
414     fprintf(output, "  -w <filename>            name of file to save (def: tempfile)\n");
415     fprintf(output, "  -g                       enable group read access on the output file(s)\n");
416     fprintf(output, "  -b <ringbuffer opt.> ... duration:NUM - switch to next file after NUM secs\n");
417     fprintf(output, "                           filesize:NUM - switch to next file after NUM KB\n");
418     fprintf(output, "                              files:NUM - ringbuffer: replace after NUM files\n");
419     fprintf(output, "  -n                       use pcapng format instead of pcap\n");
420     fprintf(output, "\n");
421     fprintf(output, "Miscellaneous:\n");
422     fprintf(output, "  -t                       use a separate thread per interface\n");
423     fprintf(output, "  -q                       don't report packet capture counts\n");
424     fprintf(output, "  -v                       print version information and exit\n");
425     fprintf(output, "  -h                       display this help and exit\n");
426     fprintf(output, "\n");
427     fprintf(output, "Example: dumpcap -i eth0 -a duration:60 -w output.pcap\n");
428     fprintf(output, "\"Capture network packets from interface eth0 until 60s passed into output.pcap\"\n");
429     fprintf(output, "\n");
430     fprintf(output, "Use Ctrl-C to stop capturing at any time.\n");
431 }
432
433 static void
434 show_version(GString *comp_info_str, GString *runtime_info_str)
435 {
436     printf(
437         "Dumpcap " VERSION "%s\n"
438         "\n"
439         "%s\n"
440         "%s\n"
441         "%s\n"
442         "See http://www.wireshark.org for more information.\n",
443         wireshark_svnversion, get_copyright_info() ,comp_info_str->str, runtime_info_str->str);
444 }
445
446 /*
447  * Print to the standard error.  This is a command-line tool, so there's
448  * no need to pop up a console.
449  */
450 void
451 vfprintf_stderr(const char *fmt, va_list ap)
452 {
453     vfprintf(stderr, fmt, ap);
454 }
455
456 void
457 fprintf_stderr(const char *fmt, ...)
458 {
459     va_list ap;
460
461     va_start(ap, fmt);
462     vfprintf_stderr(fmt, ap);
463     va_end(ap);
464 }
465
466 /*
467  * Report an error in command-line arguments.
468  */
469 void
470 cmdarg_err(const char *fmt, ...)
471 {
472     va_list ap;
473
474     if(capture_child) {
475         gchar *msg;
476         /* Generate a 'special format' message back to parent */
477         va_start(ap, fmt);
478         msg = g_strdup_vprintf(fmt, ap);
479         sync_pipe_errmsg_to_parent(2, msg, "");
480         g_free(msg);
481         va_end(ap);
482     } else {
483         va_start(ap, fmt);
484         fprintf(stderr, "dumpcap: ");
485         vfprintf(stderr, fmt, ap);
486         fprintf(stderr, "\n");
487         va_end(ap);
488     }
489 }
490
491 /*
492  * Report additional information for an error in command-line arguments.
493  */
494 void
495 cmdarg_err_cont(const char *fmt, ...)
496 {
497     va_list ap;
498
499     if(capture_child) {
500         gchar *msg;
501         va_start(ap, fmt);
502         msg = g_strdup_vprintf(fmt, ap);
503         sync_pipe_errmsg_to_parent(2, msg, "");
504         g_free(msg);
505         va_end(ap);
506     } else {
507         va_start(ap, fmt);
508         vfprintf(stderr, fmt, ap);
509         fprintf(stderr, "\n");
510         va_end(ap);
511     }
512 }
513
514 #ifdef HAVE_LIBCAP
515 static void
516 #if 0 /* Set to enable capability debugging */
517 /* see 'man cap_to_text()' for explanation of output                         */
518 /* '='   means 'all= '  ie: no capabilities                                  */
519 /* '=ip' means 'all=ip' ie: all capabilities are permissible and inheritable */
520 /* ....                                                                      */
521 print_caps(const char *pfx) {
522     cap_t caps = cap_get_proc();
523     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
524           "%s: EUID: %d  Capabilities: %s", pfx,
525           geteuid(), cap_to_text(caps, NULL));
526     cap_free(caps);
527 #else
528 print_caps(const char *pfx _U_) {
529 #endif
530 }
531
532 static void
533 relinquish_all_capabilities(void)
534 {
535     /* Drop any and all capabilities this process may have.            */
536     /* Allowed whether or not process has any privileges.              */
537     cap_t caps = cap_init();    /* all capabilities initialized to off */
538     print_caps("Pre-clear");
539     if (cap_set_proc(caps)) {
540         cmdarg_err("cap_set_proc() fail return: %s", g_strerror(errno));
541     }
542     print_caps("Post-clear");
543     cap_free(caps);
544 }
545 #endif
546
547 static pcap_t *
548 open_capture_device(interface_options *interface_opts,
549                     char (*open_err_str)[PCAP_ERRBUF_SIZE])
550 {
551     pcap_t *pcap_h;
552 #ifdef HAVE_PCAP_CREATE
553     int         err;
554 #endif
555 #if defined(HAVE_PCAP_OPEN) && defined(HAVE_PCAP_REMOTE)
556     struct pcap_rmtauth auth;
557 #endif
558
559     /* Open the network interface to capture from it.
560        Some versions of libpcap may put warnings into the error buffer
561        if they succeed; to tell if that's happened, we have to clear
562        the error buffer, and check if it's still a null string.  */
563     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "Entering open_capture_device().");
564     (*open_err_str)[0] = '\0';
565 #if defined(HAVE_PCAP_OPEN) && defined(HAVE_PCAP_REMOTE)
566     /*
567      * If we're opening a remote device, use pcap_open(); that's currently
568      * the only open routine that supports remote devices.
569      */
570     if (strncmp (interface_opts->name, "rpcap://", 8) == 0) {
571         auth.type = interface_opts->auth_type == CAPTURE_AUTH_PWD ?
572             RPCAP_RMTAUTH_PWD : RPCAP_RMTAUTH_NULL;
573         auth.username = interface_opts->auth_username;
574         auth.password = interface_opts->auth_password;
575
576         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
577               "Calling pcap_open() using name %s, snaplen %d, promisc_mode %d, datatx_udp %d, nocap_rpcap %d.",
578               interface_opts->name, interface_opts->snaplen, interface_opts->promisc_mode,
579               interface_opts->datatx_udp, interface_opts->nocap_rpcap);
580         pcap_h = pcap_open(interface_opts->name, interface_opts->snaplen,
581                            /* flags */
582                            (interface_opts->promisc_mode ? PCAP_OPENFLAG_PROMISCUOUS : 0) |
583                            (interface_opts->datatx_udp ? PCAP_OPENFLAG_DATATX_UDP : 0) |
584                            (interface_opts->nocap_rpcap ? PCAP_OPENFLAG_NOCAPTURE_RPCAP : 0),
585                            CAP_READ_TIMEOUT, &auth, *open_err_str);
586         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
587               "pcap_open() returned %p.", (void *)pcap_h);
588     } else
589 #endif
590     {
591         /*
592          * If we're not opening a remote device, use pcap_create() and
593          * pcap_activate() if we have them, so that we can set the buffer
594          * size, otherwise use pcap_open_live().
595          */
596 #ifdef HAVE_PCAP_CREATE
597         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
598               "Calling pcap_create() using %s.", interface_opts->name);
599         pcap_h = pcap_create(interface_opts->name, *open_err_str);
600         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
601               "pcap_create() returned %p.", (void *)pcap_h);
602         if (pcap_h != NULL) {
603             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
604                   "Calling pcap_set_snaplen() with snaplen %d.", interface_opts->snaplen);
605             pcap_set_snaplen(pcap_h, interface_opts->snaplen);
606             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
607                   "Calling pcap_set_snaplen() with promisc_mode %d.", interface_opts->promisc_mode);
608             pcap_set_promisc(pcap_h, interface_opts->promisc_mode);
609             pcap_set_timeout(pcap_h, CAP_READ_TIMEOUT);
610
611             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
612                   "buffersize %d.", interface_opts->buffer_size);
613             if (interface_opts->buffer_size > 1) {
614                 pcap_set_buffer_size(pcap_h, interface_opts->buffer_size * 1024 * 1024);
615             }
616             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
617                   "monitor_mode %d.", interface_opts->monitor_mode);
618             if (interface_opts->monitor_mode)
619                 pcap_set_rfmon(pcap_h, 1);
620             err = pcap_activate(pcap_h);
621             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
622                   "pcap_activate() returned %d.", err);
623             if (err < 0) {
624                 /* Failed to activate, set to NULL */
625                 if (err == PCAP_ERROR)
626                     g_strlcpy(*open_err_str, pcap_geterr(pcap_h), sizeof *open_err_str);
627                 else
628                     g_strlcpy(*open_err_str, pcap_statustostr(err), sizeof *open_err_str);
629                 pcap_close(pcap_h);
630                 pcap_h = NULL;
631             }
632         }
633 #else
634         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
635               "pcap_open_live() calling using name %s, snaplen %d, promisc_mode %d.",
636               interface_opts->name, interface_opts->snaplen, interface_opts->promisc_mode);
637         pcap_h = pcap_open_live(interface_opts->name, interface_opts->snaplen,
638                                 interface_opts->promisc_mode, CAP_READ_TIMEOUT,
639                                 *open_err_str);
640         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
641               "pcap_open_live() returned %p.", (void *)pcap_h);
642 #endif
643     }
644     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "open_capture_device %s : %s", pcap_h ? "SUCCESS" : "FAILURE", interface_opts->name);
645     return pcap_h;
646 }
647
648 static void
649 get_capture_device_open_failure_messages(const char *open_err_str,
650                                          const char *iface
651 #ifndef _WIN32
652                                                            _U_
653 #endif
654                                          ,
655                                          char *errmsg, size_t errmsg_len,
656                                          char *secondary_errmsg,
657                                          size_t secondary_errmsg_len)
658 {
659     const char *libpcap_warn;
660     static const char ppamsg[] = "can't find PPA for ";
661
662     /* If we got a "can't find PPA for X" message, warn the user (who
663        is running dumcap on HP-UX) that they don't have a version of
664        libpcap that properly handles HP-UX (libpcap 0.6.x and later
665        versions, which properly handle HP-UX, say "can't find /dev/dlpi
666        PPA for X" rather than "can't find PPA for X"). */
667     if (strncmp(open_err_str, ppamsg, sizeof ppamsg - 1) == 0)
668         libpcap_warn =
669             "\n\n"
670             "You are running (T)Wireshark with a version of the libpcap library\n"
671             "that doesn't handle HP-UX network devices well; this means that\n"
672             "(T)Wireshark may not be able to capture packets.\n"
673             "\n"
674             "To fix this, you should install libpcap 0.6.2, or a later version\n"
675             "of libpcap, rather than libpcap 0.4 or 0.5.x.  It is available in\n"
676             "packaged binary form from the Software Porting And Archive Centre\n"
677             "for HP-UX; the Centre is at http://hpux.connect.org.uk/ - the page\n"
678             "at the URL lists a number of mirror sites.";
679     else
680         libpcap_warn = "";
681     g_snprintf(errmsg, (gulong) errmsg_len,
682                "The capture session could not be initiated (%s).", open_err_str);
683 #ifdef _WIN32
684     if (!has_wpcap) {
685       char *detailed_err;
686
687       detailed_err = cant_load_winpcap_err("TShark");
688       g_snprintf(secondary_errmsg, (gulong) secondary_errmsg_len,
689                  "\n",
690                  "%s\n", detailed_err);
691       g_free(detailed_err);
692     } else {
693       g_snprintf(secondary_errmsg, (gulong) secondary_errmsg_len,
694                  "\n"
695                  "Please check that \"%s\" is the proper interface.\n"
696                  "\n"
697                  "\n"
698                  "Help can be found at:\n"
699                  "\n"
700                  "       http://wiki.wireshark.org/WinPcap\n"
701                  "       http://wiki.wireshark.org/CaptureSetup\n",
702                  iface);
703     }
704 #else
705     g_snprintf(secondary_errmsg, (gulong) secondary_errmsg_len,
706                "Please check to make sure you have sufficient permissions, and that you have "
707                "the proper interface or pipe specified.%s", libpcap_warn);
708 #endif /* _WIN32 */
709 }
710
711 /* Set the data link type on a pcap. */
712 static gboolean
713 set_pcap_linktype(pcap_t *pcap_h, int linktype,
714 #ifdef HAVE_PCAP_SET_DATALINK
715                   char *name _U_,
716 #else
717                   char *name,
718 #endif
719                   char *errmsg, size_t errmsg_len,
720                   char *secondary_errmsg, size_t secondary_errmsg_len)
721 {
722     char *set_linktype_err_str;
723
724     if (linktype == -1)
725         return TRUE; /* just use the default */
726 #ifdef HAVE_PCAP_SET_DATALINK
727     if (pcap_set_datalink(pcap_h, linktype) == 0)
728         return TRUE; /* no error */
729     set_linktype_err_str = pcap_geterr(pcap_h);
730 #else
731     /* Let them set it to the type it is; reject any other request. */
732     if (get_pcap_linktype(pcap_h, name) == linktype)
733         return TRUE; /* no error */
734     set_linktype_err_str =
735         "That DLT isn't one of the DLTs supported by this device";
736 #endif
737     g_snprintf(errmsg, (gulong) errmsg_len, "Unable to set data link type (%s).",
738                set_linktype_err_str);
739     /*
740      * If the error isn't "XXX is not one of the DLTs supported by this device",
741      * tell the user to tell the Wireshark developers about it.
742      */
743     if (strstr(set_linktype_err_str, "is not one of the DLTs supported by this device") == NULL)
744         g_snprintf(secondary_errmsg, (gulong) secondary_errmsg_len, please_report);
745     else
746         secondary_errmsg[0] = '\0';
747     return FALSE;
748 }
749
750 static gboolean
751 compile_capture_filter(const char *iface, pcap_t *pcap_h,
752                        struct bpf_program *fcode, const char *cfilter)
753 {
754     bpf_u_int32 netnum, netmask;
755     gchar       lookup_net_err_str[PCAP_ERRBUF_SIZE];
756
757     if (pcap_lookupnet(iface, &netnum, &netmask, lookup_net_err_str) < 0) {
758         /*
759          * Well, we can't get the netmask for this interface; it's used
760          * only for filters that check for broadcast IP addresses, so
761          * we just punt and use 0.  It might be nice to warn the user,
762          * but that's a pain in a GUI application, as it'd involve popping
763          * up a message box, and it's not clear how often this would make
764          * a difference (only filters that check for IP broadcast addresses
765          * use the netmask).
766          */
767         /*cmdarg_err(
768           "Warning:  Couldn't obtain netmask info (%s).", lookup_net_err_str);*/
769         netmask = 0;
770     }
771
772     /*
773      * Sigh.  Older versions of libpcap don't properly declare the
774      * third argument to pcap_compile() as a const pointer.  Cast
775      * away the warning.
776      */
777     if (pcap_compile(pcap_h, fcode, (char *)cfilter, 1, netmask) < 0)
778         return FALSE;
779     return TRUE;
780 }
781
782 #ifdef HAVE_BPF_IMAGE
783 static gboolean
784 show_filter_code(capture_options *capture_opts)
785 {
786     interface_options interface_opts;
787     pcap_t *pcap_h;
788     gchar open_err_str[PCAP_ERRBUF_SIZE];
789     char errmsg[MSG_MAX_LENGTH+1];
790     char secondary_errmsg[MSG_MAX_LENGTH+1];
791     struct bpf_program fcode;
792     struct bpf_insn *insn;
793     u_int i;
794     guint j;
795
796     for (j = 0; j < capture_opts->ifaces->len; j++) {
797         interface_opts = g_array_index(capture_opts->ifaces, interface_options, j);
798         pcap_h = open_capture_device(&interface_opts, &open_err_str);
799         if (pcap_h == NULL) {
800             /* Open failed; get messages */
801             get_capture_device_open_failure_messages(open_err_str,
802                                                      interface_opts.name,
803                                                      errmsg, sizeof errmsg,
804                                                      secondary_errmsg,
805                                                      sizeof secondary_errmsg);
806             /* And report them */
807             report_capture_error(errmsg, secondary_errmsg);
808             return FALSE;
809         }
810
811         /* Set the link-layer type. */
812         if (!set_pcap_linktype(pcap_h, interface_opts.linktype, interface_opts.name,
813                                errmsg, sizeof errmsg,
814                                secondary_errmsg, sizeof secondary_errmsg)) {
815             pcap_close(pcap_h);
816             report_capture_error(errmsg, secondary_errmsg);
817             return FALSE;
818         }
819
820         /* OK, try to compile the capture filter. */
821         if (!compile_capture_filter(interface_opts.name, pcap_h, &fcode,
822                                     interface_opts.cfilter)) {
823             pcap_close(pcap_h);
824             report_cfilter_error(capture_opts, j, errmsg);
825             return FALSE;
826         }
827         pcap_close(pcap_h);
828
829         /* Now print the filter code. */
830         insn = fcode.bf_insns;
831
832         for (i = 0; i < fcode.bf_len; insn++, i++)
833             printf("%s\n", bpf_image(insn, i));
834     }
835     /* If not using libcap: we now can now set euid/egid to ruid/rgid         */
836     /*  to remove any suid privileges.                                        */
837     /* If using libcap: we can now remove NET_RAW and NET_ADMIN capabilities  */
838     /*  (euid/egid have already previously been set to ruid/rgid.             */
839     /* (See comment in main() for details)                                    */
840 #ifndef HAVE_LIBCAP
841     relinquish_special_privs_perm();
842 #else
843     relinquish_all_capabilities();
844 #endif
845     if (capture_child) {
846         /* Let our parent know we succeeded. */
847         pipe_write_block(2, SP_SUCCESS, NULL);
848     }
849     return TRUE;
850 }
851 #endif
852
853 /*
854  * capture_interface_list() is expected to do the right thing to get
855  * a list of interfaces.
856  *
857  * In most of the programs in the Wireshark suite, "the right thing"
858  * is to run dumpcap and ask it for the list, because dumpcap may
859  * be the only program in the suite with enough privileges to get
860  * the list.
861  *
862  * In dumpcap itself, however, we obviously can't run dumpcap to
863  * ask for the list.  Therefore, our capture_interface_list() should
864  * just call get_interface_list().
865  */
866 GList *
867 capture_interface_list(int *err, char **err_str)
868 {
869     return get_interface_list(err, err_str);
870 }
871
872 /*
873  * Get the data-link type for a libpcap device.
874  * This works around AIX 5.x's non-standard and incompatible-with-the-
875  * rest-of-the-universe libpcap.
876  */
877 static int
878 get_pcap_linktype(pcap_t *pch, const char *devname
879 #ifndef _AIX
880         _U_
881 #endif
882 )
883 {
884     int linktype;
885 #ifdef _AIX
886     const char *ifacename;
887 #endif
888
889     linktype = pcap_datalink(pch);
890 #ifdef _AIX
891
892     /*
893      * The libpcap that comes with AIX 5.x uses RFC 1573 ifType values
894      * rather than DLT_ values for link-layer types; the ifType values
895      * for LAN devices are:
896      *
897      *  Ethernet        6
898      *  802.3           7
899      *  Token Ring      9
900      *  FDDI            15
901      *
902      * and the ifType value for a loopback device is 24.
903      *
904      * The AIX names for LAN devices begin with:
905      *
906      *  Ethernet                en
907      *  802.3                   et
908      *  Token Ring              tr
909      *  FDDI                    fi
910      *
911      * and the AIX names for loopback devices begin with "lo".
912      *
913      * (The difference between "Ethernet" and "802.3" is presumably
914      * whether packets have an Ethernet header, with a packet type,
915      * or an 802.3 header, with a packet length, followed by an 802.2
916      * header and possibly a SNAP header.)
917      *
918      * If the device name matches "linktype" interpreted as an ifType
919      * value, rather than as a DLT_ value, we will assume this is AIX's
920      * non-standard, incompatible libpcap, rather than a standard libpcap,
921      * and will map the link-layer type to the standard DLT_ value for
922      * that link-layer type, as that's what the rest of Wireshark expects.
923      *
924      * (This means the capture files won't be readable by a tcpdump
925      * linked with AIX's non-standard libpcap, but so it goes.  They
926      * *will* be readable by standard versions of tcpdump, Wireshark,
927      * and so on.)
928      *
929      * XXX - if we conclude we're using AIX libpcap, should we also
930      * set a flag to cause us to assume the time stamps are in
931      * seconds-and-nanoseconds form, and to convert them to
932      * seconds-and-microseconds form before processing them and
933      * writing them out?
934      */
935
936     /*
937      * Find the last component of the device name, which is the
938      * interface name.
939      */
940     ifacename = strchr(devname, '/');
941     if (ifacename == NULL)
942         ifacename = devname;
943
944     /* See if it matches any of the LAN device names. */
945     if (strncmp(ifacename, "en", 2) == 0) {
946         if (linktype == 6) {
947             /*
948              * That's the RFC 1573 value for Ethernet; map it to DLT_EN10MB.
949              */
950             linktype = 1;
951         }
952     } else if (strncmp(ifacename, "et", 2) == 0) {
953         if (linktype == 7) {
954             /*
955              * That's the RFC 1573 value for 802.3; map it to DLT_EN10MB.
956              * (libpcap, tcpdump, Wireshark, etc. don't care if it's Ethernet
957              * or 802.3.)
958              */
959             linktype = 1;
960         }
961     } else if (strncmp(ifacename, "tr", 2) == 0) {
962         if (linktype == 9) {
963             /*
964              * That's the RFC 1573 value for 802.5 (Token Ring); map it to
965              * DLT_IEEE802, which is what's used for Token Ring.
966              */
967             linktype = 6;
968         }
969     } else if (strncmp(ifacename, "fi", 2) == 0) {
970         if (linktype == 15) {
971             /*
972              * That's the RFC 1573 value for FDDI; map it to DLT_FDDI.
973              */
974             linktype = 10;
975         }
976     } else if (strncmp(ifacename, "lo", 2) == 0) {
977         if (linktype == 24) {
978             /*
979              * That's the RFC 1573 value for "software loopback" devices; map it
980              * to DLT_NULL, which is what's used for loopback devices on BSD.
981              */
982             linktype = 0;
983         }
984     }
985 #endif
986
987     return linktype;
988 }
989
990 static data_link_info_t *
991 create_data_link_info(int dlt)
992 {
993     data_link_info_t *data_link_info;
994     const char *text;
995
996     data_link_info = (data_link_info_t *)g_malloc(sizeof (data_link_info_t));
997     data_link_info->dlt = dlt;
998     text = pcap_datalink_val_to_name(dlt);
999     if (text != NULL)
1000         data_link_info->name = g_strdup(text);
1001     else
1002         data_link_info->name = g_strdup_printf("DLT %d", dlt);
1003     text = pcap_datalink_val_to_description(dlt);
1004     if (text != NULL)
1005         data_link_info->description = g_strdup(text);
1006     else
1007         data_link_info->description = NULL;
1008     return data_link_info;
1009 }
1010
1011 /*
1012  * Get the capabilities of a network device.
1013  */
1014 static if_capabilities_t *
1015 get_if_capabilities(const char *devname, gboolean monitor_mode
1016 #ifndef HAVE_PCAP_CREATE
1017         _U_
1018 #endif
1019 , char **err_str)
1020 {
1021     if_capabilities_t *caps;
1022     char errbuf[PCAP_ERRBUF_SIZE];
1023     pcap_t *pch;
1024 #ifdef HAVE_PCAP_CREATE
1025     int status;
1026 #endif
1027     int deflt;
1028 #ifdef HAVE_PCAP_LIST_DATALINKS
1029     int *linktypes;
1030     int i, nlt;
1031 #endif
1032     data_link_info_t *data_link_info;
1033
1034     /*
1035      * Allocate the interface capabilities structure.
1036      */
1037     caps = g_malloc(sizeof *caps);
1038
1039 #ifdef HAVE_PCAP_OPEN
1040     pch = pcap_open(devname, MIN_PACKET_SIZE, 0, 0, NULL, errbuf);
1041     caps->can_set_rfmon = FALSE;
1042     if (pch == NULL) {
1043         if (err_str != NULL)
1044             *err_str = g_strdup(errbuf);
1045         g_free(caps);
1046         return NULL;
1047     }
1048 #elif defined(HAVE_PCAP_CREATE)
1049     pch = pcap_create(devname, errbuf);
1050     if (pch == NULL) {
1051         if (err_str != NULL)
1052             *err_str = g_strdup(errbuf);
1053         g_free(caps);
1054         return NULL;
1055     }
1056     status = pcap_can_set_rfmon(pch);
1057     if (status < 0) {
1058         /* Error. */
1059         if (status == PCAP_ERROR)
1060             *err_str = g_strdup_printf("pcap_can_set_rfmon() failed: %s",
1061                                        pcap_geterr(pch));
1062         else
1063             *err_str = g_strdup(pcap_statustostr(status));
1064         pcap_close(pch);
1065         g_free(caps);
1066         return NULL;
1067     }
1068     if (status == 0)
1069         caps->can_set_rfmon = FALSE;
1070     else if (status == 1) {
1071         caps->can_set_rfmon = TRUE;
1072         if (monitor_mode)
1073             pcap_set_rfmon(pch, 1);
1074     } else {
1075         if (err_str != NULL) {
1076             *err_str = g_strdup_printf("pcap_can_set_rfmon() returned %d",
1077                                        status);
1078         }
1079         pcap_close(pch);
1080         g_free(caps);
1081         return NULL;
1082     }
1083
1084     status = pcap_activate(pch);
1085     if (status < 0) {
1086         /* Error.  We ignore warnings (status > 0). */
1087         if (err_str != NULL) {
1088             if (status == PCAP_ERROR)
1089                 *err_str = g_strdup_printf("pcap_activate() failed: %s",
1090                                            pcap_geterr(pch));
1091             else
1092                 *err_str = g_strdup(pcap_statustostr(status));
1093         }
1094         pcap_close(pch);
1095         g_free(caps);
1096         return NULL;
1097     }
1098 #else
1099     pch = pcap_open_live(devname, MIN_PACKET_SIZE, 0, 0, errbuf);
1100     caps->can_set_rfmon = FALSE;
1101     if (pch == NULL) {
1102         if (err_str != NULL)
1103             *err_str = g_strdup(errbuf);
1104         g_free(caps);
1105         return NULL;
1106     }
1107 #endif
1108     deflt = get_pcap_linktype(pch, devname);
1109 #ifdef HAVE_PCAP_LIST_DATALINKS
1110     nlt = pcap_list_datalinks(pch, &linktypes);
1111     if (nlt == 0 || linktypes == NULL) {
1112         pcap_close(pch);
1113         if (err_str != NULL)
1114             *err_str = NULL; /* an empty list doesn't mean an error */
1115         return NULL;
1116     }
1117     caps->data_link_types = NULL;
1118     for (i = 0; i < nlt; i++) {
1119         data_link_info = create_data_link_info(linktypes[i]);
1120
1121         /*
1122          * XXX - for 802.11, make the most detailed 802.11
1123          * version the default, rather than the one the
1124          * device has as the default?
1125          */
1126         if (linktypes[i] == deflt)
1127             caps->data_link_types = g_list_prepend(caps->data_link_types,
1128                                                    data_link_info);
1129         else
1130             caps->data_link_types = g_list_append(caps->data_link_types,
1131                                                   data_link_info);
1132     }
1133 #ifdef HAVE_PCAP_FREE_DATALINKS
1134     pcap_free_datalinks(linktypes);
1135 #else
1136     /*
1137      * In Windows, there's no guarantee that if you have a library
1138      * built with one version of the MSVC++ run-time library, and
1139      * it returns a pointer to allocated data, you can free that
1140      * data from a program linked with another version of the
1141      * MSVC++ run-time library.
1142      *
1143      * This is not an issue on UN*X.
1144      *
1145      * See the mail threads starting at
1146      *
1147      *    http://www.winpcap.org/pipermail/winpcap-users/2006-September/001421.html
1148      *
1149      * and
1150      *
1151      *    http://www.winpcap.org/pipermail/winpcap-users/2008-May/002498.html
1152      */
1153 #ifndef _WIN32
1154 #define xx_free free  /* hack so checkAPIs doesn't complain */
1155     xx_free(linktypes);
1156 #endif /* _WIN32 */
1157 #endif /* HAVE_PCAP_FREE_DATALINKS */
1158 #else /* HAVE_PCAP_LIST_DATALINKS */
1159
1160     data_link_info = create_data_link_info(deflt);
1161     caps->data_link_types = g_list_append(caps->data_link_types,
1162                                           data_link_info);
1163 #endif /* HAVE_PCAP_LIST_DATALINKS */
1164
1165     pcap_close(pch);
1166
1167     if (err_str != NULL)
1168         *err_str = NULL;
1169     return caps;
1170 }
1171
1172 #define ADDRSTRLEN 46 /* Covers IPv4 & IPv6 */
1173 static void
1174 print_machine_readable_interfaces(GList *if_list)
1175 {
1176     int         i;
1177     GList       *if_entry;
1178     if_info_t   *if_info;
1179     GSList      *addr;
1180     if_addr_t   *if_addr;
1181     char        addr_str[ADDRSTRLEN];
1182
1183     if (capture_child) {
1184         /* Let our parent know we succeeded. */
1185         pipe_write_block(2, SP_SUCCESS, NULL);
1186     }
1187
1188     i = 1;  /* Interface id number */
1189     for (if_entry = g_list_first(if_list); if_entry != NULL;
1190          if_entry = g_list_next(if_entry)) {
1191         if_info = (if_info_t *)if_entry->data;
1192         printf("%d. %s", i++, if_info->name);
1193
1194         /*
1195          * Print the contents of the if_entry struct in a parseable format.
1196          * Each if_entry element is tab-separated.  Addresses are comma-
1197          * separated.
1198          */
1199         /* XXX - Make sure our description doesn't contain a tab */
1200         if (if_info->description != NULL)
1201             printf("\t%s\t", if_info->description);
1202         else
1203             printf("\t\t");
1204
1205         for(addr = g_slist_nth(if_info->addrs, 0); addr != NULL;
1206                     addr = g_slist_next(addr)) {
1207             if (addr != g_slist_nth(if_info->addrs, 0))
1208                 printf(",");
1209
1210             if_addr = (if_addr_t *)addr->data;
1211             switch(if_addr->ifat_type) {
1212             case IF_AT_IPv4:
1213                 if (inet_ntop(AF_INET, &if_addr->addr.ip4_addr, addr_str,
1214                               ADDRSTRLEN)) {
1215                     printf("%s", addr_str);
1216                 } else {
1217                     printf("<unknown IPv4>");
1218                 }
1219                 break;
1220             case IF_AT_IPv6:
1221                 if (inet_ntop(AF_INET6, &if_addr->addr.ip6_addr,
1222                               addr_str, ADDRSTRLEN)) {
1223                     printf("%s", addr_str);
1224                 } else {
1225                     printf("<unknown IPv6>");
1226                 }
1227                 break;
1228             default:
1229                 printf("<type unknown %u>", if_addr->ifat_type);
1230             }
1231         }
1232
1233         if (if_info->loopback)
1234             printf("\tloopback");
1235         else
1236             printf("\tnetwork");
1237
1238         printf("\n");
1239     }
1240 }
1241
1242 /*
1243  * If you change the machine-readable output format of this function,
1244  * you MUST update capture_ifinfo.c:capture_get_if_capabilities() accordingly!
1245  */
1246 static void
1247 print_machine_readable_if_capabilities(if_capabilities_t *caps)
1248 {
1249     GList *lt_entry;
1250     data_link_info_t *data_link_info;
1251     const gchar *desc_str;
1252
1253     if (capture_child) {
1254         /* Let our parent know we succeeded. */
1255         pipe_write_block(2, SP_SUCCESS, NULL);
1256     }
1257
1258     if (caps->can_set_rfmon)
1259         printf("1\n");
1260     else
1261         printf("0\n");
1262     for (lt_entry = caps->data_link_types; lt_entry != NULL;
1263          lt_entry = g_list_next(lt_entry)) {
1264       data_link_info = (data_link_info_t *)lt_entry->data;
1265       if (data_link_info->description != NULL)
1266         desc_str = data_link_info->description;
1267       else
1268         desc_str = "(not supported)";
1269       printf("%d\t%s\t%s\n", data_link_info->dlt, data_link_info->name,
1270              desc_str);
1271     }
1272 }
1273
1274 typedef struct {
1275     char *name;
1276     pcap_t *pch;
1277 } if_stat_t;
1278
1279 /* Print the number of packets captured for each interface until we're killed. */
1280 static int
1281 print_statistics_loop(gboolean machine_readable)
1282 {
1283     GList       *if_list, *if_entry, *stat_list = NULL, *stat_entry;
1284     if_info_t   *if_info;
1285     if_stat_t   *if_stat;
1286     int         err;
1287     gchar       *err_str;
1288     pcap_t      *pch;
1289     char        errbuf[PCAP_ERRBUF_SIZE];
1290     struct pcap_stat ps;
1291
1292     if_list = get_interface_list(&err, &err_str);
1293     if (if_list == NULL) {
1294         switch (err) {
1295         case CANT_GET_INTERFACE_LIST:
1296             cmdarg_err("%s", err_str);
1297             g_free(err_str);
1298             break;
1299
1300         case NO_INTERFACES_FOUND:
1301             cmdarg_err("There are no interfaces on which a capture can be done");
1302             break;
1303         }
1304         return err;
1305     }
1306
1307     for (if_entry = g_list_first(if_list); if_entry != NULL; if_entry = g_list_next(if_entry)) {
1308         if_info = (if_info_t *)if_entry->data;
1309 #ifdef HAVE_PCAP_OPEN
1310         pch = pcap_open(if_info->name, MIN_PACKET_SIZE, 0, 0, NULL, errbuf);
1311 #else
1312         pch = pcap_open_live(if_info->name, MIN_PACKET_SIZE, 0, 0, errbuf);
1313 #endif
1314
1315         if (pch) {
1316             if_stat = (if_stat_t *)g_malloc(sizeof(if_stat_t));
1317             if_stat->name = g_strdup(if_info->name);
1318             if_stat->pch = pch;
1319             stat_list = g_list_append(stat_list, if_stat);
1320         }
1321     }
1322
1323     if (!stat_list) {
1324         cmdarg_err("There are no interfaces on which a capture can be done");
1325         return 2;
1326     }
1327
1328     if (capture_child) {
1329         /* Let our parent know we succeeded. */
1330         pipe_write_block(2, SP_SUCCESS, NULL);
1331     }
1332
1333     if (!machine_readable) {
1334         printf("%-15s  %10s  %10s\n", "Interface", "Received",
1335             "Dropped");
1336     }
1337
1338     global_ld.go = TRUE;
1339     while (global_ld.go) {
1340         for (stat_entry = g_list_first(stat_list); stat_entry != NULL; stat_entry = g_list_next(stat_entry)) {
1341             if_stat = (if_stat_t *)stat_entry->data;
1342             pcap_stats(if_stat->pch, &ps);
1343
1344             if (!machine_readable) {
1345                 printf("%-15s  %10u  %10u\n", if_stat->name,
1346                     ps.ps_recv, ps.ps_drop);
1347             } else {
1348                 printf("%s\t%u\t%u\n", if_stat->name,
1349                     ps.ps_recv, ps.ps_drop);
1350                 fflush(stdout);
1351             }
1352         }
1353 #ifdef _WIN32
1354         Sleep(1 * 1000);
1355 #else
1356         sleep(1);
1357 #endif
1358     }
1359
1360     /* XXX - Not reached.  Should we look for 'q' in stdin? */
1361     for (stat_entry = g_list_first(stat_list); stat_entry != NULL; stat_entry = g_list_next(stat_entry)) {
1362         if_stat = (if_stat_t *)stat_entry->data;
1363         pcap_close(if_stat->pch);
1364         g_free(if_stat->name);
1365         g_free(if_stat);
1366     }
1367     g_list_free(stat_list);
1368     free_interface_list(if_list);
1369
1370     return 0;
1371 }
1372
1373
1374 #ifdef _WIN32
1375 static BOOL WINAPI
1376 capture_cleanup_handler(DWORD dwCtrlType)
1377 {
1378     /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
1379        Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
1380        is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
1381        like SIGTERM at least when the machine's shutting down.
1382
1383        For now, if we're running as a command rather than a capture child,
1384        we handle all but CTRL_LOGOFF_EVENT as indications that we should
1385        clean up and quit, just as we handle SIGINT, SIGHUP, and SIGTERM
1386        in that way on UN*X.
1387
1388        If we're not running as a capture child, we might be running as
1389        a service; ignore CTRL_LOGOFF_EVENT, so we keep running after the
1390        user logs out.  (XXX - can we explicitly check whether we're
1391        running as a service?) */
1392
1393     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
1394         "Console: Control signal");
1395     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
1396         "Console: Control signal, CtrlType: %u", dwCtrlType);
1397
1398     /* Keep capture running if we're a service and a user logs off */
1399     if (capture_child || (dwCtrlType != CTRL_LOGOFF_EVENT)) {
1400         capture_loop_stop();
1401         return TRUE;
1402     } else {
1403         return FALSE;
1404     }
1405 }
1406 #else
1407 static void
1408 capture_cleanup_handler(int signum _U_)
1409 {
1410     /* On UN*X, we cleanly shut down the capture on SIGINT, SIGHUP, and
1411        SIGTERM.  We assume that if the user wanted it to keep running
1412        after they logged out, they'd have nohupped it. */
1413
1414     /* Note: don't call g_log() in the signal handler: if we happened to be in
1415      * g_log() in process context when the signal came in, g_log will detect
1416      * the "recursion" and abort.
1417      */
1418
1419     capture_loop_stop();
1420 }
1421 #endif
1422
1423
1424 static void
1425 report_capture_count(gboolean reportit)
1426 {
1427     /* Don't print this if we're a capture child. */
1428     if (!capture_child && reportit) {
1429         fprintf(stderr, "\rPackets captured: %u\n", global_ld.packet_count);
1430         /* stderr could be line buffered */
1431         fflush(stderr);
1432     }
1433 }
1434
1435
1436 #ifdef SIGINFO
1437 static void
1438 report_counts_for_siginfo(void)
1439 {
1440     report_capture_count(quiet);
1441     infoprint = FALSE; /* we just reported it */
1442 }
1443
1444 static void
1445 report_counts_siginfo(int signum _U_)
1446 {
1447     int sav_errno = errno;
1448
1449     /* If we've been told to delay printing, just set a flag asking
1450        that we print counts (if we're supposed to), otherwise print
1451        the count of packets captured (if we're supposed to). */
1452     if (infodelay)
1453         infoprint = TRUE;
1454     else
1455         report_counts_for_siginfo();
1456     errno = sav_errno;
1457 }
1458 #endif /* SIGINFO */
1459
1460 static void
1461 exit_main(int status)
1462 {
1463 #ifdef _WIN32
1464     /* Shutdown windows sockets */
1465     WSACleanup();
1466
1467     /* can be helpful for debugging */
1468 #ifdef DEBUG_DUMPCAP
1469     printf("Press any key\n");
1470     _getch();
1471 #endif
1472
1473 #endif /* _WIN32 */
1474
1475     exit(status);
1476 }
1477
1478 #ifdef HAVE_LIBCAP
1479 /*
1480  * If we were linked with libcap (not libpcap), make sure we have
1481  * CAP_NET_ADMIN and CAP_NET_RAW, then relinquish our permissions.
1482  * (See comment in main() for details)
1483  */
1484 static void
1485 relinquish_privs_except_capture(void)
1486 {
1487     /* If 'started_with_special_privs' (ie: suid) then enable for
1488      *  ourself the  NET_ADMIN and NET_RAW capabilities and then
1489      *  drop our suid privileges.
1490      *
1491      * CAP_NET_ADMIN: Promiscuous mode and a truckload of other
1492      *                stuff we don't need (and shouldn't have).
1493      * CAP_NET_RAW:   Packet capture (raw sockets).
1494      */
1495
1496     if (started_with_special_privs()) {
1497         cap_value_t cap_list[2] = { CAP_NET_ADMIN, CAP_NET_RAW };
1498         int cl_len = sizeof(cap_list) / sizeof(cap_value_t);
1499
1500         cap_t caps = cap_init();    /* all capabilities initialized to off */
1501
1502         print_caps("Pre drop, pre set");
1503
1504         if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) == -1) {
1505             cmdarg_err("prctl() fail return: %s", g_strerror(errno));
1506         }
1507
1508         cap_set_flag(caps, CAP_PERMITTED,   cl_len, cap_list, CAP_SET);
1509         cap_set_flag(caps, CAP_INHERITABLE, cl_len, cap_list, CAP_SET);
1510
1511         if (cap_set_proc(caps)) {
1512             cmdarg_err("cap_set_proc() fail return: %s", g_strerror(errno));
1513         }
1514         print_caps("Pre drop, post set");
1515
1516         relinquish_special_privs_perm();
1517
1518         print_caps("Post drop, pre set");
1519         cap_set_flag(caps, CAP_EFFECTIVE,   cl_len, cap_list, CAP_SET);
1520         if (cap_set_proc(caps)) {
1521             cmdarg_err("cap_set_proc() fail return: %s", g_strerror(errno));
1522         }
1523         print_caps("Post drop, post set");
1524
1525         cap_free(caps);
1526     }
1527 }
1528
1529 #endif /* HAVE_LIBCAP */
1530
1531 /* Take care of byte order in the libpcap headers read from pipes.
1532  * (function taken from wiretap/libpcap.c) */
1533 static void
1534 cap_pipe_adjust_header(gboolean byte_swapped, struct pcap_hdr *hdr, struct pcaprec_hdr *rechdr)
1535 {
1536     if (byte_swapped) {
1537         /* Byte-swap the record header fields. */
1538         rechdr->ts_sec = BSWAP32(rechdr->ts_sec);
1539         rechdr->ts_usec = BSWAP32(rechdr->ts_usec);
1540         rechdr->incl_len = BSWAP32(rechdr->incl_len);
1541         rechdr->orig_len = BSWAP32(rechdr->orig_len);
1542     }
1543
1544     /* In file format version 2.3, the "incl_len" and "orig_len" fields were
1545        swapped, in order to match the BPF header layout.
1546
1547        Unfortunately, some files were, according to a comment in the "libpcap"
1548        source, written with version 2.3 in their headers but without the
1549        interchanged fields, so if "incl_len" is greater than "orig_len" - which
1550        would make no sense - we assume that we need to swap them.  */
1551     if (hdr->version_major == 2 &&
1552         (hdr->version_minor < 3 ||
1553          (hdr->version_minor == 3 && rechdr->incl_len > rechdr->orig_len))) {
1554         guint32 temp;
1555
1556         temp = rechdr->orig_len;
1557         rechdr->orig_len = rechdr->incl_len;
1558         rechdr->incl_len = temp;
1559     }
1560 }
1561
1562 #if defined(_WIN32)
1563 /*
1564  * Thread function that reads from a pipe and pushes the data
1565  * to the main application thread.
1566  */
1567 /*
1568  * XXX Right now we use async queues for basic signaling. The main thread
1569  * sets cap_pipe_buf and cap_bytes_to_read, then pushes an item onto
1570  * cap_pipe_pending_q which triggers a read in the cap_pipe_read thread.
1571  * Iff the read is successful cap_pipe_read pushes an item onto
1572  * cap_pipe_done_q, otherwise an error is signaled. No data is passed in
1573  * the queues themselves (yet).
1574  *
1575  * We might want to move some of the cap_pipe_dispatch logic here so that
1576  * we can let cap_pipe_read run independently, queuing up multiple reads
1577  * for the main thread (and possibly get rid of cap_pipe_read_mtx).
1578  */
1579 static void *cap_pipe_read(void *arg)
1580 {
1581     pcap_options *pcap_opts;
1582     int bytes_read;
1583 #ifdef _WIN32
1584     BOOL res;
1585     DWORD b, last_err;
1586 #else /* _WIN32 */
1587     int b;
1588 #endif /* _WIN32 */
1589
1590     pcap_opts = (pcap_options *)arg;
1591     while (pcap_opts->cap_pipe_err == PIPOK) {
1592         g_async_queue_pop(pcap_opts->cap_pipe_pending_q); /* Wait for our cue (ahem) from the main thread */
1593         g_mutex_lock(pcap_opts->cap_pipe_read_mtx);
1594         bytes_read = 0;
1595         while (bytes_read < (int) pcap_opts->cap_pipe_bytes_to_read) {
1596 #ifdef _WIN32
1597             /* If we try to use read() on a named pipe on Windows with partial
1598              * data it appears to return EOF.
1599              */
1600             res = ReadFile(pcap_opts->cap_pipe_h, pcap_opts->cap_pipe_buf+bytes_read,
1601                            pcap_opts->cap_pipe_bytes_to_read - bytes_read,
1602                            &b, NULL);
1603
1604             bytes_read += b;
1605             if (!res) {
1606                 last_err = GetLastError();
1607                 if (last_err == ERROR_MORE_DATA) {
1608                     continue;
1609                 } else if (last_err == ERROR_HANDLE_EOF || last_err == ERROR_BROKEN_PIPE || last_err == ERROR_PIPE_NOT_CONNECTED) {
1610                     pcap_opts->cap_pipe_err = PIPEOF;
1611                     bytes_read = 0;
1612                     break;
1613                 }
1614                 pcap_opts->cap_pipe_err = PIPERR;
1615                 bytes_read = -1;
1616                 break;
1617             } else if (b == 0 && pcap_opts->cap_pipe_bytes_to_read > 0) {
1618                 pcap_opts->cap_pipe_err = PIPEOF;
1619                 bytes_read = 0;
1620                 break;
1621             }
1622 #else /* _WIN32 */
1623             b = read(pcap_opts->cap_pipe_fd, pcap_opts->cap_pipe_buf+bytes_read,
1624                      pcap_opts->cap_pipe_bytes_to_read - bytes_read);
1625             if (b <= 0) {
1626                 if (b == 0) {
1627                     pcap_opts->cap_pipe_err = PIPEOF;
1628                     bytes_read = 0;
1629                     break;
1630                 } else {
1631                     pcap_opts->cap_pipe_err = PIPERR;
1632                     bytes_read = -1;
1633                     break;
1634                 }
1635             } else {
1636                 bytes_read += b;
1637             }
1638 #endif /*_WIN32 */
1639         }
1640         pcap_opts->cap_pipe_bytes_read = bytes_read;
1641         if (pcap_opts->cap_pipe_bytes_read >= pcap_opts->cap_pipe_bytes_to_read) {
1642             g_async_queue_push(pcap_opts->cap_pipe_done_q, pcap_opts->cap_pipe_buf); /* Any non-NULL value will do */
1643         }
1644         g_mutex_unlock(pcap_opts->cap_pipe_read_mtx);
1645     }
1646     return NULL;
1647 }
1648 #endif
1649
1650 #if !defined(_WIN32) || defined(MUST_DO_SELECT)
1651 /* Provide select() functionality for a single file descriptor
1652  * on UNIX/POSIX. Windows uses cap_pipe_read via a thread.
1653  *
1654  * Returns the same values as select.
1655  */
1656 static int
1657 cap_pipe_select(int pipe_fd)
1658 {
1659     fd_set      rfds;
1660     struct timeval timeout;
1661
1662     FD_ZERO(&rfds);
1663     FD_SET(pipe_fd, &rfds);
1664
1665     timeout.tv_sec = PIPE_READ_TIMEOUT / 1000000;
1666     timeout.tv_usec = PIPE_READ_TIMEOUT % 1000000;
1667
1668     return select(pipe_fd+1, &rfds, NULL, NULL, &timeout);
1669 }
1670 #endif
1671
1672
1673 /* Mimic pcap_open_live() for pipe captures
1674
1675  * We check if "pipename" is "-" (stdin), a AF_UNIX socket, or a FIFO,
1676  * open it, and read the header.
1677  *
1678  * N.B. : we can't read the libpcap formats used in RedHat 6.1 or SuSE 6.3
1679  * because we can't seek on pipes (see wiretap/libpcap.c for details) */
1680 static void
1681 cap_pipe_open_live(char *pipename,
1682                    pcap_options *pcap_opts,
1683                    struct pcap_hdr *hdr,
1684                    char *errmsg, int errmsgl)
1685 {
1686 #ifndef _WIN32
1687     ws_statb64   pipe_stat;
1688     struct sockaddr_un sa;
1689     int          b;
1690     int          fd;
1691 #else /* _WIN32 */
1692 #if 1
1693     char *pncopy, *pos;
1694     wchar_t *err_str;
1695 #endif
1696 #endif
1697 #ifndef _WIN32
1698     int          sel_ret;
1699     unsigned int bytes_read;
1700 #endif
1701     guint32       magic = 0;
1702
1703 #ifndef _WIN32
1704     pcap_opts->cap_pipe_fd = -1;
1705 #else
1706     pcap_opts->cap_pipe_h = INVALID_HANDLE_VALUE;
1707 #endif
1708     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "cap_pipe_open_live: %s", pipename);
1709
1710     /*
1711      * XXX - this blocks until a pcap per-file header has been written to
1712      * the pipe, so it could block indefinitely.
1713      */
1714     if (strcmp(pipename, "-") == 0) {
1715 #ifndef _WIN32
1716         fd = 0; /* read from stdin */
1717 #else /* _WIN32 */
1718         pcap_opts->cap_pipe_h = GetStdHandle(STD_INPUT_HANDLE);
1719 #endif  /* _WIN32 */
1720     } else {
1721 #ifndef _WIN32
1722         if (ws_stat64(pipename, &pipe_stat) < 0) {
1723             if (errno == ENOENT || errno == ENOTDIR)
1724                 pcap_opts->cap_pipe_err = PIPNEXIST;
1725             else {
1726                 g_snprintf(errmsg, errmsgl,
1727                            "The capture session could not be initiated "
1728                            "due to error getting information on pipe/socket: %s", g_strerror(errno));
1729                 pcap_opts->cap_pipe_err = PIPERR;
1730             }
1731             return;
1732         }
1733         if (S_ISFIFO(pipe_stat.st_mode)) {
1734             fd = ws_open(pipename, O_RDONLY | O_NONBLOCK, 0000 /* no creation so don't matter */);
1735             if (fd == -1) {
1736                 g_snprintf(errmsg, errmsgl,
1737                            "The capture session could not be initiated "
1738                            "due to error on pipe open: %s", g_strerror(errno));
1739                 pcap_opts->cap_pipe_err = PIPERR;
1740                 return;
1741             }
1742         } else if (S_ISSOCK(pipe_stat.st_mode)) {
1743             fd = socket(AF_UNIX, SOCK_STREAM, 0);
1744             if (fd == -1) {
1745                 g_snprintf(errmsg, errmsgl,
1746                            "The capture session could not be initiated "
1747                            "due to error on socket create: %s", g_strerror(errno));
1748                 pcap_opts->cap_pipe_err = PIPERR;
1749                 return;
1750             }
1751             sa.sun_family = AF_UNIX;
1752             /*
1753              * The Single UNIX Specification says:
1754              *
1755              *   The size of sun_path has intentionally been left undefined.
1756              *   This is because different implementations use different sizes.
1757              *   For example, 4.3 BSD uses a size of 108, and 4.4 BSD uses a size
1758              *   of 104. Since most implementations originate from BSD versions,
1759              *   the size is typically in the range 92 to 108.
1760              *
1761              *   Applications should not assume a particular length for sun_path
1762              *   or assume that it can hold {_POSIX_PATH_MAX} bytes (256).
1763              *
1764              * It also says
1765              *
1766              *   The <sys/un.h> header shall define the sockaddr_un structure,
1767              *   which shall include at least the following members:
1768              *
1769              *   sa_family_t  sun_family  Address family.
1770              *   char         sun_path[]  Socket pathname.
1771              *
1772              * so we assume that it's an array, with a specified size,
1773              * and that the size reflects the maximum path length.
1774              */
1775             if (g_strlcpy(sa.sun_path, pipename, sizeof sa.sun_path) > sizeof sa.sun_path) {
1776                 /* Path name too long */
1777                 g_snprintf(errmsg, errmsgl,
1778                            "The capture session coud not be initiated "
1779                            "due to error on socket connect: Path name too long");
1780                 pcap_opts->cap_pipe_err = PIPERR;
1781                 return;
1782             }
1783             b = connect(fd, (struct sockaddr *)&sa, sizeof sa);
1784             if (b == -1) {
1785                 g_snprintf(errmsg, errmsgl,
1786                            "The capture session coud not be initiated "
1787                            "due to error on socket connect: %s", g_strerror(errno));
1788                 pcap_opts->cap_pipe_err = PIPERR;
1789                 return;
1790             }
1791         } else {
1792             if (S_ISCHR(pipe_stat.st_mode)) {
1793                 /*
1794                  * Assume the user specified an interface on a system where
1795                  * interfaces are in /dev.  Pretend we haven't seen it.
1796                  */
1797                 pcap_opts->cap_pipe_err = PIPNEXIST;
1798             } else
1799             {
1800                 g_snprintf(errmsg, errmsgl,
1801                            "The capture session could not be initiated because\n"
1802                            "\"%s\" is neither an interface nor a socket nor a pipe", pipename);
1803                 pcap_opts->cap_pipe_err = PIPERR;
1804             }
1805             return;
1806         }
1807 #else /* _WIN32 */
1808 #define PIPE_STR "\\pipe\\"
1809         /* Under Windows, named pipes _must_ have the form
1810          * "\\<server>\pipe\<pipename>".  <server> may be "." for localhost.
1811          */
1812         pncopy = g_strdup(pipename);
1813         if ( (pos=strstr(pncopy, "\\\\")) == pncopy) {
1814             pos = strchr(pncopy + 3, '\\');
1815             if (pos && g_ascii_strncasecmp(pos, PIPE_STR, strlen(PIPE_STR)) != 0)
1816                 pos = NULL;
1817         }
1818
1819         g_free(pncopy);
1820
1821         if (!pos) {
1822             g_snprintf(errmsg, errmsgl,
1823                        "The capture session could not be initiated because\n"
1824                        "\"%s\" is neither an interface nor a pipe", pipename);
1825             pcap_opts->cap_pipe_err = PIPNEXIST;
1826             return;
1827         }
1828
1829         /* Wait for the pipe to appear */
1830         while (1) {
1831             pcap_opts->cap_pipe_h = CreateFile(utf_8to16(pipename), GENERIC_READ, 0, NULL,
1832                                                OPEN_EXISTING, 0, NULL);
1833
1834             if (pcap_opts->cap_pipe_h != INVALID_HANDLE_VALUE)
1835                 break;
1836
1837             if (GetLastError() != ERROR_PIPE_BUSY) {
1838                 FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1839                               NULL, GetLastError(), 0, (LPTSTR) &err_str, 0, NULL);
1840                 g_snprintf(errmsg, errmsgl,
1841                            "The capture session on \"%s\" could not be started "
1842                            "due to error on pipe open: %s (error %d)",
1843                            pipename, utf_16to8(err_str), GetLastError());
1844                 LocalFree(err_str);
1845                 pcap_opts->cap_pipe_err = PIPERR;
1846                 return;
1847             }
1848
1849             if (!WaitNamedPipe(utf_8to16(pipename), 30 * 1000)) {
1850                 FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
1851                               NULL, GetLastError(), 0, (LPTSTR) &err_str, 0, NULL);
1852                 g_snprintf(errmsg, errmsgl,
1853                            "The capture session on \"%s\" timed out during "
1854                            "pipe open: %s (error %d)",
1855                            pipename, utf_16to8(err_str), GetLastError());
1856                 LocalFree(err_str);
1857                 pcap_opts->cap_pipe_err = PIPERR;
1858                 return;
1859             }
1860         }
1861 #endif /* _WIN32 */
1862     }
1863
1864     pcap_opts->from_cap_pipe = TRUE;
1865
1866 #ifndef _WIN32
1867     /* read the pcap header */
1868     bytes_read = 0;
1869     while (bytes_read < sizeof magic) {
1870         sel_ret = cap_pipe_select(fd);
1871         if (sel_ret < 0) {
1872             g_snprintf(errmsg, errmsgl,
1873                        "Unexpected error from select: %s", g_strerror(errno));
1874             goto error;
1875         } else if (sel_ret > 0) {
1876             b = read(fd, ((char *)&magic)+bytes_read, sizeof magic-bytes_read);
1877             if (b <= 0) {
1878                 if (b == 0)
1879                     g_snprintf(errmsg, errmsgl, "End of file on pipe magic during open");
1880                 else
1881                     g_snprintf(errmsg, errmsgl, "Error on pipe magic during open: %s",
1882                                g_strerror(errno));
1883                 goto error;
1884             }
1885             bytes_read += b;
1886         }
1887     }
1888 #else
1889     g_thread_create(&cap_pipe_read, pcap_opts, FALSE, NULL);
1890
1891     pcap_opts->cap_pipe_buf = (char *) &magic;
1892     pcap_opts->cap_pipe_bytes_read = 0;
1893     pcap_opts->cap_pipe_bytes_to_read = sizeof(magic);
1894     /* We don't have to worry about cap_pipe_read_mtx here */
1895     g_async_queue_push(pcap_opts->cap_pipe_pending_q, pcap_opts->cap_pipe_buf);
1896     g_async_queue_pop(pcap_opts->cap_pipe_done_q);
1897     if (pcap_opts->cap_pipe_bytes_read <= 0) {
1898         if (pcap_opts->cap_pipe_bytes_read == 0)
1899             g_snprintf(errmsg, errmsgl, "End of file on pipe magic during open");
1900         else
1901             g_snprintf(errmsg, errmsgl, "Error on pipe magic during open: %s",
1902                        g_strerror(errno));
1903         goto error;
1904     }
1905
1906 #endif
1907
1908     switch (magic) {
1909     case PCAP_MAGIC:
1910         /* Host that wrote it has our byte order, and was running
1911            a program using either standard or ss990417 libpcap. */
1912         pcap_opts->cap_pipe_byte_swapped = FALSE;
1913         pcap_opts->cap_pipe_modified = FALSE;
1914         break;
1915     case PCAP_MODIFIED_MAGIC:
1916         /* Host that wrote it has our byte order, but was running
1917            a program using either ss990915 or ss991029 libpcap. */
1918         pcap_opts->cap_pipe_byte_swapped = FALSE;
1919         pcap_opts->cap_pipe_modified = TRUE;
1920         break;
1921     case PCAP_SWAPPED_MAGIC:
1922         /* Host that wrote it has a byte order opposite to ours,
1923            and was running a program using either standard or
1924            ss990417 libpcap. */
1925         pcap_opts->cap_pipe_byte_swapped = TRUE;
1926         pcap_opts->cap_pipe_modified = FALSE;
1927         break;
1928     case PCAP_SWAPPED_MODIFIED_MAGIC:
1929         /* Host that wrote it out has a byte order opposite to
1930            ours, and was running a program using either ss990915
1931            or ss991029 libpcap. */
1932         pcap_opts->cap_pipe_byte_swapped = TRUE;
1933         pcap_opts->cap_pipe_modified = TRUE;
1934         break;
1935     default:
1936         /* Not a "libpcap" type we know about. */
1937         g_snprintf(errmsg, errmsgl, "Unrecognized libpcap format");
1938         goto error;
1939     }
1940
1941 #ifndef _WIN32
1942     /* Read the rest of the header */
1943     bytes_read = 0;
1944     while (bytes_read < sizeof(struct pcap_hdr)) {
1945         sel_ret = cap_pipe_select(fd);
1946         if (sel_ret < 0) {
1947             g_snprintf(errmsg, errmsgl,
1948                        "Unexpected error from select: %s", g_strerror(errno));
1949             goto error;
1950         } else if (sel_ret > 0) {
1951             b = read(fd, ((char *)hdr)+bytes_read,
1952                      sizeof(struct pcap_hdr) - bytes_read);
1953             if (b <= 0) {
1954                 if (b == 0)
1955                     g_snprintf(errmsg, errmsgl, "End of file on pipe header during open");
1956                 else
1957                     g_snprintf(errmsg, errmsgl, "Error on pipe header during open: %s",
1958                                g_strerror(errno));
1959                 goto error;
1960             }
1961             bytes_read += b;
1962         }
1963     }
1964 #else
1965     pcap_opts->cap_pipe_buf = (char *) hdr;
1966     pcap_opts->cap_pipe_bytes_read = 0;
1967     pcap_opts->cap_pipe_bytes_to_read = sizeof(struct pcap_hdr);
1968     g_async_queue_push(pcap_opts->cap_pipe_pending_q, pcap_opts->cap_pipe_buf);
1969     g_async_queue_pop(pcap_opts->cap_pipe_done_q);
1970     if (pcap_opts->cap_pipe_bytes_read <= 0) {
1971         if (pcap_opts->cap_pipe_bytes_read == 0)
1972             g_snprintf(errmsg, errmsgl, "End of file on pipe header during open");
1973         else
1974             g_snprintf(errmsg, errmsgl, "Error on pipe header header during open: %s",
1975                        g_strerror(errno));
1976         goto error;
1977     }
1978 #endif
1979
1980     if (pcap_opts->cap_pipe_byte_swapped) {
1981         /* Byte-swap the header fields about which we care. */
1982         hdr->version_major = BSWAP16(hdr->version_major);
1983         hdr->version_minor = BSWAP16(hdr->version_minor);
1984         hdr->snaplen = BSWAP32(hdr->snaplen);
1985         hdr->network = BSWAP32(hdr->network);
1986     }
1987     pcap_opts->linktype = hdr->network;
1988
1989     if (hdr->version_major < 2) {
1990         g_snprintf(errmsg, errmsgl, "Unable to read old libpcap format");
1991         goto error;
1992     }
1993
1994     pcap_opts->cap_pipe_state = STATE_EXPECT_REC_HDR;
1995     pcap_opts->cap_pipe_err = PIPOK;
1996 #ifndef _WIN32
1997     pcap_opts->cap_pipe_fd = fd;
1998 #endif
1999     return;
2000
2001 error:
2002     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "cap_pipe_open_live: error %s", errmsg);
2003     pcap_opts->cap_pipe_err = PIPERR;
2004 #ifndef _WIN32
2005     ws_close(fd);
2006     pcap_opts->cap_pipe_fd = -1;
2007 #endif
2008     return;
2009
2010 }
2011
2012
2013 /* We read one record from the pipe, take care of byte order in the record
2014  * header, write the record to the capture file, and update capture statistics. */
2015 static int
2016 cap_pipe_dispatch(loop_data *ld, pcap_options *pcap_opts, guchar *data, char *errmsg, int errmsgl)
2017 {
2018     struct pcap_pkthdr phdr;
2019     enum { PD_REC_HDR_READ, PD_DATA_READ, PD_PIPE_EOF, PD_PIPE_ERR,
2020            PD_ERR } result;
2021 #ifdef _WIN32
2022     GTimeVal wait_time;
2023     gpointer q_status;
2024 #else
2025     int b;
2026 #endif
2027 #ifdef _WIN32
2028     wchar_t *err_str;
2029 #endif
2030
2031 #ifdef LOG_CAPTURE_VERBOSE
2032     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "cap_pipe_dispatch");
2033 #endif
2034
2035     switch (pcap_opts->cap_pipe_state) {
2036
2037     case STATE_EXPECT_REC_HDR:
2038 #ifdef _WIN32
2039         if (g_mutex_trylock(pcap_opts->cap_pipe_read_mtx)) {
2040 #endif
2041
2042             pcap_opts->cap_pipe_state = STATE_READ_REC_HDR;
2043             pcap_opts->cap_pipe_bytes_to_read = pcap_opts->cap_pipe_modified ?
2044                 sizeof(struct pcaprec_modified_hdr) : sizeof(struct pcaprec_hdr);
2045             pcap_opts->cap_pipe_bytes_read = 0;
2046
2047 #ifdef _WIN32
2048             pcap_opts->cap_pipe_buf = (char *) &pcap_opts->cap_pipe_rechdr;
2049             g_async_queue_push(pcap_opts->cap_pipe_pending_q, pcap_opts->cap_pipe_buf);
2050             g_mutex_unlock(pcap_opts->cap_pipe_read_mtx);
2051         }
2052 #endif
2053         /* Fall through */
2054
2055     case STATE_READ_REC_HDR:
2056 #ifndef _WIN32
2057         b = read(pcap_opts->cap_pipe_fd, ((char *)&pcap_opts->cap_pipe_rechdr)+pcap_opts->cap_pipe_bytes_read,
2058                  pcap_opts->cap_pipe_bytes_to_read - pcap_opts->cap_pipe_bytes_read);
2059         if (b <= 0) {
2060             if (b == 0)
2061                 result = PD_PIPE_EOF;
2062             else
2063                 result = PD_PIPE_ERR;
2064             break;
2065         }
2066         pcap_opts->cap_pipe_bytes_read += b;
2067 #else
2068         g_get_current_time(&wait_time);
2069         g_time_val_add(&wait_time, PIPE_READ_TIMEOUT);
2070         q_status = g_async_queue_timed_pop(pcap_opts->cap_pipe_done_q, &wait_time);
2071         if (pcap_opts->cap_pipe_err == PIPEOF) {
2072             result = PD_PIPE_EOF;
2073             break;
2074         } else if (pcap_opts->cap_pipe_err == PIPERR) {
2075             result = PD_PIPE_ERR;
2076             break;
2077         }
2078         if (!q_status) {
2079             return 0;
2080         }
2081 #endif
2082         if ((pcap_opts->cap_pipe_bytes_read) < pcap_opts->cap_pipe_bytes_to_read)
2083             return 0;
2084         result = PD_REC_HDR_READ;
2085         break;
2086
2087     case STATE_EXPECT_DATA:
2088 #ifdef _WIN32
2089         if (g_mutex_trylock(pcap_opts->cap_pipe_read_mtx)) {
2090 #endif
2091
2092             pcap_opts->cap_pipe_state = STATE_READ_DATA;
2093             pcap_opts->cap_pipe_bytes_to_read = pcap_opts->cap_pipe_rechdr.hdr.incl_len;
2094             pcap_opts->cap_pipe_bytes_read = 0;
2095
2096 #ifdef _WIN32
2097             pcap_opts->cap_pipe_buf = (char *) data;
2098             g_async_queue_push(pcap_opts->cap_pipe_pending_q, pcap_opts->cap_pipe_buf);
2099             g_mutex_unlock(pcap_opts->cap_pipe_read_mtx);
2100         }
2101 #endif
2102         /* Fall through */
2103
2104     case STATE_READ_DATA:
2105 #ifndef _WIN32
2106         b = read(pcap_opts->cap_pipe_fd, data+pcap_opts->cap_pipe_bytes_read,
2107                  pcap_opts->cap_pipe_bytes_to_read - pcap_opts->cap_pipe_bytes_read);
2108         if (b <= 0) {
2109             if (b == 0)
2110                 result = PD_PIPE_EOF;
2111             else
2112                 result = PD_PIPE_ERR;
2113             break;
2114         }
2115         pcap_opts->cap_pipe_bytes_read += b;
2116 #else
2117         g_get_current_time(&wait_time);
2118         g_time_val_add(&wait_time, PIPE_READ_TIMEOUT);
2119         q_status = g_async_queue_timed_pop(pcap_opts->cap_pipe_done_q, &wait_time);
2120         if (pcap_opts->cap_pipe_err == PIPEOF) {
2121             result = PD_PIPE_EOF;
2122             break;
2123         } else if (pcap_opts->cap_pipe_err == PIPERR) {
2124             result = PD_PIPE_ERR;
2125             break;
2126         }
2127         if (!q_status) {
2128             return 0;
2129         }
2130 #endif
2131         if ((pcap_opts->cap_pipe_bytes_read) < pcap_opts->cap_pipe_bytes_to_read)
2132             return 0;
2133         result = PD_DATA_READ;
2134         break;
2135
2136     default:
2137         g_snprintf(errmsg, errmsgl, "cap_pipe_dispatch: invalid state");
2138         result = PD_ERR;
2139
2140     } /* switch (ld->cap_pipe_state) */
2141
2142     /*
2143      * We've now read as much data as we were expecting, so process it.
2144      */
2145     switch (result) {
2146
2147     case PD_REC_HDR_READ:
2148         /* We've read the header. Take care of byte order. */
2149         cap_pipe_adjust_header(pcap_opts->cap_pipe_byte_swapped, &pcap_opts->cap_pipe_hdr,
2150                                &pcap_opts->cap_pipe_rechdr.hdr);
2151         if (pcap_opts->cap_pipe_rechdr.hdr.incl_len > WTAP_MAX_PACKET_SIZE) {
2152             g_snprintf(errmsg, errmsgl, "Frame %u too long (%d bytes)",
2153                        ld->packet_count+1, pcap_opts->cap_pipe_rechdr.hdr.incl_len);
2154             break;
2155         }
2156
2157         if (pcap_opts->cap_pipe_rechdr.hdr.incl_len) {
2158             pcap_opts->cap_pipe_state = STATE_EXPECT_DATA;
2159             return 0;
2160         }
2161         /* no data to read? fall through */
2162
2163     case PD_DATA_READ:
2164         /* Fill in a "struct pcap_pkthdr", and process the packet. */
2165         phdr.ts.tv_sec = pcap_opts->cap_pipe_rechdr.hdr.ts_sec;
2166         phdr.ts.tv_usec = pcap_opts->cap_pipe_rechdr.hdr.ts_usec;
2167         phdr.caplen = pcap_opts->cap_pipe_rechdr.hdr.incl_len;
2168         phdr.len = pcap_opts->cap_pipe_rechdr.hdr.orig_len;
2169
2170         if (use_threads) {
2171             capture_loop_queue_packet_cb((u_char *)pcap_opts, &phdr, data);
2172         } else {
2173             capture_loop_write_packet_cb((u_char *)pcap_opts, &phdr, data);
2174         }
2175         pcap_opts->cap_pipe_state = STATE_EXPECT_REC_HDR;
2176         return 1;
2177
2178     case PD_PIPE_EOF:
2179         pcap_opts->cap_pipe_err = PIPEOF;
2180         return -1;
2181
2182     case PD_PIPE_ERR:
2183 #ifdef _WIN32
2184         FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
2185                       NULL, GetLastError(), 0, (LPTSTR) &err_str, 0, NULL);
2186         g_snprintf(errmsg, errmsgl,
2187                    "Error reading from pipe: %s (error %d)",
2188                    utf_16to8(err_str), GetLastError());
2189         LocalFree(err_str);
2190 #else
2191         g_snprintf(errmsg, errmsgl, "Error reading from pipe: %s",
2192                    g_strerror(errno));
2193 #endif
2194         /* Fall through */
2195     case PD_ERR:
2196         break;
2197     }
2198
2199     pcap_opts->cap_pipe_err = PIPERR;
2200     /* Return here rather than inside the switch to prevent GCC warning */
2201     return -1;
2202 }
2203
2204
2205 /** Open the capture input file (pcap or capture pipe).
2206  *  Returns TRUE if it succeeds, FALSE otherwise. */
2207 static gboolean
2208 capture_loop_open_input(capture_options *capture_opts, loop_data *ld,
2209                         char *errmsg, size_t errmsg_len,
2210                         char *secondary_errmsg, size_t secondary_errmsg_len)
2211 {
2212     gchar             open_err_str[PCAP_ERRBUF_SIZE];
2213     gchar             *sync_msg_str;
2214     interface_options interface_opts;
2215     pcap_options      *pcap_opts;
2216     guint             i;
2217 #ifdef _WIN32
2218     int         err;
2219     gchar      *sync_secondary_msg_str;
2220     WORD        wVersionRequested;
2221     WSADATA     wsaData;
2222 #endif
2223
2224 /* XXX - opening Winsock on tshark? */
2225
2226     /* Initialize Windows Socket if we are in a WIN32 OS
2227        This needs to be done before querying the interface for network/netmask */
2228 #ifdef _WIN32
2229     /* XXX - do we really require 1.1 or earlier?
2230        Are there any versions that support only 2.0 or higher? */
2231     wVersionRequested = MAKEWORD(1, 1);
2232     err = WSAStartup(wVersionRequested, &wsaData);
2233     if (err != 0) {
2234         switch (err) {
2235
2236         case WSASYSNOTREADY:
2237             g_snprintf(errmsg, (gulong) errmsg_len,
2238                        "Couldn't initialize Windows Sockets: Network system not ready for network communication");
2239             break;
2240
2241         case WSAVERNOTSUPPORTED:
2242             g_snprintf(errmsg, (gulong) errmsg_len,
2243                        "Couldn't initialize Windows Sockets: Windows Sockets version %u.%u not supported",
2244                        LOBYTE(wVersionRequested), HIBYTE(wVersionRequested));
2245             break;
2246
2247         case WSAEINPROGRESS:
2248             g_snprintf(errmsg, (gulong) errmsg_len,
2249                        "Couldn't initialize Windows Sockets: Blocking operation is in progress");
2250             break;
2251
2252         case WSAEPROCLIM:
2253             g_snprintf(errmsg, (gulong) errmsg_len,
2254                        "Couldn't initialize Windows Sockets: Limit on the number of tasks supported by this WinSock implementation has been reached");
2255             break;
2256
2257         case WSAEFAULT:
2258             g_snprintf(errmsg, (gulong) errmsg_len,
2259                        "Couldn't initialize Windows Sockets: Bad pointer passed to WSAStartup");
2260             break;
2261
2262         default:
2263             g_snprintf(errmsg, (gulong) errmsg_len,
2264                        "Couldn't initialize Windows Sockets: error %d", err);
2265             break;
2266         }
2267         g_snprintf(secondary_errmsg, (gulong) secondary_errmsg_len, please_report);
2268         return FALSE;
2269     }
2270 #endif
2271     if ((use_threads == FALSE) &&
2272         (capture_opts->ifaces->len > 1)) {
2273         g_snprintf(errmsg, (gulong) errmsg_len,
2274                    "Using threads is required for capturing on mulitple interfaces!");
2275         return FALSE;
2276     }
2277
2278     for (i = 0; i < capture_opts->ifaces->len; i++) {
2279         interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
2280         pcap_opts = (pcap_options *)g_malloc(sizeof (pcap_options));
2281         if (pcap_opts == NULL) {
2282             g_snprintf(errmsg, (gulong) errmsg_len,
2283                    "Could not allocate memory.");
2284             return FALSE;
2285         }
2286         pcap_opts->received = 0;
2287         pcap_opts->dropped = 0;
2288         pcap_opts->pcap_h = NULL;
2289 #ifdef MUST_DO_SELECT
2290         pcap_opts->pcap_fd = -1;
2291 #endif
2292         pcap_opts->pcap_err = FALSE;
2293         pcap_opts->interface_id = i;
2294         pcap_opts->tid = NULL;
2295         pcap_opts->snaplen = 0;
2296         pcap_opts->linktype = -1;
2297         pcap_opts->from_cap_pipe = FALSE;
2298         memset(&pcap_opts->cap_pipe_hdr, 0, sizeof(struct pcap_hdr));
2299         memset(&pcap_opts->cap_pipe_rechdr, 0, sizeof(struct pcaprec_modified_hdr));
2300 #ifdef _WIN32
2301         pcap_opts->cap_pipe_h = INVALID_HANDLE_VALUE;
2302 #else
2303         pcap_opts->cap_pipe_fd = -1;
2304 #endif
2305         pcap_opts->cap_pipe_modified = FALSE;
2306         pcap_opts->cap_pipe_byte_swapped = FALSE;
2307 #ifdef _WIN32
2308         pcap_opts->cap_pipe_buf = NULL;
2309 #endif
2310         pcap_opts->cap_pipe_bytes_to_read = 0;
2311         pcap_opts->cap_pipe_bytes_read = 0;
2312         pcap_opts->cap_pipe_state = 0;
2313         pcap_opts->cap_pipe_err = PIPOK;
2314 #ifdef _WIN32
2315 #if GLIB_CHECK_VERSION(2,31,0)
2316         pcap_opts->cap_pipe_read_mtx = g_malloc(sizeof(GMutex));
2317         g_mutex_init(pcap_opts->cap_pipe_read_mtx);
2318 #else
2319         pcap_opts->cap_pipe_read_mtx = g_mutex_new();
2320 #endif
2321         pcap_opts->cap_pipe_pending_q = g_async_queue_new();
2322         pcap_opts->cap_pipe_done_q = g_async_queue_new();
2323 #endif
2324         g_array_append_val(ld->pcaps, pcap_opts);
2325
2326         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_open_input : %s", interface_opts.name);
2327         pcap_opts->pcap_h = open_capture_device(&interface_opts, &open_err_str);
2328
2329         if (pcap_opts->pcap_h != NULL) {
2330             /* we've opened "iface" as a network device */
2331 #ifdef _WIN32
2332             /* try to set the capture buffer size */
2333             if (interface_opts.buffer_size > 1 &&
2334                 pcap_setbuff(pcap_opts->pcap_h, interface_opts.buffer_size * 1024 * 1024) != 0) {
2335                 sync_secondary_msg_str = g_strdup_printf(
2336                     "The capture buffer size of %dMB seems to be too high for your machine,\n"
2337                     "the default of 1MB will be used.\n"
2338                     "\n"
2339                     "Nonetheless, the capture is started.\n",
2340                     interface_opts.buffer_size);
2341                 report_capture_error("Couldn't set the capture buffer size!",
2342                                      sync_secondary_msg_str);
2343                 g_free(sync_secondary_msg_str);
2344             }
2345 #endif
2346
2347 #if defined(HAVE_PCAP_SETSAMPLING)
2348             if (interface_opts.sampling_method != CAPTURE_SAMP_NONE) {
2349                 struct pcap_samp *samp;
2350
2351                 if ((samp = pcap_setsampling(pcap_opts->pcap_h)) != NULL) {
2352                     switch (interface_opts.sampling_method) {
2353                     case CAPTURE_SAMP_BY_COUNT:
2354                         samp->method = PCAP_SAMP_1_EVERY_N;
2355                         break;
2356
2357                     case CAPTURE_SAMP_BY_TIMER:
2358                         samp->method = PCAP_SAMP_FIRST_AFTER_N_MS;
2359                         break;
2360
2361                     default:
2362                         sync_msg_str = g_strdup_printf(
2363                             "Unknown sampling method %d specified,\n"
2364                             "continue without packet sampling",
2365                             interface_opts.sampling_method);
2366                         report_capture_error("Couldn't set the capture "
2367                                              "sampling", sync_msg_str);
2368                         g_free(sync_msg_str);
2369                     }
2370                     samp->value = interface_opts.sampling_param;
2371                 } else {
2372                     report_capture_error("Couldn't set the capture sampling",
2373                                          "Cannot get packet sampling data structure");
2374                 }
2375             }
2376 #endif
2377
2378             /* setting the data link type only works on real interfaces */
2379             if (!set_pcap_linktype(pcap_opts->pcap_h, interface_opts.linktype, interface_opts.name,
2380                                    errmsg, errmsg_len,
2381                                    secondary_errmsg, secondary_errmsg_len)) {
2382                 return FALSE;
2383             }
2384             pcap_opts->linktype = get_pcap_linktype(pcap_opts->pcap_h, interface_opts.name);
2385         } else {
2386             /* We couldn't open "iface" as a network device. */
2387             /* Try to open it as a pipe */
2388             cap_pipe_open_live(interface_opts.name, pcap_opts, &pcap_opts->cap_pipe_hdr, errmsg, (int) errmsg_len);
2389
2390 #ifndef _WIN32
2391             if (pcap_opts->cap_pipe_fd == -1) {
2392 #else
2393             if (pcap_opts->cap_pipe_h == INVALID_HANDLE_VALUE) {
2394 #endif
2395                 if (pcap_opts->cap_pipe_err == PIPNEXIST) {
2396                     /* Pipe doesn't exist, so output message for interface */
2397                     get_capture_device_open_failure_messages(open_err_str,
2398                                                              interface_opts.name,
2399                                                              errmsg,
2400                                                              errmsg_len,
2401                                                              secondary_errmsg,
2402                                                              secondary_errmsg_len);
2403                 }
2404                 /*
2405                  * Else pipe (or file) does exist and cap_pipe_open_live() has
2406                  * filled in errmsg
2407                  */
2408                 return FALSE;
2409             } else {
2410                 /* cap_pipe_open_live() succeeded; don't want
2411                    error message from pcap_open_live() */
2412                 open_err_str[0] = '\0';
2413             }
2414         }
2415
2416 /* XXX - will this work for tshark? */
2417 #ifdef MUST_DO_SELECT
2418         if (!pcap_opts->from_cap_pipe) {
2419 #ifdef HAVE_PCAP_GET_SELECTABLE_FD
2420             pcap_opts->pcap_fd = pcap_get_selectable_fd(pcap_opts->pcap_h);
2421 #else
2422             pcap_opts->pcap_fd = pcap_fileno(pcap_opts->pcap_h);
2423 #endif
2424         }
2425 #endif
2426
2427         /* Does "open_err_str" contain a non-empty string?  If so, "pcap_open_live()"
2428            returned a warning; print it, but keep capturing. */
2429         if (open_err_str[0] != '\0') {
2430             sync_msg_str = g_strdup_printf("%s.", open_err_str);
2431             report_capture_error(sync_msg_str, "");
2432             g_free(sync_msg_str);
2433         }
2434         capture_opts->ifaces = g_array_remove_index(capture_opts->ifaces, i);
2435         g_array_insert_val(capture_opts->ifaces, i, interface_opts);
2436     }
2437
2438     /* If not using libcap: we now can now set euid/egid to ruid/rgid         */
2439     /*  to remove any suid privileges.                                        */
2440     /* If using libcap: we can now remove NET_RAW and NET_ADMIN capabilities  */
2441     /*  (euid/egid have already previously been set to ruid/rgid.             */
2442     /* (See comment in main() for details)                                    */
2443 #ifndef HAVE_LIBCAP
2444     relinquish_special_privs_perm();
2445 #else
2446     relinquish_all_capabilities();
2447 #endif
2448     return TRUE;
2449 }
2450
2451 /* close the capture input file (pcap or capture pipe) */
2452 static void capture_loop_close_input(loop_data *ld)
2453 {
2454     guint i;
2455     pcap_options *pcap_opts;
2456
2457     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_close_input");
2458
2459     for (i = 0; i < ld->pcaps->len; i++) {
2460         pcap_opts = g_array_index(ld->pcaps, pcap_options *, i);
2461         /* if open, close the capture pipe "input file" */
2462 #ifndef _WIN32
2463         if (pcap_opts->cap_pipe_fd >= 0) {
2464             g_assert(pcap_opts->from_cap_pipe);
2465             ws_close(pcap_opts->cap_pipe_fd);
2466             pcap_opts->cap_pipe_fd = -1;
2467         }
2468 #else
2469         if (pcap_opts->cap_pipe_h != INVALID_HANDLE_VALUE) {
2470             CloseHandle(pcap_opts->cap_pipe_h);
2471             pcap_opts->cap_pipe_h = INVALID_HANDLE_VALUE;
2472         }
2473 #endif
2474         /* if open, close the pcap "input file" */
2475         if (pcap_opts->pcap_h != NULL) {
2476             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_close_input: closing %p", (void *)pcap_opts->pcap_h);
2477             pcap_close(pcap_opts->pcap_h);
2478             pcap_opts->pcap_h = NULL;
2479         }
2480     }
2481
2482     ld->go = FALSE;
2483
2484 #ifdef _WIN32
2485     /* Shut down windows sockets */
2486     WSACleanup();
2487 #endif
2488 }
2489
2490
2491 /* init the capture filter */
2492 static initfilter_status_t
2493 capture_loop_init_filter(pcap_t *pcap_h, gboolean from_cap_pipe,
2494                          const gchar * name, const gchar * cfilter)
2495 {
2496     struct bpf_program fcode;
2497
2498     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_init_filter: %s", cfilter);
2499
2500     /* capture filters only work on real interfaces */
2501     if (cfilter && !from_cap_pipe) {
2502         /* A capture filter was specified; set it up. */
2503         if (!compile_capture_filter(name, pcap_h, &fcode, cfilter)) {
2504             /* Treat this specially - our caller might try to compile this
2505                as a display filter and, if that succeeds, warn the user that
2506                the display and capture filter syntaxes are different. */
2507             return INITFILTER_BAD_FILTER;
2508         }
2509         if (pcap_setfilter(pcap_h, &fcode) < 0) {
2510 #ifdef HAVE_PCAP_FREECODE
2511             pcap_freecode(&fcode);
2512 #endif
2513             return INITFILTER_OTHER_ERROR;
2514         }
2515 #ifdef HAVE_PCAP_FREECODE
2516         pcap_freecode(&fcode);
2517 #endif
2518     }
2519
2520     return INITFILTER_NO_ERROR;
2521 }
2522
2523
2524 /* set up to write to the already-opened capture output file/files */
2525 static gboolean
2526 capture_loop_init_output(capture_options *capture_opts, loop_data *ld, char *errmsg, int errmsg_len)
2527 {
2528     int err;
2529     guint i;
2530     pcap_options *pcap_opts;
2531     interface_options interface_opts;
2532     gboolean successful;
2533
2534     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_init_output");
2535
2536     if ((capture_opts->use_pcapng == FALSE) &&
2537         (capture_opts->ifaces->len > 1)) {
2538         g_snprintf(errmsg, errmsg_len,
2539                    "Using PCAPNG is required for capturing on mulitple interfaces! Use the -n option.");
2540         return FALSE;
2541     }
2542
2543     /* Set up to write to the capture file. */
2544     if (capture_opts->multi_files_on) {
2545         ld->pdh = ringbuf_init_libpcap_fdopen(&err);
2546     } else {
2547         ld->pdh = libpcap_fdopen(ld->save_file_fd, &err);
2548     }
2549     if (ld->pdh) {
2550         if (capture_opts->use_pcapng) {
2551             char appname[100];
2552
2553             g_snprintf(appname, sizeof(appname), "Dumpcap " VERSION "%s", wireshark_svnversion);
2554             successful = libpcap_write_session_header_block(ld->pdh, appname, &ld->bytes_written, &err);
2555             for (i = 0; successful && (i < capture_opts->ifaces->len); i++) {
2556                 interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
2557                 pcap_opts = g_array_index(ld->pcaps, pcap_options *, i);
2558                 if (pcap_opts->from_cap_pipe) {
2559                     pcap_opts->snaplen = pcap_opts->cap_pipe_hdr.snaplen;
2560                 } else {
2561                     pcap_opts->snaplen = pcap_snapshot(pcap_opts->pcap_h);
2562                 }
2563                 successful = libpcap_write_interface_description_block(ld->pdh,
2564                                                                        interface_opts.name,
2565                                                                        interface_opts.cfilter?interface_opts.cfilter:"",
2566                                                                        pcap_opts->linktype,
2567                                                                        pcap_opts->snaplen,
2568                                                                        &ld->bytes_written,
2569                                                                        &err);
2570             }
2571         } else {
2572             pcap_opts = g_array_index(ld->pcaps, pcap_options *, 0);
2573             if (pcap_opts->from_cap_pipe) {
2574                 pcap_opts->snaplen = pcap_opts->cap_pipe_hdr.snaplen;
2575             } else {
2576                 pcap_opts->snaplen = pcap_snapshot(pcap_opts->pcap_h);
2577             }
2578             successful = libpcap_write_file_header(ld->pdh, pcap_opts->linktype, pcap_opts->snaplen,
2579                                                    &ld->bytes_written, &err);
2580         }
2581         if (!successful) {
2582             fclose(ld->pdh);
2583             ld->pdh = NULL;
2584         }
2585     }
2586
2587     if (ld->pdh == NULL) {
2588         /* We couldn't set up to write to the capture file. */
2589         /* XXX - use cf_open_error_message from tshark instead? */
2590         switch (err) {
2591
2592         default:
2593             if (err < 0) {
2594                 g_snprintf(errmsg, errmsg_len,
2595                            "The file to which the capture would be"
2596                            " saved (\"%s\") could not be opened: Error %d.",
2597                            capture_opts->save_file, err);
2598             } else {
2599                 g_snprintf(errmsg, errmsg_len,
2600                            "The file to which the capture would be"
2601                            " saved (\"%s\") could not be opened: %s.",
2602                            capture_opts->save_file, g_strerror(err));
2603             }
2604             break;
2605         }
2606
2607         return FALSE;
2608     }
2609
2610     return TRUE;
2611 }
2612
2613 static gboolean
2614 capture_loop_close_output(capture_options *capture_opts, loop_data *ld, int *err_close)
2615 {
2616
2617     unsigned int i;
2618     pcap_options *pcap_opts;
2619
2620     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_close_output");
2621
2622     if (capture_opts->multi_files_on) {
2623         return ringbuf_libpcap_dump_close(&capture_opts->save_file, err_close);
2624     } else {
2625         if (capture_opts->use_pcapng) {
2626             for (i = 0; i < global_ld.pcaps->len; i++) {
2627                 pcap_opts = g_array_index(global_ld.pcaps, pcap_options *, i);
2628                 if (!pcap_opts->from_cap_pipe) {
2629                     libpcap_write_interface_statistics_block(ld->pdh, i, pcap_opts->pcap_h, &ld->bytes_written, err_close);
2630                 }
2631             }
2632         }
2633         return libpcap_dump_close(ld->pdh, err_close);
2634     }
2635 }
2636
2637 /* dispatch incoming packets (pcap or capture pipe)
2638  *
2639  * Waits for incoming packets to be available, and calls pcap_dispatch()
2640  * to cause them to be processed.
2641  *
2642  * Returns the number of packets which were processed.
2643  *
2644  * Times out (returning zero) after CAP_READ_TIMEOUT ms; this ensures that the
2645  * packet-batching behaviour does not cause packets to get held back
2646  * indefinitely.
2647  */
2648 static int
2649 capture_loop_dispatch(loop_data *ld,
2650                       char *errmsg, int errmsg_len, pcap_options *pcap_opts)
2651 {
2652     int       inpkts;
2653     gint      packet_count_before;
2654     guchar    pcap_data[WTAP_MAX_PACKET_SIZE];
2655 #ifndef _WIN32
2656     int       sel_ret;
2657 #endif
2658
2659     packet_count_before = ld->packet_count;
2660     if (pcap_opts->from_cap_pipe) {
2661         /* dispatch from capture pipe */
2662 #ifdef LOG_CAPTURE_VERBOSE
2663         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_dispatch: from capture pipe");
2664 #endif
2665 #ifndef _WIN32
2666         sel_ret = cap_pipe_select(pcap_opts->cap_pipe_fd);
2667         if (sel_ret <= 0) {
2668             if (sel_ret < 0 && errno != EINTR) {
2669                 g_snprintf(errmsg, errmsg_len,
2670                            "Unexpected error from select: %s", g_strerror(errno));
2671                 report_capture_error(errmsg, please_report);
2672                 ld->go = FALSE;
2673             }
2674         } else {
2675             /*
2676              * "select()" says we can read from the pipe without blocking
2677              */
2678 #endif
2679             inpkts = cap_pipe_dispatch(ld, pcap_opts, pcap_data, errmsg, errmsg_len);
2680             if (inpkts < 0) {
2681                 ld->go = FALSE;
2682             }
2683 #ifndef _WIN32
2684         }
2685 #endif
2686     }
2687     else
2688     {
2689         /* dispatch from pcap */
2690 #ifdef MUST_DO_SELECT
2691         /*
2692          * If we have "pcap_get_selectable_fd()", we use it to get the
2693          * descriptor on which to select; if that's -1, it means there
2694          * is no descriptor on which you can do a "select()" (perhaps
2695          * because you're capturing on a special device, and that device's
2696          * driver unfortunately doesn't support "select()", in which case
2697          * we don't do the select - which means it might not be possible
2698          * to stop a capture until a packet arrives.  If that's unacceptable,
2699          * plead with whoever supplies the software for that device to add
2700          * "select()" support, or upgrade to libpcap 0.8.1 or later, and
2701          * rebuild Wireshark or get a version built with libpcap 0.8.1 or
2702          * later, so it can use pcap_breakloop().
2703          */
2704 #ifdef LOG_CAPTURE_VERBOSE
2705         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_dispatch: from pcap_dispatch with select");
2706 #endif
2707         if (pcap_opts->pcap_fd != -1) {
2708             sel_ret = cap_pipe_select(pcap_opts->pcap_fd);
2709             if (sel_ret > 0) {
2710                 /*
2711                  * "select()" says we can read from it without blocking; go for
2712                  * it.
2713                  *
2714                  * We don't have pcap_breakloop(), so we only process one packet
2715                  * per pcap_dispatch() call, to allow a signal to stop the
2716                  * processing immediately, rather than processing all packets
2717                  * in a batch before quitting.
2718                  */
2719                 if (use_threads) {
2720                     inpkts = pcap_dispatch(pcap_opts->pcap_h, 1, capture_loop_queue_packet_cb, (u_char *)pcap_opts);
2721                 } else {
2722                     inpkts = pcap_dispatch(pcap_opts->pcap_h, 1, capture_loop_write_packet_cb, (u_char *)pcap_opts);
2723                 }
2724                 if (inpkts < 0) {
2725                     if (inpkts == -1) {
2726                         /* Error, rather than pcap_breakloop(). */
2727                         pcap_opts->pcap_err = TRUE;
2728                     }
2729                     ld->go = FALSE; /* error or pcap_breakloop() - stop capturing */
2730                 }
2731             } else {
2732                 if (sel_ret < 0 && errno != EINTR) {
2733                     g_snprintf(errmsg, errmsg_len,
2734                                "Unexpected error from select: %s", g_strerror(errno));
2735                     report_capture_error(errmsg, please_report);
2736                     ld->go = FALSE;
2737                 }
2738             }
2739         }
2740         else
2741 #endif /* MUST_DO_SELECT */
2742         {
2743             /* dispatch from pcap without select */
2744 #if 1
2745 #ifdef LOG_CAPTURE_VERBOSE
2746             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_dispatch: from pcap_dispatch");
2747 #endif
2748 #ifdef _WIN32
2749             /*
2750              * On Windows, we don't support asynchronously telling a process to
2751              * stop capturing; instead, we check for an indication on a pipe
2752              * after processing packets.  We therefore process only one packet
2753              * at a time, so that we can check the pipe after every packet.
2754              */
2755             if (use_threads) {
2756                 inpkts = pcap_dispatch(pcap_opts->pcap_h, 1, capture_loop_queue_packet_cb, (u_char *)pcap_opts);
2757             } else {
2758                 inpkts = pcap_dispatch(pcap_opts->pcap_h, 1, capture_loop_write_packet_cb, (u_char *)pcap_opts);
2759             }
2760 #else
2761             if (use_threads) {
2762                 inpkts = pcap_dispatch(pcap_opts->pcap_h, -1, capture_loop_queue_packet_cb, (u_char *)pcap_opts);
2763             } else {
2764                 inpkts = pcap_dispatch(pcap_opts->pcap_h, -1, capture_loop_write_packet_cb, (u_char *)pcap_opts);
2765             }
2766 #endif
2767             if (inpkts < 0) {
2768                 if (inpkts == -1) {
2769                     /* Error, rather than pcap_breakloop(). */
2770                     pcap_opts->pcap_err = TRUE;
2771                 }
2772                 ld->go = FALSE; /* error or pcap_breakloop() - stop capturing */
2773             }
2774 #else /* pcap_next_ex */
2775 #ifdef LOG_CAPTURE_VERBOSE
2776             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_dispatch: from pcap_next_ex");
2777 #endif
2778             /* XXX - this is currently unused, as there is some confusion with pcap_next_ex() vs. pcap_dispatch() */
2779
2780             /*
2781              * WinPcap's remote capturing feature doesn't work with pcap_dispatch(),
2782              * see http://wiki.wireshark.org/CaptureSetup_2fWinPcapRemote
2783              * This should be fixed in the WinPcap 4.0 alpha release.
2784              *
2785              * For reference, an example remote interface:
2786              * rpcap://[1.2.3.4]/\Device\NPF_{39993D68-7C9B-4439-A329-F2D888DA7C5C}
2787              */
2788
2789             /* emulate dispatch from pcap */
2790             {
2791                 int in;
2792                 struct pcap_pkthdr *pkt_header;
2793                 u_char *pkt_data;
2794
2795                 in = 0;
2796                 while(ld->go &&
2797                       (in = pcap_next_ex(pcap_opts->pcap_h, &pkt_header, &pkt_data)) == 1) {
2798                     if (use_threads) {
2799                         capture_loop_queue_packet_cb((u_char *)pcap_opts, pkt_header, pkt_data);
2800                     } else {
2801                         capture_loop_write_packet_cb((u_char *)pcap_opts, pkt_header, pkt_data);
2802                     }
2803                 }
2804
2805                 if(in < 0) {
2806                     pcap_opts->pcap_err = TRUE;
2807                     ld->go = FALSE;
2808                 }
2809             }
2810 #endif /* pcap_next_ex */
2811         }
2812     }
2813
2814 #ifdef LOG_CAPTURE_VERBOSE
2815     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_dispatch: %d new packet%s", inpkts, plurality(inpkts, "", "s"));
2816 #endif
2817
2818     return ld->packet_count - packet_count_before;
2819 }
2820
2821 #ifdef _WIN32
2822 /* Isolate the Universally Unique Identifier from the interface.  Basically, we
2823  * want to grab only the characters between the '{' and '}' delimiters.
2824  *
2825  * Returns a GString that must be freed with g_string_free(). */
2826 static GString *
2827 isolate_uuid(const char *iface)
2828 {
2829     gchar *ptr;
2830     GString *gstr;
2831
2832     ptr = strchr(iface, '{');
2833     if (ptr == NULL)
2834         return g_string_new(iface);
2835     gstr = g_string_new(ptr + 1);
2836
2837     ptr = strchr(gstr->str, '}');
2838     if (ptr == NULL)
2839         return gstr;
2840
2841     gstr = g_string_truncate(gstr, ptr - gstr->str);
2842     return gstr;
2843 }
2844 #endif
2845
2846 /* open the output file (temporary/specified name/ringbuffer/named pipe/stdout) */
2847 /* Returns TRUE if the file opened successfully, FALSE otherwise. */
2848 static gboolean
2849 capture_loop_open_output(capture_options *capture_opts, int *save_file_fd,
2850                          char *errmsg, int errmsg_len)
2851 {
2852     char *tmpname;
2853     gchar *capfile_name;
2854     gchar *prefix;
2855     gboolean is_tempfile;
2856
2857     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_open_output: %s",
2858           (capture_opts->save_file) ? capture_opts->save_file : "(not specified)");
2859
2860     if (capture_opts->save_file != NULL) {
2861         /* We return to the caller while the capture is in progress.
2862          * Therefore we need to take a copy of save_file in
2863          * case the caller destroys it after we return.
2864          */
2865         capfile_name = g_strdup(capture_opts->save_file);
2866
2867         if (capture_opts->output_to_pipe == TRUE) { /* either "-" or named pipe */
2868             if (capture_opts->multi_files_on) {
2869                 /* ringbuffer is enabled; that doesn't work with standard output or a named pipe */
2870                 g_snprintf(errmsg, errmsg_len,
2871                            "Ring buffer requested, but capture is being written to standard output or to a named pipe.");
2872                 g_free(capfile_name);
2873                 return FALSE;
2874             }
2875             if (strcmp(capfile_name, "-") == 0) {
2876                 /* write to stdout */
2877                 *save_file_fd = 1;
2878 #ifdef _WIN32
2879                 /* set output pipe to binary mode to avoid Windows text-mode processing (eg: for CR/LF)  */
2880                 _setmode(1, O_BINARY);
2881 #endif
2882             }
2883         } /* if (...output_to_pipe ... */
2884
2885         else {
2886             if (capture_opts->multi_files_on) {
2887                 /* ringbuffer is enabled */
2888                 *save_file_fd = ringbuf_init(capfile_name,
2889                                              (capture_opts->has_ring_num_files) ? capture_opts->ring_num_files : 0,
2890                                              capture_opts->group_read_access);
2891
2892                 /* we need the ringbuf name */
2893                 if(*save_file_fd != -1) {
2894                     g_free(capfile_name);
2895                     capfile_name = g_strdup(ringbuf_current_filename());
2896                 }
2897             } else {
2898                 /* Try to open/create the specified file for use as a capture buffer. */
2899                 *save_file_fd = ws_open(capfile_name, O_RDWR|O_BINARY|O_TRUNC|O_CREAT,
2900                                         (capture_opts->group_read_access) ? 0640 : 0600);
2901             }
2902         }
2903         is_tempfile = FALSE;
2904     } else {
2905         /* Choose a random name for the temporary capture buffer */
2906         if (global_capture_opts.ifaces->len > 1) {
2907             prefix = g_strdup_printf("wireshark_%d_interfaces", global_capture_opts.ifaces->len);
2908         } else {
2909             gchar *basename;
2910 #ifdef _WIN32
2911             GString *iface;
2912             iface = isolate_uuid(g_array_index(global_capture_opts.ifaces, interface_options, 0).name);
2913             basename = g_path_get_basename(iface->str);
2914             g_string_free(iface, TRUE);
2915 #else
2916             basename = g_path_get_basename(g_array_index(global_capture_opts.ifaces, interface_options, 0).name);
2917 #endif
2918             prefix = g_strconcat("wireshark_", basename, NULL);
2919             g_free(basename);
2920         }
2921         *save_file_fd = create_tempfile(&tmpname, prefix);
2922         g_free(prefix);
2923         capfile_name = g_strdup(tmpname);
2924         is_tempfile = TRUE;
2925     }
2926
2927     /* did we fail to open the output file? */
2928     if (*save_file_fd == -1) {
2929         if (is_tempfile) {
2930             g_snprintf(errmsg, errmsg_len,
2931                        "The temporary file to which the capture would be saved (\"%s\") "
2932                        "could not be opened: %s.", capfile_name, g_strerror(errno));
2933         } else {
2934             if (capture_opts->multi_files_on) {
2935                 ringbuf_error_cleanup();
2936             }
2937
2938             g_snprintf(errmsg, errmsg_len,
2939                        "The file to which the capture would be saved (\"%s\") "
2940                        "could not be opened: %s.", capfile_name,
2941                        g_strerror(errno));
2942         }
2943         g_free(capfile_name);
2944         return FALSE;
2945     }
2946
2947     if(capture_opts->save_file != NULL) {
2948         g_free(capture_opts->save_file);
2949     }
2950     capture_opts->save_file = capfile_name;
2951     /* capture_opts.save_file is "g_free"ed later, which is equivalent to
2952        "g_free(capfile_name)". */
2953
2954     return TRUE;
2955 }
2956
2957
2958 /* Do the work of handling either the file size or file duration capture
2959    conditions being reached, and switching files or stopping. */
2960 static gboolean
2961 do_file_switch_or_stop(capture_options *capture_opts,
2962                        condition *cnd_autostop_files,
2963                        condition *cnd_autostop_size,
2964                        condition *cnd_file_duration)
2965 {
2966     guint i;
2967     pcap_options *pcap_opts;
2968     interface_options interface_opts;
2969     gboolean successful;
2970
2971     if (capture_opts->multi_files_on) {
2972         if (cnd_autostop_files != NULL &&
2973             cnd_eval(cnd_autostop_files, ++global_ld.autostop_files)) {
2974             /* no files left: stop here */
2975             global_ld.go = FALSE;
2976             return FALSE;
2977         }
2978
2979         /* Switch to the next ringbuffer file */
2980         if (ringbuf_switch_file(&global_ld.pdh, &capture_opts->save_file,
2981                                 &global_ld.save_file_fd, &global_ld.err)) {
2982
2983             /* File switch succeeded: reset the conditions */
2984             global_ld.bytes_written = 0;
2985             if (capture_opts->use_pcapng) {
2986                 char appname[100];
2987
2988                 g_snprintf(appname, sizeof(appname), "Dumpcap " VERSION "%s", wireshark_svnversion);
2989                 successful = libpcap_write_session_header_block(global_ld.pdh, appname, &(global_ld.bytes_written), &global_ld.err);
2990                 for (i = 0; successful && (i < capture_opts->ifaces->len); i++) {
2991                     interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
2992                     pcap_opts = g_array_index(global_ld.pcaps, pcap_options *, i);
2993                     successful = libpcap_write_interface_description_block(global_ld.pdh,
2994                                                                            interface_opts.name,
2995                                                                            interface_opts.cfilter?interface_opts.cfilter:"",
2996                                                                            pcap_opts->linktype,
2997                                                                            pcap_opts->snaplen,
2998                                                                            &(global_ld.bytes_written),
2999                                                                            &global_ld.err);
3000                 }
3001             } else {
3002                 pcap_opts = g_array_index(global_ld.pcaps, pcap_options *, 0);
3003                 successful = libpcap_write_file_header(global_ld.pdh, pcap_opts->linktype, pcap_opts->snaplen,
3004                                                        &global_ld.bytes_written, &global_ld.err);
3005             }
3006             if (!successful) {
3007                 fclose(global_ld.pdh);
3008                 global_ld.pdh = NULL;
3009                 global_ld.go = FALSE;
3010                 return FALSE;
3011             }
3012             if (cnd_autostop_size)
3013                 cnd_reset(cnd_autostop_size);
3014             if (cnd_file_duration)
3015                 cnd_reset(cnd_file_duration);
3016             libpcap_dump_flush(global_ld.pdh, NULL);
3017             if (!quiet)
3018                 report_packet_count(global_ld.inpkts_to_sync_pipe);
3019             global_ld.inpkts_to_sync_pipe = 0;
3020             report_new_capture_file(capture_opts->save_file);
3021         } else {
3022             /* File switch failed: stop here */
3023             global_ld.go = FALSE;
3024             return FALSE;
3025         }
3026     } else {
3027         /* single file, stop now */
3028         global_ld.go = FALSE;
3029         return FALSE;
3030     }
3031     return TRUE;
3032 }
3033
3034 static void *
3035 pcap_read_handler(void* arg)
3036 {
3037     pcap_options *pcap_opts;
3038     char errmsg[MSG_MAX_LENGTH+1];
3039
3040     pcap_opts = (pcap_options *)arg;
3041
3042     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Started thread for interface %d.",
3043           pcap_opts->interface_id);
3044
3045     while (global_ld.go) {
3046         /* dispatch incoming packets */
3047         capture_loop_dispatch(&global_ld, errmsg, sizeof(errmsg), pcap_opts);
3048     }
3049     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Stopped thread for interface %d.",
3050           pcap_opts->interface_id);
3051     g_thread_exit(NULL);
3052     return (NULL);
3053 }
3054
3055 /* Do the low-level work of a capture.
3056    Returns TRUE if it succeeds, FALSE otherwise. */
3057 static gboolean
3058 capture_loop_start(capture_options *capture_opts, gboolean *stats_known, struct pcap_stat *stats)
3059 {
3060 #ifdef WIN32
3061     DWORD upd_time, cur_time;   /* GetTickCount() returns a "DWORD" (which is 'unsigned long') */
3062 #else
3063     struct timeval upd_time, cur_time;
3064 #endif
3065     int         err_close;
3066     int         inpkts;
3067     condition  *cnd_file_duration = NULL;
3068     condition  *cnd_autostop_files = NULL;
3069     condition  *cnd_autostop_size = NULL;
3070     condition  *cnd_autostop_duration = NULL;
3071     gboolean    write_ok;
3072     gboolean    close_ok;
3073     gboolean    cfilter_error = FALSE;
3074     char        errmsg[MSG_MAX_LENGTH+1];
3075     char        secondary_errmsg[MSG_MAX_LENGTH+1];
3076     pcap_options *pcap_opts;
3077     interface_options interface_opts;
3078     guint i, error_index = 0;
3079
3080     *errmsg           = '\0';
3081     *secondary_errmsg = '\0';
3082
3083     /* init the loop data */
3084     global_ld.go                  = TRUE;
3085     global_ld.packet_count        = 0;
3086 #ifdef SIGINFO
3087     global_ld.report_packet_count = FALSE;
3088 #endif
3089     if (capture_opts->has_autostop_packets)
3090         global_ld.packet_max      = capture_opts->autostop_packets;
3091     else
3092         global_ld.packet_max      = 0;        /* no limit */
3093     global_ld.inpkts_to_sync_pipe = 0;
3094     global_ld.err                 = 0;  /* no error seen yet */
3095     global_ld.pdh                 = NULL;
3096     global_ld.autostop_files      = 0;
3097     global_ld.save_file_fd        = -1;
3098
3099     /* We haven't yet gotten the capture statistics. */
3100     *stats_known      = FALSE;
3101
3102     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Capture loop starting ...");
3103     capture_opts_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, capture_opts);
3104
3105     /* open the "input file" from network interface or capture pipe */
3106     if (!capture_loop_open_input(capture_opts, &global_ld, errmsg, sizeof(errmsg),
3107                                  secondary_errmsg, sizeof(secondary_errmsg))) {
3108         goto error;
3109     }
3110     for (i = 0; i < capture_opts->ifaces->len; i++) {
3111         pcap_opts = g_array_index(global_ld.pcaps, pcap_options *, i);
3112         interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
3113         /* init the input filter from the network interface (capture pipe will do nothing) */
3114         /*
3115          * When remote capturing WinPCap crashes when the capture filter
3116          * is NULL. This might be a bug in WPCap. Therefore we provide an emtpy
3117          * string.
3118          */
3119         switch (capture_loop_init_filter(pcap_opts->pcap_h, pcap_opts->from_cap_pipe,
3120                                          interface_opts.name,
3121                                          interface_opts.cfilter?interface_opts.cfilter:"")) {
3122
3123         case INITFILTER_NO_ERROR:
3124             break;
3125
3126         case INITFILTER_BAD_FILTER:
3127             cfilter_error = TRUE;
3128             error_index = i;
3129             g_snprintf(errmsg, sizeof(errmsg), "%s", pcap_geterr(pcap_opts->pcap_h));
3130             goto error;
3131
3132         case INITFILTER_OTHER_ERROR:
3133             g_snprintf(errmsg, sizeof(errmsg), "Can't install filter (%s).",
3134                        pcap_geterr(pcap_opts->pcap_h));
3135             g_snprintf(secondary_errmsg, sizeof(secondary_errmsg), "%s", please_report);
3136             goto error;
3137         }
3138     }
3139
3140     /* If we're supposed to write to a capture file, open it for output
3141        (temporary/specified name/ringbuffer) */
3142     if (capture_opts->saving_to_file) {
3143         if (!capture_loop_open_output(capture_opts, &global_ld.save_file_fd,
3144                                       errmsg, sizeof(errmsg))) {
3145             goto error;
3146         }
3147
3148         /* set up to write to the already-opened capture output file/files */
3149         if (!capture_loop_init_output(capture_opts, &global_ld, errmsg,
3150                                       sizeof(errmsg))) {
3151             goto error;
3152         }
3153
3154         /* XXX - capture SIGTERM and close the capture, in case we're on a
3155            Linux 2.0[.x] system and you have to explicitly close the capture
3156            stream in order to turn promiscuous mode off?  We need to do that
3157            in other places as well - and I don't think that works all the
3158            time in any case, due to libpcap bugs. */
3159
3160         /* Well, we should be able to start capturing.
3161
3162            Sync out the capture file, so the header makes it to the file system,
3163            and send a "capture started successfully and capture file created"
3164            message to our parent so that they'll open the capture file and
3165            update its windows to indicate that we have a live capture in
3166            progress. */
3167         libpcap_dump_flush(global_ld.pdh, NULL);
3168         report_new_capture_file(capture_opts->save_file);
3169     }
3170
3171     /* initialize capture stop (and alike) conditions */
3172     init_capture_stop_conditions();
3173     /* create stop conditions */
3174     if (capture_opts->has_autostop_filesize)
3175         cnd_autostop_size =
3176             cnd_new(CND_CLASS_CAPTURESIZE,(long)capture_opts->autostop_filesize * 1024);
3177     if (capture_opts->has_autostop_duration)
3178         cnd_autostop_duration =
3179             cnd_new(CND_CLASS_TIMEOUT,(gint32)capture_opts->autostop_duration);
3180
3181     if (capture_opts->multi_files_on) {
3182         if (capture_opts->has_file_duration)
3183             cnd_file_duration =
3184                 cnd_new(CND_CLASS_TIMEOUT, capture_opts->file_duration);
3185
3186         if (capture_opts->has_autostop_files)
3187             cnd_autostop_files =
3188                 cnd_new(CND_CLASS_CAPTURESIZE, capture_opts->autostop_files);
3189     }
3190
3191     /* init the time values */
3192 #ifdef WIN32
3193     upd_time = GetTickCount();
3194 #else
3195     gettimeofday(&upd_time, NULL);
3196 #endif
3197
3198     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Capture loop running!");
3199
3200     /* WOW, everything is prepared! */
3201     /* please fasten your seat belts, we will enter now the actual capture loop */
3202     if (use_threads) {
3203         pcap_queue = g_async_queue_new();
3204         pcap_queue_bytes = 0;
3205         pcap_queue_packets = 0;
3206         for (i = 0; i < global_ld.pcaps->len; i++) {
3207             pcap_opts = g_array_index(global_ld.pcaps, pcap_options *, i);
3208 #if GLIB_CHECK_VERSION(2,31,0)
3209             /* XXX - Add an interface name here? */
3210             pcap_opts->tid = g_thread_new("Capture read", pcap_read_handler, pcap_opts);
3211 #else
3212             pcap_opts->tid = g_thread_create(pcap_read_handler, pcap_opts, TRUE, NULL);
3213 #endif
3214         }
3215     }
3216     while (global_ld.go) {
3217         /* dispatch incoming packets */
3218         if (use_threads) {
3219             GTimeVal write_thread_time;
3220             pcap_queue_element *queue_element;
3221
3222             g_get_current_time(&write_thread_time);
3223             g_time_val_add(&write_thread_time, WRITER_THREAD_TIMEOUT);
3224             g_async_queue_lock(pcap_queue);
3225             queue_element = g_async_queue_timed_pop_unlocked(pcap_queue, &write_thread_time);
3226             if (queue_element) {
3227                 pcap_queue_bytes -= queue_element->phdr.caplen;
3228                 pcap_queue_packets -= 1;
3229             }
3230             g_async_queue_unlock(pcap_queue);
3231             if (queue_element) {
3232                 g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
3233                       "Dequeued a packet of length %d captured on interface %d.",
3234                       queue_element->phdr.caplen, queue_element->pcap_opts->interface_id);
3235
3236                 capture_loop_write_packet_cb((u_char *) queue_element->pcap_opts,
3237                                              &queue_element->phdr,
3238                                              queue_element->pd);
3239                 g_free(queue_element->pd);
3240                 g_free(queue_element);
3241                 inpkts = 1;
3242             } else {
3243                 inpkts = 0;
3244             }
3245         } else {
3246             pcap_opts = g_array_index(global_ld.pcaps, pcap_options *, 0);
3247             inpkts = capture_loop_dispatch(&global_ld, errmsg,
3248                                            sizeof(errmsg), pcap_opts);
3249         }
3250 #ifdef SIGINFO
3251         /* Were we asked to print packet counts by the SIGINFO handler? */
3252         if (global_ld.report_packet_count) {
3253             fprintf(stderr, "%u packet%s captured\n", global_ld.packet_count,
3254                     plurality(global_ld.packet_count, "", "s"));
3255             global_ld.report_packet_count = FALSE;
3256         }
3257 #endif
3258
3259 #ifdef _WIN32
3260         /* any news from our parent (signal pipe)? -> just stop the capture */
3261         if (!signal_pipe_check_running()) {
3262             global_ld.go = FALSE;
3263         }
3264 #endif
3265
3266         if (inpkts > 0) {
3267             global_ld.inpkts_to_sync_pipe += inpkts;
3268
3269             /* check capture size condition */
3270             if (cnd_autostop_size != NULL &&
3271                 cnd_eval(cnd_autostop_size, (guint32)global_ld.bytes_written)) {
3272                 /* Capture size limit reached, do we have another file? */
3273                 if (!do_file_switch_or_stop(capture_opts, cnd_autostop_files,
3274                                             cnd_autostop_size, cnd_file_duration))
3275                     continue;
3276             } /* cnd_autostop_size */
3277             if (capture_opts->output_to_pipe) {
3278                 libpcap_dump_flush(global_ld.pdh, NULL);
3279             }
3280         } /* inpkts */
3281
3282         /* Only update once every 500ms so as not to overload slow displays.
3283          * This also prevents too much context-switching between the dumpcap
3284          * and wireshark processes.
3285          */
3286 #define DUMPCAP_UPD_TIME 500
3287
3288 #ifdef WIN32
3289         cur_time = GetTickCount();  /* Note: wraps to 0 if sys runs for 49.7 days */
3290         if ((cur_time - upd_time) > DUMPCAP_UPD_TIME) { /* wrap just causes an extra update */
3291 #else
3292         gettimeofday(&cur_time, NULL);
3293         if ((cur_time.tv_sec * 1000000 + cur_time.tv_usec) >
3294             (upd_time.tv_sec * 1000000 + upd_time.tv_usec + DUMPCAP_UPD_TIME*1000)) {
3295 #endif
3296
3297             upd_time = cur_time;
3298
3299 #if 0
3300             if (pcap_stats(pch, stats) >= 0) {
3301                 *stats_known = TRUE;
3302             }
3303 #endif
3304             /* Let the parent process know. */
3305             if (global_ld.inpkts_to_sync_pipe) {
3306                 /* do sync here */
3307                 libpcap_dump_flush(global_ld.pdh, NULL);
3308
3309                 /* Send our parent a message saying we've written out
3310                    "global_ld.inpkts_to_sync_pipe" packets to the capture file. */
3311                 if (!quiet)
3312                     report_packet_count(global_ld.inpkts_to_sync_pipe);
3313
3314                 global_ld.inpkts_to_sync_pipe = 0;
3315             }
3316
3317             /* check capture duration condition */
3318             if (cnd_autostop_duration != NULL && cnd_eval(cnd_autostop_duration)) {
3319                 /* The maximum capture time has elapsed; stop the capture. */
3320                 global_ld.go = FALSE;
3321                 continue;
3322             }
3323
3324             /* check capture file duration condition */
3325             if (cnd_file_duration != NULL && cnd_eval(cnd_file_duration)) {
3326                 /* duration limit reached, do we have another file? */
3327                 if (!do_file_switch_or_stop(capture_opts, cnd_autostop_files,
3328                                             cnd_autostop_size, cnd_file_duration))
3329                     continue;
3330             } /* cnd_file_duration */
3331         }
3332     }
3333
3334     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Capture loop stopping ...");
3335     if (use_threads) {
3336         pcap_queue_element *queue_element;
3337
3338         for (i = 0; i < global_ld.pcaps->len; i++) {
3339             pcap_opts = g_array_index(global_ld.pcaps, pcap_options *, i);
3340             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Waiting for thread of interface %u...",
3341                   pcap_opts->interface_id);
3342             g_thread_join(pcap_opts->tid);
3343             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Thread of interface %u terminated.",
3344                   pcap_opts->interface_id);
3345         }
3346         while (1) {
3347             g_async_queue_lock(pcap_queue);
3348             queue_element = g_async_queue_try_pop_unlocked(pcap_queue);
3349             if (queue_element) {
3350                 pcap_queue_bytes -= queue_element->phdr.caplen;
3351                 pcap_queue_packets -= 1;
3352             }
3353             g_async_queue_unlock(pcap_queue);
3354             if (queue_element == NULL) {
3355                 break;
3356             }
3357             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
3358                   "Dequeued a packet of length %d captured on interface %d.",
3359                   queue_element->phdr.caplen, queue_element->pcap_opts->interface_id);
3360             capture_loop_write_packet_cb((u_char *)queue_element->pcap_opts,
3361                                          &queue_element->phdr,
3362                                          queue_element->pd);
3363             g_free(queue_element->pd);
3364             g_free(queue_element);
3365             global_ld.inpkts_to_sync_pipe += 1;
3366             if (capture_opts->output_to_pipe) {
3367                 libpcap_dump_flush(global_ld.pdh, NULL);
3368             }
3369         }
3370     }
3371
3372
3373     /* delete stop conditions */
3374     if (cnd_file_duration != NULL)
3375         cnd_delete(cnd_file_duration);
3376     if (cnd_autostop_files != NULL)
3377         cnd_delete(cnd_autostop_files);
3378     if (cnd_autostop_size != NULL)
3379         cnd_delete(cnd_autostop_size);
3380     if (cnd_autostop_duration != NULL)
3381         cnd_delete(cnd_autostop_duration);
3382
3383     /* did we have a pcap (input) error? */
3384     for (i = 0; i < capture_opts->ifaces->len; i++) {
3385         pcap_opts = g_array_index(global_ld.pcaps, pcap_options *, i);
3386         if (pcap_opts->pcap_err) {
3387             /* On Linux, if an interface goes down while you're capturing on it,
3388                you'll get a "recvfrom: Network is down" or
3389                "The interface went down" error (ENETDOWN).
3390                (At least you will if g_strerror() doesn't show a local translation
3391                of the error.)
3392
3393                On FreeBSD and OS X, if a network adapter disappears while
3394                you're capturing on it, you'll get a "read: Device not configured"
3395                error (ENXIO).  (See previous parenthetical note.)
3396
3397                On OpenBSD, you get "read: I/O error" (EIO) in the same case.
3398
3399                These should *not* be reported to the Wireshark developers. */
3400             char *cap_err_str;
3401
3402             cap_err_str = pcap_geterr(pcap_opts->pcap_h);
3403             if (strcmp(cap_err_str, "recvfrom: Network is down") == 0 ||
3404                 strcmp(cap_err_str, "The interface went down") == 0 ||
3405                 strcmp(cap_err_str, "read: Device not configured") == 0 ||
3406                 strcmp(cap_err_str, "read: I/O error") == 0 ||
3407                 strcmp(cap_err_str, "read error: PacketReceivePacket failed") == 0) {
3408                 report_capture_error("The network adapter on which the capture was being done "
3409                                      "is no longer running; the capture has stopped.",
3410                                      "");
3411             } else {
3412                 g_snprintf(errmsg, sizeof(errmsg), "Error while capturing packets: %s",
3413                            cap_err_str);
3414                 report_capture_error(errmsg, please_report);
3415             }
3416             break;
3417         } else if (pcap_opts->from_cap_pipe && pcap_opts->cap_pipe_err == PIPERR) {
3418             report_capture_error(errmsg, "");
3419             break;
3420         }
3421     }
3422     /* did we have an output error while capturing? */
3423     if (global_ld.err == 0) {
3424         write_ok = TRUE;
3425     } else {
3426         capture_loop_get_errmsg(errmsg, sizeof(errmsg), capture_opts->save_file,
3427                                 global_ld.err, FALSE);
3428         report_capture_error(errmsg, please_report);
3429         write_ok = FALSE;
3430     }
3431
3432     if (capture_opts->saving_to_file) {
3433         /* close the output file */
3434         close_ok = capture_loop_close_output(capture_opts, &global_ld, &err_close);
3435     } else
3436         close_ok = TRUE;
3437
3438     /* there might be packets not yet notified to the parent */
3439     /* (do this after closing the file, so all packets are already flushed) */
3440     if(global_ld.inpkts_to_sync_pipe) {
3441         if (!quiet)
3442             report_packet_count(global_ld.inpkts_to_sync_pipe);
3443         global_ld.inpkts_to_sync_pipe = 0;
3444     }
3445
3446     /* If we've displayed a message about a write error, there's no point
3447        in displaying another message about an error on close. */
3448     if (!close_ok && write_ok) {
3449         capture_loop_get_errmsg(errmsg, sizeof(errmsg), capture_opts->save_file, err_close,
3450                                 TRUE);
3451         report_capture_error(errmsg, "");
3452     }
3453
3454     /*
3455      * XXX We exhibit different behaviour between normal mode and sync mode
3456      * when the pipe is stdin and not already at EOF.  If we're a child, the
3457      * parent's stdin isn't closed, so if the user starts another capture,
3458      * cap_pipe_open_live() will very likely not see the expected magic bytes and
3459      * will say "Unrecognized libpcap format".  On the other hand, in normal
3460      * mode, cap_pipe_open_live() will say "End of file on pipe during open".
3461      */
3462
3463     report_capture_count(TRUE);
3464
3465     /* get packet drop statistics from pcap */
3466     for (i = 0; i < capture_opts->ifaces->len; i++) {
3467         guint32 received;
3468         guint32 dropped;
3469
3470         pcap_opts = g_array_index(global_ld.pcaps, pcap_options *, i);
3471         interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
3472         received = pcap_opts->received;
3473         dropped = pcap_opts->dropped;
3474         if (pcap_opts->pcap_h != NULL) {
3475             g_assert(!pcap_opts->from_cap_pipe);
3476             /* Get the capture statistics, so we know how many packets were dropped. */
3477             if (pcap_stats(pcap_opts->pcap_h, stats) >= 0) {
3478                 *stats_known = TRUE;
3479                 /* Let the parent process know. */
3480                 dropped += stats->ps_drop;
3481             } else {
3482                 g_snprintf(errmsg, sizeof(errmsg),
3483                            "Can't get packet-drop statistics: %s",
3484                            pcap_geterr(pcap_opts->pcap_h));
3485                 report_capture_error(errmsg, please_report);
3486             }
3487         }
3488         report_packet_drops(received, dropped, interface_opts.name);
3489     }
3490
3491     /* close the input file (pcap or capture pipe) */
3492     capture_loop_close_input(&global_ld);
3493
3494     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Capture loop stopped!");
3495
3496     /* ok, if the write and the close were successful. */
3497     return write_ok && close_ok;
3498
3499 error:
3500     if (capture_opts->multi_files_on) {
3501         /* cleanup ringbuffer */
3502         ringbuf_error_cleanup();
3503     } else {
3504         /* We can't use the save file, and we have no FILE * for the stream
3505            to close in order to close it, so close the FD directly. */
3506         if (global_ld.save_file_fd != -1) {
3507             ws_close(global_ld.save_file_fd);
3508         }
3509
3510         /* We couldn't even start the capture, so get rid of the capture
3511            file. */
3512         if (capture_opts->save_file != NULL) {
3513             ws_unlink(capture_opts->save_file);
3514             g_free(capture_opts->save_file);
3515         }
3516     }
3517     capture_opts->save_file = NULL;
3518     if (cfilter_error)
3519         report_cfilter_error(capture_opts, error_index, errmsg);
3520     else
3521         report_capture_error(errmsg, secondary_errmsg);
3522
3523     /* close the input file (pcap or cap_pipe) */
3524     capture_loop_close_input(&global_ld);
3525
3526     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Capture loop stopped with error");
3527
3528     return FALSE;
3529 }
3530
3531
3532 static void capture_loop_stop(void)
3533 {
3534 #ifdef HAVE_PCAP_BREAKLOOP
3535     guint i;
3536     pcap_options *pcap_opts;
3537
3538     for (i = 0; i < global_ld.pcaps->len; i++) {
3539         pcap_opts = g_array_index(global_ld.pcaps, pcap_options *, i);
3540         if (pcap_opts->pcap_h != NULL)
3541             pcap_breakloop(pcap_opts->pcap_h);
3542     }
3543 #endif
3544     global_ld.go = FALSE;
3545 }
3546
3547
3548 static void
3549 capture_loop_get_errmsg(char *errmsg, int errmsglen, const char *fname,
3550                         int err, gboolean is_close)
3551 {
3552     switch (err) {
3553
3554     case ENOSPC:
3555         g_snprintf(errmsg, errmsglen,
3556                    "Not all the packets could be written to the file"
3557                    " to which the capture was being saved\n"
3558                    "(\"%s\") because there is no space left on the file system\n"
3559                    "on which that file resides.",
3560                    fname);
3561         break;
3562
3563 #ifdef EDQUOT
3564     case EDQUOT:
3565         g_snprintf(errmsg, errmsglen,
3566                    "Not all the packets could be written to the file"
3567                    " to which the capture was being saved\n"
3568                    "(\"%s\") because you are too close to, or over,"
3569                    " your disk quota\n"
3570                    "on the file system on which that file resides.",
3571                    fname);
3572         break;
3573 #endif
3574
3575     default:
3576         if (is_close) {
3577             g_snprintf(errmsg, errmsglen,
3578                        "The file to which the capture was being saved\n"
3579                        "(\"%s\") could not be closed: %s.",
3580                        fname, g_strerror(err));
3581         } else {
3582             g_snprintf(errmsg, errmsglen,
3583                        "An error occurred while writing to the file"
3584                        " to which the capture was being saved\n"
3585                        "(\"%s\"): %s.",
3586                        fname, g_strerror(err));
3587         }
3588         break;
3589     }
3590 }
3591
3592
3593 /* one packet was captured, process it */
3594 static void
3595 capture_loop_write_packet_cb(u_char *pcap_opts_p, const struct pcap_pkthdr *phdr,
3596                              const u_char *pd)
3597 {
3598     pcap_options *pcap_opts = (pcap_options *) (void *) pcap_opts_p;
3599     int err;
3600
3601     /* We may be called multiple times from pcap_dispatch(); if we've set
3602        the "stop capturing" flag, ignore this packet, as we're not
3603        supposed to be saving any more packets. */
3604     if (!global_ld.go)
3605         return;
3606
3607     if (global_ld.pdh) {
3608         gboolean successful;
3609
3610         /* We're supposed to write the packet to a file; do so.
3611            If this fails, set "ld->go" to FALSE, to stop the capture, and set
3612            "ld->err" to the error. */
3613         if (global_capture_opts.use_pcapng) {
3614             successful = libpcap_write_enhanced_packet_block(global_ld.pdh, phdr, pcap_opts->interface_id, pd, &global_ld.bytes_written, &err);
3615         } else {
3616             successful = libpcap_write_packet(global_ld.pdh, phdr, pd, &global_ld.bytes_written, &err);
3617         }
3618         if (!successful) {
3619             global_ld.go = FALSE;
3620             global_ld.err = err;
3621         } else {
3622             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
3623                   "Wrote a packet of length %d captured on interface %u.",
3624                    phdr->caplen, pcap_opts->interface_id);
3625             global_ld.packet_count++;
3626             pcap_opts->received++;
3627             /* if the user told us to stop after x packets, do we already have enough? */
3628             if ((global_ld.packet_max > 0) && (global_ld.packet_count >= global_ld.packet_max)) {
3629                 global_ld.go = FALSE;
3630             }
3631         }
3632     }
3633 }
3634
3635 /* one packet was captured, queue it */
3636 static void
3637 capture_loop_queue_packet_cb(u_char *pcap_opts_p, const struct pcap_pkthdr *phdr,
3638                              const u_char *pd)
3639 {
3640     pcap_options *pcap_opts = (pcap_options *) (void *) pcap_opts_p;
3641     pcap_queue_element *queue_element;
3642     gboolean limit_reached;
3643
3644     /* We may be called multiple times from pcap_dispatch(); if we've set
3645        the "stop capturing" flag, ignore this packet, as we're not
3646        supposed to be saving any more packets. */
3647     if (!global_ld.go)
3648         return;
3649
3650     queue_element = (pcap_queue_element *)g_malloc(sizeof(pcap_queue_element));
3651     if (queue_element == NULL) {
3652        pcap_opts->dropped++;
3653        return;
3654     }
3655     queue_element->pcap_opts = pcap_opts;
3656     queue_element->phdr = *phdr;
3657     queue_element->pd = (u_char *)g_malloc(phdr->caplen);
3658     if (queue_element->pd == NULL) {
3659         pcap_opts->dropped++;
3660         g_free(queue_element);
3661         return;
3662     }
3663     memcpy(queue_element->pd, pd, phdr->caplen);
3664     g_async_queue_lock(pcap_queue);
3665     if (((pcap_queue_byte_limit > 0) && (pcap_queue_bytes < pcap_queue_byte_limit)) &&
3666         ((pcap_queue_packet_limit > 0) && (pcap_queue_packets < pcap_queue_packet_limit))) {
3667         limit_reached = FALSE;
3668         g_async_queue_push_unlocked(pcap_queue, queue_element);
3669         pcap_queue_bytes += phdr->caplen;
3670         pcap_queue_packets += 1;
3671     } else {
3672         limit_reached = TRUE;
3673     }
3674     g_async_queue_unlock(pcap_queue);
3675     if (limit_reached) {
3676         pcap_opts->dropped++;
3677         g_free(queue_element->pd);
3678         g_free(queue_element);
3679         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
3680               "Dropped a packet of length %d captured on interface %u.",
3681               phdr->caplen, pcap_opts->interface_id);
3682     } else {
3683         pcap_opts->received++;
3684         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
3685               "Queued a packet of length %d captured on interface %u.",
3686               phdr->caplen, pcap_opts->interface_id);
3687     }
3688     /* I don't want to hold the mutex over the debug output. So the
3689        output may be wrong */
3690     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
3691           "Queue size is now %" G_GINT64_MODIFIER "d bytes (%" G_GINT64_MODIFIER "d packets)",
3692           pcap_queue_bytes, pcap_queue_packets);
3693 }
3694
3695 /* And now our feature presentation... [ fade to music ] */
3696 int
3697 main(int argc, char *argv[])
3698 {
3699     int                  opt;
3700     gboolean             arg_error = FALSE;
3701
3702 #ifdef _WIN32
3703     WSADATA              wsaData;
3704 #else
3705     struct sigaction action, oldaction;
3706 #endif
3707
3708     gboolean             start_capture = TRUE;
3709     gboolean             stats_known;
3710     struct pcap_stat     stats;
3711     GLogLevelFlags       log_flags;
3712     gboolean             list_interfaces = FALSE;
3713     gboolean             list_link_layer_types = FALSE;
3714 #ifdef HAVE_BPF_IMAGE
3715     gboolean             print_bpf_code = FALSE;
3716 #endif
3717     gboolean             machine_readable = FALSE;
3718     gboolean             print_statistics = FALSE;
3719     int                  status, run_once_args = 0;
3720     gint                 i;
3721     guint                j;
3722 #if defined(__APPLE__) && defined(__LP64__)
3723     struct utsname       osinfo;
3724 #endif
3725     GString             *str;
3726
3727 #ifdef _WIN32
3728     arg_list_utf_16to8(argc, argv);
3729 #endif /* _WIN32 */
3730
3731 #ifdef _WIN32
3732     /*
3733      * Initialize our DLL search path. MUST be called before LoadLibrary
3734      * or g_module_open.
3735      */
3736     ws_init_dll_search_path();
3737 #endif
3738
3739 #ifdef HAVE_PCAP_REMOTE
3740 #define OPTSTRING_A "A:"
3741 #define OPTSTRING_r "r"
3742 #define OPTSTRING_u "u"
3743 #else
3744 #define OPTSTRING_A ""
3745 #define OPTSTRING_r ""
3746 #define OPTSTRING_u ""
3747 #endif
3748
3749 #ifdef HAVE_PCAP_SETSAMPLING
3750 #define OPTSTRING_m "m:"
3751 #else
3752 #define OPTSTRING_m ""
3753 #endif
3754
3755 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
3756 #define OPTSTRING_B "B:"
3757 #else
3758 #define OPTSTRING_B ""
3759 #endif  /* _WIN32 or HAVE_PCAP_CREATE */
3760
3761 #ifdef HAVE_PCAP_CREATE
3762 #define OPTSTRING_I "I"
3763 #else
3764 #define OPTSTRING_I ""
3765 #endif
3766
3767 #ifdef HAVE_BPF_IMAGE
3768 #define OPTSTRING_d "d"
3769 #else
3770 #define OPTSTRING_d ""
3771 #endif
3772
3773 #define OPTSTRING "a:" OPTSTRING_A "b:" OPTSTRING_B "c:" OPTSTRING_d "Df:ghi:" OPTSTRING_I "L" OPTSTRING_m "MnpPq" OPTSTRING_r "Ss:t" OPTSTRING_u "vw:y:Z:"
3774
3775 #ifdef DEBUG_CHILD_DUMPCAP
3776     if ((debug_log = ws_fopen("dumpcap_debug_log.tmp","w")) == NULL) {
3777         fprintf (stderr, "Unable to open debug log file !\n");
3778         exit (1);
3779     }
3780 #endif
3781
3782 #if defined(__APPLE__) && defined(__LP64__)
3783     /*
3784      * Is this Mac OS X 10.6.0, 10.6.1, 10.6.3, or 10.6.4?  If so, we need
3785      * a bug workaround - timeouts less than 1 second don't work with libpcap
3786      * in 64-bit code.  (The bug was introduced in 10.6, fixed in 10.6.2,
3787      * re-introduced in 10.6.3, not fixed in 10.6.4, and fixed in 10.6.5.
3788      * The problem is extremely unlikely to be reintroduced in a future
3789      * release.)
3790      */
3791     if (uname(&osinfo) == 0) {
3792         /*
3793          * Mac OS X 10.x uses Darwin {x+4}.0.0.  Mac OS X 10.x.y uses Darwin
3794          * {x+4}.y.0 (except that 10.6.1 appears to have a uname version
3795          * number of 10.0.0, not 10.1.0 - go figure).
3796          */
3797         if (strcmp(osinfo.release, "10.0.0") == 0 ||    /* 10.6, 10.6.1 */
3798             strcmp(osinfo.release, "10.3.0") == 0 ||    /* 10.6.3 */
3799             strcmp(osinfo.release, "10.4.0") == 0)              /* 10.6.4 */
3800             need_timeout_workaround = TRUE;
3801     }
3802 #endif
3803
3804     /*
3805      * Determine if dumpcap is being requested to run in a special
3806      * capture_child mode by going thru the command line args to see if
3807      * a -Z is present. (-Z is a hidden option).
3808      *
3809      * The primary result of running in capture_child mode is that
3810      * all messages sent out on stderr are in a special type/len/string
3811      * format to allow message processing by type.  These messages include
3812      * error messages if dumpcap fails to start the operation it was
3813      * requested to do, as well as various "status" messages which are sent
3814      * when an actual capture is in progress, and a "success" message sent
3815      * if dumpcap was requested to perform an operation other than a
3816      * capture.
3817      *
3818      * Capture_child mode would normally be requested by a parent process
3819      * which invokes dumpcap and obtains dumpcap stderr output via a pipe
3820      * to which dumpcap stderr has been redirected.  It might also have
3821      * another pipe to obtain dumpcap stdout output; for operations other
3822      * than a capture, that information is formatted specially for easier
3823      * parsing by the parent process.
3824      *
3825      * Capture_child mode needs to be determined immediately upon
3826      * startup so that any messages generated by dumpcap in this mode
3827      * (eg: during initialization) will be formatted properly.
3828      */
3829
3830     for (i=1; i<argc; i++) {
3831         if (strcmp("-Z", argv[i]) == 0) {
3832             capture_child = TRUE;
3833             machine_readable = TRUE;  /* request machine-readable output */
3834 #ifdef _WIN32
3835             /* set output pipe to binary mode, to avoid ugly text conversions */
3836             _setmode(2, O_BINARY);
3837 #endif
3838         }
3839     }
3840
3841     /* The default_log_handler will use stdout, which makes trouble in   */
3842     /* capture child mode, as it uses stdout for it's sync_pipe.         */
3843     /* So: the filtering is done in the console_log_handler and not here.*/
3844     /* We set the log handlers right up front to make sure that any log  */
3845     /* messages when running as child will be sent back to the parent    */
3846     /* with the correct format.                                          */
3847
3848     log_flags =
3849         G_LOG_LEVEL_ERROR|
3850         G_LOG_LEVEL_CRITICAL|
3851         G_LOG_LEVEL_WARNING|
3852         G_LOG_LEVEL_MESSAGE|
3853         G_LOG_LEVEL_INFO|
3854         G_LOG_LEVEL_DEBUG|
3855         G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION;
3856
3857     g_log_set_handler(NULL,
3858                       log_flags,
3859                       console_log_handler, NULL /* user_data */);
3860     g_log_set_handler(LOG_DOMAIN_MAIN,
3861                       log_flags,
3862                       console_log_handler, NULL /* user_data */);
3863     g_log_set_handler(LOG_DOMAIN_CAPTURE,
3864                       log_flags,
3865                       console_log_handler, NULL /* user_data */);
3866     g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
3867                       log_flags,
3868                       console_log_handler, NULL /* user_data */);
3869
3870     /* Initialize the pcaps list */
3871     global_ld.pcaps = g_array_new(FALSE, FALSE, sizeof(pcap_options *));
3872
3873 #if !GLIB_CHECK_VERSION(2,31,0)
3874     /* Initialize the thread system */
3875     g_thread_init(NULL);
3876 #endif
3877
3878 #ifdef _WIN32
3879     /* Load wpcap if possible. Do this before collecting the run-time version information */
3880     load_wpcap();
3881
3882     /* ... and also load the packet.dll from wpcap */
3883     /* XXX - currently not required, may change later. */
3884     /*wpcap_packet_load();*/
3885
3886     /* Start windows sockets */
3887     WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
3888
3889     /* Set handler for Ctrl+C key */
3890     SetConsoleCtrlHandler(capture_cleanup_handler, TRUE);
3891 #else
3892     /* Catch SIGINT and SIGTERM and, if we get either of them, clean up
3893        and exit. */
3894     action.sa_handler = capture_cleanup_handler;
3895     /*
3896      * Arrange that system calls not get restarted, because when
3897      * our signal handler returns we don't want to restart
3898      * a call that was waiting for packets to arrive.
3899      */
3900     action.sa_flags = 0;
3901     sigemptyset(&action.sa_mask);
3902     sigaction(SIGTERM, &action, NULL);
3903     sigaction(SIGINT, &action, NULL);
3904     sigaction(SIGPIPE, &action, NULL);
3905     sigaction(SIGHUP, NULL, &oldaction);
3906     if (oldaction.sa_handler == SIG_DFL)
3907         sigaction(SIGHUP, &action, NULL);
3908
3909 #ifdef SIGINFO
3910     /* Catch SIGINFO and, if we get it and we're capturing in
3911        quiet mode, report the number of packets we've captured. */
3912     action.sa_handler = report_counts_siginfo;
3913     action.sa_flags = SA_RESTART;
3914     sigemptyset(&action.sa_mask);
3915     sigaction(SIGINFO, &action, NULL);
3916 #endif /* SIGINFO */
3917 #endif  /* _WIN32 */
3918
3919     /* ----------------------------------------------------------------- */
3920     /* Privilege and capability handling                                 */
3921     /* Cases:                                                            */
3922     /* 1. Running not as root or suid root; no special capabilities.     */
3923     /*    Action: none                                                   */
3924     /*                                                                   */