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