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