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