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