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