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