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