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