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