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