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