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