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