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