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