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