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