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