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