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