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