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