split some parts of the packet counting functions into their own files capture_info...
[metze/wireshark/wip.git] / capture_loop.c
1 /* capture_loop.c
2  * The actual capturing loop, getting packets and storing it
3  *
4  * $Id$
5  *
6  * Ethereal - Network traffic analyzer
7  * By Gerald Combs <gerald@ethereal.com>
8  * Copyright 1998 Gerald Combs
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23  */
24
25
26 /** @file
27  *  
28  * Capture loop (internal interface).
29  *
30  * It will open the input and output files, capture the packets, 
31  * change ringbuffer output files while capturing and close all files again.
32  * 
33  * The input file can be a network interface or capture pipe (unix only).
34  * The output file can be a single or a ringbuffer file handled by wiretap.
35  *
36  */
37
38 #ifdef HAVE_CONFIG_H
39 # include "config.h"
40 #endif
41
42 #ifdef HAVE_LIBPCAP
43
44 #include <string.h>
45
46 #ifdef HAVE_FCNTL_H
47 #include <fcntl.h>
48 #endif
49
50 #ifdef HAVE_UNISTD_H
51 #include <unistd.h>
52 #endif
53
54 #ifdef HAVE_SYS_TYPES_H
55 # include <sys/types.h>
56 #endif
57
58 #ifdef HAVE_SYS_STAT_H
59 # include <sys/stat.h>
60 #endif
61
62 #include <signal.h>
63 #include <errno.h>
64
65 #include <pcap.h>
66
67 #include <glib.h>
68
69 #include <epan/packet.h>
70 #include "capture.h"
71 #include "capture_loop.h"
72 #include "capture_info.h"
73 #include "capture_sync.h"
74 #include "pcap-util.h"
75
76 #include "simple_dialog.h"
77 #include "conditions.h"
78 #include "capture_stop_conditions.h"
79 #include "ringbuffer.h"
80
81 #include "wiretap/libpcap.h"
82 #include "wiretap/wtap.h"
83 #include "wiretap/wtap-capture.h"
84
85 /* XXX - try to remove this later */
86 #include <epan/prefs.h>
87 #include "ui_util.h"
88 /* XXX - try to remove this later */
89 #include "util.h"
90 #include "alert_box.h"
91 #include "log.h"
92 #include "file_util.h"
93
94
95
96
97 /*
98  * We don't want to do a "select()" on the pcap_t's file descriptor on
99  * BSD (because "select()" doesn't work correctly on BPF devices on at
100  * least some releases of some flavors of BSD), and we don't want to do
101  * it on Windows (because "select()" is something for sockets, not for
102  * arbitrary handles).  (Note that "Windows" here includes Cygwin;
103  * even in its pretend-it's-UNIX environment, we're using WinPcap, not
104  * a UNIX libpcap.)
105  *
106  * We *do* want to do it on other platforms, as, on other platforms (with
107  * the possible exception of Ultrix and Digital UNIX), the read timeout
108  * doesn't expire if no packets have arrived, so a "pcap_dispatch()" call
109  * will block until packets arrive, causing the UI to hang.
110  *
111  * XXX - the various BSDs appear to define BSD in <sys/param.h>; we don't
112  * want to include it if it's not present on this platform, however.
113  */
114 #if !defined(__FreeBSD__) && !defined(__NetBSD__) && !defined(__OpenBSD__) && \
115     !defined(__bsdi__) && !defined(__APPLE__) && !defined(_WIN32) && \
116     !defined(__CYGWIN__)
117 # define MUST_DO_SELECT
118 #endif
119
120
121 typedef struct _loop_data {
122   /* common */
123   gboolean       go;                    /* TRUE as long as we're supposed to keep capturing */
124   int            err;                   /* if non-zero, error seen while capturing */
125   gint           packets_curr;          /* Number of packets we have already captured */
126   gint           packets_max;           /* Number of packets we're supposed to capture - 0 means infinite */
127   gint           packets_sync_pipe;     /* packets not already send out to the sync_pipe */
128   packet_counts  counts;                /* several packet type counters */
129   gboolean       show_info;             /* show(hide) capture info dialog */
130
131   /* pcap "input file" */
132   pcap_t        *pcap_h;                /* pcap handle */
133   gboolean       pcap_err;              /* TRUE if error from pcap */
134 #ifdef MUST_DO_SELECT
135   int            pcap_fd;               /* pcap file descriptor */
136 #endif
137
138   /* capture pipe (unix only "input file") */
139   gboolean       from_cap_pipe;         /* TRUE if we are capturing data from a capture pipe */
140 #ifndef _WIN32
141   struct pcap_hdr cap_pipe_hdr;
142   struct pcaprec_modified_hdr cap_pipe_rechdr;
143   int            cap_pipe_fd;           /* the file descriptor of the capture pipe */
144   gboolean       cap_pipe_modified;     /* TRUE if data in the pipe uses modified pcap headers */
145   gboolean       cap_pipe_byte_swapped; /* TRUE if data in the pipe is byte swapped */
146   unsigned int   cap_pipe_bytes_to_read;/* Used by cap_pipe_dispatch */
147   unsigned int   cap_pipe_bytes_read;   /* Used by cap_pipe_dispatch */
148   enum {
149          STATE_EXPECT_REC_HDR,
150          STATE_READ_REC_HDR,
151          STATE_EXPECT_DATA,
152          STATE_READ_DATA
153        } cap_pipe_state;
154
155   enum { PIPOK, PIPEOF, PIPERR, PIPNEXIST } cap_pipe_err;
156 #endif
157
158   /* wiretap (output file) */
159   wtap_dumper   *wtap_pdh;
160   gint           wtap_linktype;
161
162 } loop_data;
163
164
165 /*
166  * Timeout, in milliseconds, for reads from the stream of captured packets.
167  */
168 #define CAP_READ_TIMEOUT        250
169
170 static void capture_loop_packet_cb(u_char *user, const struct pcap_pkthdr *phdr,
171   const u_char *pd);
172 static void capture_loop_get_errmsg(char *errmsg, int errmsglen, const char *fname,
173                           int err, gboolean is_close);
174
175
176
177 #ifndef _WIN32
178 /* Take care of byte order in the libpcap headers read from pipes.
179  * (function taken from wiretap/libpcap.c) */
180 static void
181 cap_pipe_adjust_header(loop_data *ld, struct pcap_hdr *hdr, struct pcaprec_hdr *rechdr)
182 {
183   if (ld->cap_pipe_byte_swapped) {
184     /* Byte-swap the record header fields. */
185     rechdr->ts_sec = BSWAP32(rechdr->ts_sec);
186     rechdr->ts_usec = BSWAP32(rechdr->ts_usec);
187     rechdr->incl_len = BSWAP32(rechdr->incl_len);
188     rechdr->orig_len = BSWAP32(rechdr->orig_len);
189   }
190
191   /* In file format version 2.3, the "incl_len" and "orig_len" fields were
192      swapped, in order to match the BPF header layout.
193
194      Unfortunately, some files were, according to a comment in the "libpcap"
195      source, written with version 2.3 in their headers but without the
196      interchanged fields, so if "incl_len" is greater than "orig_len" - which
197      would make no sense - we assume that we need to swap them.  */
198   if (hdr->version_major == 2 &&
199       (hdr->version_minor < 3 ||
200        (hdr->version_minor == 3 && rechdr->incl_len > rechdr->orig_len))) {
201     guint32 temp;
202
203     temp = rechdr->orig_len;
204     rechdr->orig_len = rechdr->incl_len;
205     rechdr->incl_len = temp;
206   }
207 }
208
209 /* Mimic pcap_open_live() for pipe captures
210  * We check if "pipename" is "-" (stdin) or a FIFO, open it, and read the
211  * header.
212  * N.B. : we can't read the libpcap formats used in RedHat 6.1 or SuSE 6.3
213  * because we can't seek on pipes (see wiretap/libpcap.c for details) */
214 static int
215 cap_pipe_open_live(char *pipename, struct pcap_hdr *hdr, loop_data *ld,
216                  char *errmsg, int errmsgl)
217 {
218   struct stat pipe_stat;
219   int         fd;
220   guint32     magic;
221   int         b, sel_ret;
222   unsigned int bytes_read;
223   fd_set      rfds;
224   struct timeval timeout;
225
226
227   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "cap_pipe_open_live: %s", pipename);
228
229   /*
230    * XXX Ethereal blocks until we return
231    */
232   if (strcmp(pipename, "-") == 0)
233     fd = 0; /* read from stdin */
234   else {
235     if (eth_stat(pipename, &pipe_stat) < 0) {
236       if (errno == ENOENT || errno == ENOTDIR)
237         ld->cap_pipe_err = PIPNEXIST;
238       else {
239         g_snprintf(errmsg, errmsgl,
240           "The capture session could not be initiated "
241           "due to error on pipe: %s", strerror(errno));
242         ld->cap_pipe_err = PIPERR;
243       }
244       return -1;
245     }
246     if (! S_ISFIFO(pipe_stat.st_mode)) {
247       if (S_ISCHR(pipe_stat.st_mode)) {
248         /*
249          * Assume the user specified an interface on a system where
250          * interfaces are in /dev.  Pretend we haven't seen it.
251          */
252          ld->cap_pipe_err = PIPNEXIST;
253       } else {
254         g_snprintf(errmsg, errmsgl,
255             "The capture session could not be initiated because\n"
256             "\"%s\" is neither an interface nor a pipe", pipename);
257         ld->cap_pipe_err = PIPERR;
258       }
259       return -1;
260     }
261     fd = eth_open(pipename, O_RDONLY | O_NONBLOCK, 0000 /* no creation so don't matter */);
262     if (fd == -1) {
263       g_snprintf(errmsg, errmsgl,
264           "The capture session could not be initiated "
265           "due to error on pipe open: %s", strerror(errno));
266       ld->cap_pipe_err = PIPERR;
267       return -1;
268     }
269   }
270
271   ld->from_cap_pipe = TRUE;
272
273   /* read the pcap header */
274   FD_ZERO(&rfds);
275   bytes_read = 0;
276   while (bytes_read < sizeof magic) {
277     FD_SET(fd, &rfds);
278     timeout.tv_sec = 0;
279     timeout.tv_usec = CAP_READ_TIMEOUT*1000;
280     sel_ret = select(fd+1, &rfds, NULL, NULL, &timeout);
281     if (sel_ret < 0) {
282       g_snprintf(errmsg, errmsgl,
283         "Unexpected error from select: %s", strerror(errno));
284       goto error;
285     } else if (sel_ret > 0) {
286       b = read(fd, ((char *)&magic)+bytes_read, sizeof magic-bytes_read);
287       if (b <= 0) {
288         if (b == 0)
289           g_snprintf(errmsg, errmsgl, "End of file on pipe during open");
290         else
291           g_snprintf(errmsg, errmsgl, "Error on pipe during open: %s",
292             strerror(errno));
293         goto error;
294       }
295       bytes_read += b;
296     }
297   }
298
299   switch (magic) {
300   case PCAP_MAGIC:
301     /* Host that wrote it has our byte order, and was running
302        a program using either standard or ss990417 libpcap. */
303     ld->cap_pipe_byte_swapped = FALSE;
304     ld->cap_pipe_modified = FALSE;
305     break;
306   case PCAP_MODIFIED_MAGIC:
307     /* Host that wrote it has our byte order, but was running
308        a program using either ss990915 or ss991029 libpcap. */
309     ld->cap_pipe_byte_swapped = FALSE;
310     ld->cap_pipe_modified = TRUE;
311     break;
312   case PCAP_SWAPPED_MAGIC:
313     /* Host that wrote it has a byte order opposite to ours,
314        and was running a program using either standard or
315        ss990417 libpcap. */
316     ld->cap_pipe_byte_swapped = TRUE;
317     ld->cap_pipe_modified = FALSE;
318     break;
319   case PCAP_SWAPPED_MODIFIED_MAGIC:
320     /* Host that wrote it out has a byte order opposite to
321        ours, and was running a program using either ss990915
322        or ss991029 libpcap. */
323     ld->cap_pipe_byte_swapped = TRUE;
324     ld->cap_pipe_modified = TRUE;
325     break;
326   default:
327     /* Not a "libpcap" type we know about. */
328     g_snprintf(errmsg, errmsgl, "Unrecognized libpcap format");
329     goto error;
330   }
331
332   /* Read the rest of the header */
333   bytes_read = 0;
334   while (bytes_read < sizeof(struct pcap_hdr)) {
335     FD_SET(fd, &rfds);
336     timeout.tv_sec = 0;
337     timeout.tv_usec = CAP_READ_TIMEOUT*1000;
338     sel_ret = select(fd+1, &rfds, NULL, NULL, &timeout);
339     if (sel_ret < 0) {
340       g_snprintf(errmsg, errmsgl,
341         "Unexpected error from select: %s", strerror(errno));
342       goto error;
343     } else if (sel_ret > 0) {
344       b = read(fd, ((char *)hdr)+bytes_read,
345             sizeof(struct pcap_hdr) - bytes_read);
346       if (b <= 0) {
347         if (b == 0)
348           g_snprintf(errmsg, errmsgl, "End of file on pipe during open");
349         else
350           g_snprintf(errmsg, errmsgl, "Error on pipe during open: %s",
351             strerror(errno));
352         goto error;
353       }
354       bytes_read += b;
355     }
356   }
357
358   if (ld->cap_pipe_byte_swapped) {
359     /* Byte-swap the header fields about which we care. */
360     hdr->version_major = BSWAP16(hdr->version_major);
361     hdr->version_minor = BSWAP16(hdr->version_minor);
362     hdr->snaplen = BSWAP32(hdr->snaplen);
363     hdr->network = BSWAP32(hdr->network);
364   }
365
366   if (hdr->version_major < 2) {
367     g_snprintf(errmsg, errmsgl, "Unable to read old libpcap format");
368     goto error;
369   }
370
371   ld->cap_pipe_state = STATE_EXPECT_REC_HDR;
372   ld->cap_pipe_err = PIPOK;
373   return fd;
374
375 error:
376   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "cap_pipe_open_live: error %s", errmsg);
377   ld->cap_pipe_err = PIPERR;
378   eth_close(fd);
379   return -1;
380
381 }
382
383
384 /* We read one record from the pipe, take care of byte order in the record
385  * header, write the record to the capture file, and update capture statistics. */
386 static int
387 cap_pipe_dispatch(int fd, loop_data *ld, struct pcap_hdr *hdr,
388                 struct pcaprec_modified_hdr *rechdr, guchar *data,
389                 char *errmsg, int errmsgl)
390 {
391   struct pcap_pkthdr phdr;
392   int b;
393   enum { PD_REC_HDR_READ, PD_DATA_READ, PD_PIPE_EOF, PD_PIPE_ERR,
394           PD_ERR } result;
395
396
397 #ifdef LOG_CAPTURE_VERBOSE
398   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "cap_pipe_dispatch");
399 #endif
400
401   switch (ld->cap_pipe_state) {
402
403   case STATE_EXPECT_REC_HDR:
404     ld->cap_pipe_bytes_to_read = ld->cap_pipe_modified ?
405       sizeof(struct pcaprec_modified_hdr) : sizeof(struct pcaprec_hdr);
406     ld->cap_pipe_bytes_read = 0;
407     ld->cap_pipe_state = STATE_READ_REC_HDR;
408     /* Fall through */
409
410   case STATE_READ_REC_HDR:
411     b = read(fd, ((char *)rechdr)+ld->cap_pipe_bytes_read,
412       ld->cap_pipe_bytes_to_read - ld->cap_pipe_bytes_read);
413     if (b <= 0) {
414       if (b == 0)
415         result = PD_PIPE_EOF;
416       else
417         result = PD_PIPE_ERR;
418       break;
419     }
420     if ((ld->cap_pipe_bytes_read += b) < ld->cap_pipe_bytes_to_read)
421         return 0;
422     result = PD_REC_HDR_READ;
423     break;
424
425   case STATE_EXPECT_DATA:
426     ld->cap_pipe_bytes_read = 0;
427     ld->cap_pipe_state = STATE_READ_DATA;
428     /* Fall through */
429
430   case STATE_READ_DATA:
431     b = read(fd, data+ld->cap_pipe_bytes_read, rechdr->hdr.incl_len - ld->cap_pipe_bytes_read);
432     if (b <= 0) {
433       if (b == 0)
434         result = PD_PIPE_EOF;
435       else
436         result = PD_PIPE_ERR;
437       break;
438     }
439     if ((ld->cap_pipe_bytes_read += b) < rechdr->hdr.incl_len)
440       return 0;
441     result = PD_DATA_READ;
442     break;
443
444   default:
445     g_snprintf(errmsg, errmsgl, "cap_pipe_dispatch: invalid state");
446     result = PD_ERR;
447
448   } /* switch (ld->cap_pipe_state) */
449
450   /*
451    * We've now read as much data as we were expecting, so process it.
452    */
453   switch (result) {
454
455   case PD_REC_HDR_READ:
456     /* We've read the header. Take care of byte order. */
457     cap_pipe_adjust_header(ld, hdr, &rechdr->hdr);
458     if (rechdr->hdr.incl_len > WTAP_MAX_PACKET_SIZE) {
459       g_snprintf(errmsg, errmsgl, "Frame %u too long (%d bytes)",
460         ld->packets_curr+1, rechdr->hdr.incl_len);
461       break;
462     }
463     ld->cap_pipe_state = STATE_EXPECT_DATA;
464     return 0;
465
466   case PD_DATA_READ:
467     /* Fill in a "struct pcap_pkthdr", and process the packet. */
468     phdr.ts.tv_sec = rechdr->hdr.ts_sec;
469     phdr.ts.tv_usec = rechdr->hdr.ts_usec;
470     phdr.caplen = rechdr->hdr.incl_len;
471     phdr.len = rechdr->hdr.orig_len;
472
473     capture_loop_packet_cb((u_char *)ld, &phdr, data);
474
475     ld->cap_pipe_state = STATE_EXPECT_REC_HDR;
476     return 1;
477
478   case PD_PIPE_EOF:
479     ld->cap_pipe_err = PIPEOF;
480     return -1;
481
482   case PD_PIPE_ERR:
483     g_snprintf(errmsg, errmsgl, "Error reading from pipe: %s",
484       strerror(errno));
485     /* Fall through */
486   case PD_ERR:
487     break;
488   }
489
490   ld->cap_pipe_err = PIPERR;
491   /* Return here rather than inside the switch to prevent GCC warning */
492   return -1;
493 }
494 #endif /* not _WIN32 */
495
496
497 /* open the capture input file (pcap or capture pipe) */
498 static int capture_loop_open_input(capture_options *capture_opts, loop_data *ld, char *errmsg, int errmsg_len) {
499   gchar       open_err_str[PCAP_ERRBUF_SIZE];
500   const char *set_linktype_err_str;
501 #ifdef _WIN32
502   int         err;
503   WORD        wVersionRequested;
504   WSADATA     wsaData;
505 #else
506   static const char ppamsg[] = "can't find PPA for ";
507   const char  *libpcap_warn;
508 #endif
509
510
511   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_open_input : %s", capture_opts->iface);
512
513   /* Initialize Windows Socket if we are in a WIN32 OS
514      This needs to be done before querying the interface for network/netmask */
515 #ifdef _WIN32
516   /* XXX - do we really require 1.1 or earlier?
517      Are there any versions that support only 2.0 or higher? */
518   wVersionRequested = MAKEWORD(1, 1);
519   err = WSAStartup(wVersionRequested, &wsaData);
520   if (err != 0) {
521     switch (err) {
522
523     case WSASYSNOTREADY:
524       g_snprintf(errmsg, errmsg_len,
525         "Couldn't initialize Windows Sockets: Network system not ready for network communication");
526       break;
527
528     case WSAVERNOTSUPPORTED:
529       g_snprintf(errmsg, errmsg_len,
530         "Couldn't initialize Windows Sockets: Windows Sockets version %u.%u not supported",
531         LOBYTE(wVersionRequested), HIBYTE(wVersionRequested));
532       break;
533
534     case WSAEINPROGRESS:
535       g_snprintf(errmsg, errmsg_len,
536         "Couldn't initialize Windows Sockets: Blocking operation is in progress");
537       break;
538
539     case WSAEPROCLIM:
540       g_snprintf(errmsg, errmsg_len,
541         "Couldn't initialize Windows Sockets: Limit on the number of tasks supported by this WinSock implementation has been reached");
542       break;
543
544     case WSAEFAULT:
545       g_snprintf(errmsg, errmsg_len,
546         "Couldn't initialize Windows Sockets: Bad pointer passed to WSAStartup");
547       break;
548
549     default:
550       g_snprintf(errmsg, errmsg_len,
551         "Couldn't initialize Windows Sockets: error %d", err);
552       break;
553     }
554     return FALSE;
555   }
556 #endif
557
558   /* Open the network interface to capture from it.
559      Some versions of libpcap may put warnings into the error buffer
560      if they succeed; to tell if that's happened, we have to clear
561      the error buffer, and check if it's still a null string.  */
562   open_err_str[0] = '\0';
563   ld->pcap_h = pcap_open_live(capture_opts->iface,
564                        capture_opts->has_snaplen ? capture_opts->snaplen :
565                                                   WTAP_MAX_PACKET_SIZE,
566                        capture_opts->promisc_mode, CAP_READ_TIMEOUT,
567                        open_err_str);
568
569   if (ld->pcap_h != NULL) {
570     /* we've opened "iface" as a network device */
571 #ifdef _WIN32
572     /* try to set the capture buffer size */
573     if (pcap_setbuff(ld->pcap_h, capture_opts->buffer_size * 1024 * 1024) != 0) {
574         simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
575           "%sCouldn't set the capture buffer size!%s\n"
576           "\n"
577           "The capture buffer size of %luMB seems to be too high for your machine,\n"
578           "the default of 1MB will be used.\n"
579           "\n"
580           "Nonetheless, the capture is started.\n",
581           simple_dialog_primary_start(), simple_dialog_primary_end(), capture_opts->buffer_size);
582     }
583 #endif
584
585     /* setting the data link type only works on real interfaces */
586     if (capture_opts->linktype != -1) {
587       set_linktype_err_str = set_pcap_linktype(ld->pcap_h, capture_opts->iface,
588         capture_opts->linktype);
589       if (set_linktype_err_str != NULL) {
590         g_snprintf(errmsg, errmsg_len, "Unable to set data link type (%s).",
591           set_linktype_err_str);
592         return FALSE;
593       }
594     }
595   } else {
596     /* We couldn't open "iface" as a network device. */
597 #ifdef _WIN32
598     /* On Windows, we don't support capturing on pipes, so we give up. */
599
600     /* On Win32 OSes, the capture devices are probably available to all
601        users; don't warn about permissions problems.
602
603        Do, however, warn that WAN devices aren't supported. */
604     g_snprintf(errmsg, errmsg_len,
605 "%sThe capture session could not be initiated!%s\n"
606 "\n"
607 "(%s)\n"
608 "\n"
609 "Please check that you have the proper interface specified.\n"
610 "\n"
611 "\n"
612 "Help can be found at:\n"
613 "\n"
614 "       %shttp://wiki.ethereal.com/CaptureSetup%s\n"
615 "\n"
616 "64-bit Windows:\n"
617 "WinPcap does not support 64-bit Windows, you will have to use some other\n"
618 "tool to capture traffic, such as netcap.\n"
619 "For netcap details see: http://support.microsoft.com/?id=310875\n"
620 "\n"
621 "Modem (PPP/WAN):\n"
622 "Note that version 3.0 of WinPcap, and earlier versions of WinPcap, don't\n"
623 "support capturing on PPP/WAN interfaces on Windows NT 4.0 / 2000 / XP /\n"
624 "Server 2003.\n"
625 "WinPcap 3.1 has support for it on Windows 2000 / XP / Server 2003, but has no\n"
626 "support for it on Windows NT 4.0 or Windows Vista (Beta 1).",
627         simple_dialog_primary_start(), simple_dialog_primary_end(),
628     open_err_str,
629         simple_dialog_primary_start(), simple_dialog_primary_end());
630     return FALSE;
631 #else
632     /* try to open iface as a pipe */
633     ld->cap_pipe_fd = cap_pipe_open_live(capture_opts->iface, &ld->cap_pipe_hdr, ld, errmsg, errmsg_len);
634
635     if (ld->cap_pipe_fd == -1) {
636
637       if (ld->cap_pipe_err == PIPNEXIST) {
638         /* Pipe doesn't exist, so output message for interface */
639
640         /* If we got a "can't find PPA for XXX" message, warn the user (who
641            is running Ethereal on HP-UX) that they don't have a version
642            of libpcap that properly handles HP-UX (libpcap 0.6.x and later
643            versions, which properly handle HP-UX, say "can't find /dev/dlpi
644            PPA for XXX" rather than "can't find PPA for XXX"). */
645         if (strncmp(open_err_str, ppamsg, sizeof ppamsg - 1) == 0)
646           libpcap_warn =
647             "\n\n"
648             "You are running Ethereal with a version of the libpcap library\n"
649             "that doesn't handle HP-UX network devices well; this means that\n"
650             "Ethereal may not be able to capture packets.\n"
651             "\n"
652             "To fix this, you should install libpcap 0.6.2, or a later version\n"
653             "of libpcap, rather than libpcap 0.4 or 0.5.x.  It is available in\n"
654             "packaged binary form from the Software Porting And Archive Centre\n"
655             "for HP-UX; the Centre is at http://hpux.connect.org.uk/ - the page\n"
656             "at the URL lists a number of mirror sites.";
657         else
658           libpcap_warn = "";
659         g_snprintf(errmsg, errmsg_len,
660           "The capture session could not be initiated (%s).\n"
661           "Please check to make sure you have sufficient permissions, and that\n"
662           "you have the proper interface or pipe specified.%s", open_err_str,
663           libpcap_warn);
664       }
665       /*
666        * Else pipe (or file) does exist and cap_pipe_open_live() has
667        * filled in errmsg
668        */
669       return FALSE;
670     } else
671       /* cap_pipe_open_live() succeeded; don't want
672          error message from pcap_open_live() */
673       open_err_str[0] = '\0';
674 #endif
675   }
676
677 #ifdef MUST_DO_SELECT
678   if (!ld->from_cap_pipe) {
679 #ifdef HAVE_PCAP_GET_SELECTABLE_FD
680     ld->pcap_fd = pcap_get_selectable_fd(ld->pcap_h);
681 #else
682     ld->pcap_fd = pcap_fileno(ld->pcap_h);
683 #endif
684   }
685 #endif
686
687   /* Does "open_err_str" contain a non-empty string?  If so, "pcap_open_live()"
688      returned a warning; print it, but keep capturing. */
689   if (open_err_str[0] != '\0')
690     g_warning("%s.", open_err_str);
691
692   return TRUE;
693 }
694
695
696 /* open the capture input file (pcap or capture pipe) */
697 static void capture_loop_close_input(loop_data *ld) {
698
699   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_close_input");
700
701 #ifndef _WIN32
702   /* if open, close the capture pipe "input file" */
703   if (ld->cap_pipe_fd >= 0) {
704     g_assert(ld->from_cap_pipe);
705     eth_close(ld->cap_pipe_fd);
706   }
707 #endif
708
709   /* if open, close the pcap "input file" */
710   if(ld->pcap_h != NULL) {
711     g_assert(!ld->from_cap_pipe);
712     pcap_close(ld->pcap_h);
713   }
714
715 #ifdef _WIN32
716   /* Shut down windows sockets */
717   WSACleanup();
718 #endif
719 }
720
721
722 /* init the capture filter */
723 static int capture_loop_init_filter(loop_data *ld, const gchar * iface, gchar * cfilter, char *errmsg, int errmsg_len) {
724   bpf_u_int32 netnum, netmask;
725   gchar       lookup_net_err_str[PCAP_ERRBUF_SIZE];
726   struct bpf_program fcode;
727
728
729   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_init_filter: %s", cfilter);
730
731   /* capture filters only work on real interfaces */
732   if (cfilter && !ld->from_cap_pipe) {
733     /* A capture filter was specified; set it up. */
734     if (pcap_lookupnet(iface, &netnum, &netmask, lookup_net_err_str) < 0) {
735       /*
736        * Well, we can't get the netmask for this interface; it's used
737        * only for filters that check for broadcast IP addresses, so
738        * we just punt and use 0.  It might be nice to warn the user,
739        * but that's a pain in a GUI application, as it'd involve popping
740        * up a message box, and it's not clear how often this would make
741        * a difference (only filters that check for IP broadcast addresses
742        * use the netmask).
743        */
744       netmask = 0;
745     }
746     if (pcap_compile(ld->pcap_h, &fcode, cfilter, 1, netmask) < 0) {
747       dfilter_t   *rfcode = NULL;
748       gchar *safe_cfilter = simple_dialog_format_message(cfilter);
749       gchar *safe_cfilter_error_msg = simple_dialog_format_message(
750           pcap_geterr(ld->pcap_h));
751
752       /* filter string invalid, did the user tried a display filter? */
753 #ifndef DUMPCAP
754       if (dfilter_compile(cfilter, &rfcode) && rfcode != NULL) {
755         g_snprintf(errmsg, errmsg_len,
756           "%sInvalid capture filter: \"%s\"!%s\n"
757           "\n"
758           "That string looks like a valid display filter; however, it isn't a valid\n"
759           "capture filter (%s).\n"
760           "\n"
761           "Note that display filters and capture filters don't have the same syntax,\n"
762           "so you can't use most display filter expressions as capture filters.\n"
763           "\n"
764           "See the help for a description of the capture filter syntax.",
765           simple_dialog_primary_start(), safe_cfilter,
766           simple_dialog_primary_end(), safe_cfilter_error_msg);
767         dfilter_free(rfcode);
768       } else 
769 #endif
770       {
771         g_snprintf(errmsg, errmsg_len,
772           "%sInvalid capture filter: \"%s\"!%s\n"
773           "\n"
774           "That string isn't a valid capture filter (%s).\n"
775           "See the help for a description of the capture filter syntax.",
776           simple_dialog_primary_start(), safe_cfilter,
777           simple_dialog_primary_end(), safe_cfilter_error_msg);
778       }
779       g_free(safe_cfilter_error_msg);
780       g_free(safe_cfilter);
781       return FALSE;
782     }
783     if (pcap_setfilter(ld->pcap_h, &fcode) < 0) {
784       g_snprintf(errmsg, errmsg_len, "Can't install filter (%s).",
785         pcap_geterr(ld->pcap_h));
786 #ifdef HAVE_PCAP_FREECODE
787       pcap_freecode(&fcode);
788 #endif
789       return FALSE;
790     }
791 #ifdef HAVE_PCAP_FREECODE
792     pcap_freecode(&fcode);
793 #endif
794   }
795
796   return TRUE;
797 }
798
799
800 /* open the wiretap part of the capture output file */
801 static int capture_loop_init_wiretap_output(capture_options *capture_opts, int save_file_fd, loop_data *ld, char *errmsg, int errmsg_len) {
802   int         pcap_encap;
803   int         file_snaplen;
804   int         err;
805
806
807   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_init_wiretap_output");
808
809   /* get packet encapsulation type and snaplen */
810 #ifndef _WIN32
811   if (ld->from_cap_pipe) {
812     pcap_encap = ld->cap_pipe_hdr.network;
813     file_snaplen = ld->cap_pipe_hdr.snaplen;
814   } else
815 #endif
816   {
817     pcap_encap = get_pcap_linktype(ld->pcap_h, capture_opts->iface);
818     file_snaplen = pcap_snapshot(ld->pcap_h);
819   }
820
821   /* Set up to write to the capture file. */
822   ld->wtap_linktype = wtap_pcap_encap_to_wtap_encap(pcap_encap);
823   if (ld->wtap_linktype == WTAP_ENCAP_UNKNOWN) {
824     g_snprintf(errmsg, errmsg_len,
825         "The network you're capturing from is of a type"
826         " that Ethereal doesn't support (data link type %d).", pcap_encap);
827     return FALSE;
828   }
829   if (capture_opts->multi_files_on) {
830     ld->wtap_pdh = ringbuf_init_wtap_dump_fdopen(WTAP_FILE_PCAP, ld->wtap_linktype,
831       file_snaplen, &err);
832   } else {
833     ld->wtap_pdh = wtap_dump_fdopen(save_file_fd, WTAP_FILE_PCAP,
834       ld->wtap_linktype, file_snaplen, FALSE /* compressed */, &err);
835   }
836
837   if (ld->wtap_pdh == NULL) {
838     /* We couldn't set up to write to the capture file. */
839     switch (err) {
840
841     case WTAP_ERR_CANT_OPEN:
842       strcpy(errmsg, "The file to which the capture would be saved"
843                " couldn't be created for some unknown reason.");
844       break;
845
846     case WTAP_ERR_SHORT_WRITE:
847       strcpy(errmsg, "A full header couldn't be written to the file"
848                " to which the capture would be saved.");
849       break;
850
851     default:
852       if (err < 0) {
853         g_snprintf(errmsg, errmsg_len,
854                      "The file to which the capture would be"
855                      " saved (\"%s\") could not be opened: Error %d.",
856                         capture_opts->save_file, err);
857       } else {
858         g_snprintf(errmsg, errmsg_len,
859                      "The file to which the capture would be"
860                      " saved (\"%s\") could not be opened: %s.",
861                         capture_opts->save_file, strerror(err));
862       }
863       break;
864     }
865
866     return FALSE;
867   }
868
869   return TRUE;
870 }
871
872 static gboolean capture_loop_close_output(capture_options *capture_opts, loop_data *ld, int *err_close) {
873
874   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_close_output");
875
876   if (capture_opts->multi_files_on) {
877     return ringbuf_wtap_dump_close(&capture_opts->save_file, err_close);
878   } else {
879     return wtap_dump_close(ld->wtap_pdh, err_close);
880   }
881 }
882
883 /* dispatch incoming packets (pcap or capture pipe) */
884 static int
885 capture_loop_dispatch(capture_options *capture_opts, loop_data *ld,
886                       char *errmsg, int errmsg_len) {
887   int       inpkts;
888 #ifndef _WIN32
889   fd_set    set1;
890   struct timeval timeout;
891   int         sel_ret;
892   guchar pcap_data[WTAP_MAX_PACKET_SIZE];
893 #endif
894
895 #ifndef _WIN32
896     if (ld->from_cap_pipe) {
897       /* dispatch from capture pipe */
898 #ifdef LOG_CAPTURE_VERBOSE
899       g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_dispatch: from capture pipe");
900 #endif
901       FD_ZERO(&set1);
902       FD_SET(ld->cap_pipe_fd, &set1);
903       timeout.tv_sec = 0;
904       timeout.tv_usec = CAP_READ_TIMEOUT*1000;
905       sel_ret = select(ld->cap_pipe_fd+1, &set1, NULL, NULL, &timeout);
906       if (sel_ret <= 0) {
907         inpkts = 0;
908         if (sel_ret < 0 && errno != EINTR) {
909           g_snprintf(errmsg, errmsg_len,
910             "Unexpected error from select: %s", strerror(errno));
911           sync_pipe_errmsg_to_parent(errmsg);
912           ld->go = FALSE;
913         }
914       } else {
915         /*
916          * "select()" says we can read from the pipe without blocking
917          */
918         inpkts = cap_pipe_dispatch(ld->cap_pipe_fd, ld, &ld->cap_pipe_hdr, &ld->cap_pipe_rechdr, pcap_data,
919           errmsg, errmsg_len);
920         if (inpkts < 0) {
921           ld->go = FALSE;
922         }
923       }
924     }
925     else
926 #endif /* _WIN32 */
927     {
928       /* dispatch from pcap */
929 #ifdef MUST_DO_SELECT
930       /*
931        * Sigh.  The semantics of the read timeout argument to
932        * "pcap_open_live()" aren't particularly well specified by
933        * the "pcap" man page - at least with the BSD BPF code, the
934        * intent appears to be, at least in part, a way of cutting
935        * down the number of reads done on a capture, by blocking
936        * until the buffer fills or a timer expires - and the Linux
937        * libpcap doesn't actually support it, so we can't use it
938        * to break out of the "pcap_dispatch()" every 1/4 of a second
939        * or so.  Linux's libpcap is not the only libpcap that doesn't
940        * support the read timeout.
941        *
942        * Furthermore, at least on Solaris, the bufmod STREAMS module's
943        * read timeout won't go off if no data has arrived, i.e. it cannot
944        * be used to guarantee that a read from a DLPI stream will return
945        * within a specified amount of time regardless of whether any
946        * data arrives or not.
947        *
948        * Thus, on all platforms other than BSD, we do a "select()" on the
949        * file descriptor for the capture, with a timeout of CAP_READ_TIMEOUT
950        * milliseconds, or CAP_READ_TIMEOUT*1000 microseconds.
951        *
952        * "select()", on BPF devices, doesn't work as you might expect;
953        * at least on some versions of some flavors of BSD, the timer
954        * doesn't start until a read is done, so it won't expire if
955        * only a "select()" or "poll()" is posted.
956        *
957        * If we have "pcap_get_selectable_fd()", we use it to get the
958        * descriptor on which to select; if that's -1, it means there
959        * is no descriptor on which you can do a "select()" (perhaps
960        * because you're capturing on a special device, and that device's
961        * driver unfortunately doesn't support "select()", in which case
962        * we don't do the select - which means Ethereal might block,
963        * unable to accept user input, until a packet arrives.  If
964        * that's unacceptable, plead with whoever supplies the software
965        * for that device to add "select()" support.
966        */
967 #ifdef LOG_CAPTURE_VERBOSE
968       g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_dispatch: from pcap_dispatch with select");
969 #endif
970       if (ld->pcap_fd != -1) {
971         FD_ZERO(&set1);
972         FD_SET(ld->pcap_fd, &set1);
973         timeout.tv_sec = 0;
974         timeout.tv_usec = CAP_READ_TIMEOUT*1000;
975         sel_ret = select(ld->pcap_fd+1, &set1, NULL, NULL, &timeout);
976         if (sel_ret > 0) {
977           /*
978            * "select()" says we can read from it without blocking; go for
979            * it.
980            */
981           inpkts = pcap_dispatch(ld->pcap_h, 1, capture_loop_packet_cb, (u_char *)ld);
982           if (inpkts < 0) {
983             ld->pcap_err = TRUE;
984             ld->go = FALSE;
985           }
986         } else {
987           inpkts = 0;
988           if (sel_ret < 0 && errno != EINTR) {
989             g_snprintf(errmsg, errmsg_len,
990               "Unexpected error from select: %s", strerror(errno));
991             sync_pipe_errmsg_to_parent(errmsg);
992             ld->go = FALSE;
993           }
994         }
995       }
996       else
997 #endif /* MUST_DO_SELECT */
998       {
999         /* dispatch from pcap without select */
1000 #if 1
1001 #ifdef LOG_CAPTURE_VERBOSE
1002         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_dispatch: from pcap_dispatch");
1003 #endif
1004         inpkts = pcap_dispatch(ld->pcap_h, 1, capture_loop_packet_cb, (u_char *) ld);
1005         if (inpkts < 0) {
1006           ld->pcap_err = TRUE;
1007           ld->go = FALSE;
1008         }
1009 #else
1010         {
1011 #ifdef LOG_CAPTURE_VERBOSE
1012             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_dispatch: from pcap_next_ex");
1013 #endif
1014             /* XXX - this is currently unused, as there is some confusion with pcap_next_ex() vs. pcap_dispatch() */
1015
1016             /* WinPcap's remote capturing feature doesn't work, see http://wiki.ethereal.com/CaptureSetup_2fWinPcapRemote */
1017             /* for reference, an example remote interface: rpcap://[1.2.3.4]/\Device\NPF_{39993D68-7C9B-4439-A329-F2D888DA7C5C} */
1018
1019             /* emulate dispatch from pcap */
1020             int in;
1021             struct pcap_pkthdr *pkt_header;
1022                     u_char *pkt_data;
1023
1024             inpkts = 0;
1025             while( (in = pcap_next_ex(ld->pcap_h, &pkt_header, &pkt_data)) == 1) {
1026                 capture_loop_packet_cb( (u_char *) ld, pkt_header, pkt_data);
1027                 inpkts++;
1028             }
1029
1030             if(in < 0) {
1031               ld->pcap_err = TRUE;
1032               ld->go = FALSE;
1033               inpkts = in;
1034             }
1035         }
1036 #endif
1037       }
1038     }
1039
1040 #ifdef LOG_CAPTURE_VERBOSE
1041     g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_dispatch: %d new packet%s", inpkts, plurality(inpkts, "", "s"));
1042 #endif
1043
1044     return inpkts;
1045 }
1046
1047
1048 /* open the output file (temporary/specified name/ringbuffer) */
1049 /* Returns TRUE if the file opened successfully, FALSE otherwise. */
1050 static gboolean
1051 capture_loop_open_output(capture_options *capture_opts, int *save_file_fd,
1052                       char *errmsg, int errmsg_len) {
1053
1054   char tmpname[128+1];
1055   gchar *capfile_name;
1056   gboolean is_tempfile;
1057
1058
1059   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_open_output: %s", 
1060       (capture_opts->save_file) ? capture_opts->save_file : "");
1061
1062   if (capture_opts->save_file != NULL) {
1063     /* We return to the caller while the capture is in progress.  
1064      * Therefore we need to take a copy of save_file in
1065      * case the caller destroys it after we return.
1066      */
1067     capfile_name = g_strdup(capture_opts->save_file);
1068     if (capture_opts->multi_files_on) {
1069       /* ringbuffer is enabled */
1070       *save_file_fd = ringbuf_init(capfile_name,
1071           (capture_opts->has_ring_num_files) ? capture_opts->ring_num_files : 0);
1072
1073       /* we need the ringbuf name */
1074       if(*save_file_fd != -1) {
1075           g_free(capfile_name);
1076           capfile_name = g_strdup(ringbuf_current_filename());
1077       }
1078     } else {
1079       /* Try to open/create the specified file for use as a capture buffer. */
1080       *save_file_fd = open(capfile_name, O_RDWR|O_BINARY|O_TRUNC|O_CREAT,
1081                                 0600);
1082     }
1083     is_tempfile = FALSE;
1084   } else {
1085     /* Choose a random name for the temporary capture buffer */
1086     *save_file_fd = create_tempfile(tmpname, sizeof tmpname, "ether");
1087     capfile_name = g_strdup(tmpname);
1088     is_tempfile = TRUE;
1089   }
1090
1091   /* did we fail to open the output file? */
1092   if (*save_file_fd == -1) {
1093     if (is_tempfile) {
1094       g_snprintf(errmsg, errmsg_len,
1095         "The temporary file to which the capture would be saved (\"%s\") "
1096         "could not be opened: %s.", capfile_name, strerror(errno));
1097     } else {
1098       if (capture_opts->multi_files_on) {
1099         ringbuf_error_cleanup();
1100       }
1101
1102       g_snprintf(errmsg, errmsg_len,
1103             "The file to which the capture would be saved (\"%s\") "
1104         "could not be opened: %s.", capfile_name, 
1105         strerror(errno));
1106
1107       /*open_failure_alert_box(capfile_name, errno, TRUE);*/
1108     }
1109     g_free(capfile_name);
1110     return FALSE;
1111   }
1112
1113   if(capture_opts->save_file != NULL) {
1114     g_free(capture_opts->save_file);
1115   }
1116   capture_opts->save_file = capfile_name;
1117   /* capture_opts.save_file is "g_free"ed later, which is equivalent to
1118      "g_free(capfile_name)". */
1119
1120   return TRUE;
1121 }
1122
1123
1124 #ifndef _WIN32
1125 static void
1126 capture_loop_stop_signal_handler(int signo _U_)
1127 {
1128   capture_loop_stop();
1129 }
1130 #endif
1131
1132 #ifdef _WIN32
1133 #define TIME_GET() GetTickCount()
1134 #else
1135 #define TIME_GET() time(NULL)
1136 #endif
1137
1138 /*
1139  * This needs to be static, so that the SIGUSR1 handler can clear the "go"
1140  * flag.
1141  */
1142 static loop_data   ld;
1143
1144 /* Do the low-level work of a capture.
1145    Returns TRUE if it succeeds, FALSE otherwise. */
1146 int
1147 capture_loop_start(capture_options *capture_opts, gboolean *stats_known, struct pcap_stat *stats)
1148 {
1149   time_t      upd_time, cur_time;
1150   time_t      start_time;
1151   int         err_close, inpkts;
1152   condition  *cnd_file_duration = NULL;
1153   condition  *cnd_autostop_files = NULL;
1154   condition  *cnd_autostop_size = NULL;
1155   condition  *cnd_autostop_duration = NULL;
1156   guint32     autostop_files = 0;
1157   gboolean    write_ok;
1158   gboolean    close_ok;
1159   capture_info   capture_ui;
1160   char        errmsg[4096+1];
1161   int         save_file_fd;
1162
1163
1164   /* init the loop data */
1165   ld.go                 = TRUE;
1166   ld.packets_curr       = 0;
1167   if (capture_opts->has_autostop_packets)
1168     ld.packets_max      = capture_opts->autostop_packets;
1169   else
1170     ld.packets_max      = 0;    /* no limit */
1171   ld.err                = 0;    /* no error seen yet */
1172   ld.wtap_linktype      = WTAP_ENCAP_UNKNOWN;
1173   ld.pcap_err           = FALSE;
1174   ld.from_cap_pipe      = FALSE;
1175   ld.packets_sync_pipe  = 0;
1176   ld.wtap_pdh           = NULL;
1177 #ifndef _WIN32
1178   ld.cap_pipe_fd        = -1;
1179 #endif
1180 #ifdef MUST_DO_SELECT
1181   ld.pcap_fd            = 0;
1182 #endif
1183   ld.show_info          = capture_opts->show_info;
1184
1185 #ifndef _WIN32
1186   /*
1187    * Catch SIGUSR1, so that we exit cleanly if the parent process
1188    * kills us with it due to the user selecting "Capture->Stop".
1189    */
1190     signal(SIGUSR1, capture_loop_stop_signal_handler);
1191 #endif
1192
1193   /* We haven't yet gotten the capture statistics. */
1194   *stats_known      = FALSE;
1195
1196   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Capture child starting ...");
1197   capture_opts_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, capture_opts);
1198
1199   /* open the output file (temporary/specified name/ringbuffer) */
1200   if (!capture_loop_open_output(capture_opts, &save_file_fd, errmsg, sizeof(errmsg))) {
1201     goto error;    
1202   }
1203
1204   /* open the "input file" from network interface or capture pipe */
1205   if (!capture_loop_open_input(capture_opts, &ld, errmsg, sizeof(errmsg))) {
1206     goto error;
1207   }
1208
1209   /* init the input filter from the network interface (capture pipe will do nothing) */
1210   if (!capture_loop_init_filter(&ld, capture_opts->iface, capture_opts->cfilter, errmsg, sizeof(errmsg))) {
1211     goto error;
1212   }
1213
1214   /* open the wiretap part of the output file (the output file is already open) */
1215   if (!capture_loop_init_wiretap_output(capture_opts, save_file_fd, &ld, errmsg, sizeof(errmsg))) {
1216     goto error;
1217   }
1218
1219   /* XXX - capture SIGTERM and close the capture, in case we're on a
1220      Linux 2.0[.x] system and you have to explicitly close the capture
1221      stream in order to turn promiscuous mode off?  We need to do that
1222      in other places as well - and I don't think that works all the
1223      time in any case, due to libpcap bugs. */
1224
1225   /* Well, we should be able to start capturing.
1226
1227      Sync out the capture file, so the header makes it to the file system,
1228      and send a "capture started successfully and capture file created"
1229      message to our parent so that they'll open the capture file and
1230      update its windows to indicate that we have a live capture in
1231      progress. */
1232   wtap_dump_flush(ld.wtap_pdh);
1233   sync_pipe_filename_to_parent(capture_opts->save_file);
1234
1235   /* initialize capture stop (and alike) conditions */
1236   init_capture_stop_conditions();
1237   /* create stop conditions */
1238   if (capture_opts->has_autostop_filesize)
1239     cnd_autostop_size =
1240         cnd_new(CND_CLASS_CAPTURESIZE,(long)capture_opts->autostop_filesize * 1024);
1241   if (capture_opts->has_autostop_duration)
1242     cnd_autostop_duration =
1243         cnd_new(CND_CLASS_TIMEOUT,(gint32)capture_opts->autostop_duration);
1244
1245   if (capture_opts->multi_files_on) {
1246       if (capture_opts->has_file_duration)
1247         cnd_file_duration =
1248             cnd_new(CND_CLASS_TIMEOUT, capture_opts->file_duration);
1249
1250       if (capture_opts->has_autostop_files)
1251         cnd_autostop_files =
1252             cnd_new(CND_CLASS_CAPTURESIZE, capture_opts->autostop_files);
1253   }
1254
1255   /* start capture info dialog */
1256   if(capture_opts->show_info) {
1257       capture_info_init(&ld.counts);
1258       capture_ui.counts = &ld.counts;
1259       capture_info_ui_create(&capture_ui, capture_opts->iface);
1260   }
1261
1262   /* init the time values */
1263   start_time = TIME_GET();
1264   upd_time = TIME_GET();
1265
1266
1267   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Capture child running!");
1268
1269   /* WOW, everything is prepared! */
1270   /* please fasten your seat belts, we will enter now the actual capture loop */
1271   while (ld.go) {
1272     main_window_update();
1273
1274     /* dispatch incoming packets */
1275     inpkts = capture_loop_dispatch(capture_opts, &ld, errmsg, sizeof(errmsg));
1276
1277     main_window_update();
1278
1279 #ifdef _WIN32
1280       /* some news from our parent (signal pipe)? -> just stop the capture */
1281       {
1282           HANDLE handle;
1283           DWORD avail = 0;
1284           gboolean result;
1285
1286
1287           handle = (HANDLE) _get_osfhandle (0);
1288           result = PeekNamedPipe(handle, NULL, 0, NULL, &avail, NULL);
1289
1290           if(!result || avail > 0) {
1291             /* XXX - doesn't work with dumpcap as a command line tool */
1292             /* as we have no input pipe, need to find a way to circumvent this */
1293 #ifndef DUMPCAP
1294             ld.go = FALSE;
1295 #endif
1296             /*g_warning("loop closing");*/
1297           }
1298       }
1299 #endif
1300
1301     if (inpkts > 0) {
1302       ld.packets_sync_pipe += inpkts;
1303
1304       /* check capture size condition */
1305       if (cnd_autostop_size != NULL && cnd_eval(cnd_autostop_size,
1306                     (guint32)wtap_get_bytes_dumped(ld.wtap_pdh))){
1307         /* Capture size limit reached, do we have another file? */
1308         if (capture_opts->multi_files_on) {
1309           if (cnd_autostop_files != NULL && cnd_eval(cnd_autostop_files, ++autostop_files)) {
1310             /* no files left: stop here */
1311             ld.go = FALSE;
1312             continue;
1313           }
1314
1315           /* Switch to the next ringbuffer file */
1316           if (ringbuf_switch_file(&ld.wtap_pdh, &capture_opts->save_file, &save_file_fd, &ld.err)) {
1317             /* File switch succeeded: reset the conditions */
1318             cnd_reset(cnd_autostop_size);
1319             if (cnd_file_duration) {
1320               cnd_reset(cnd_file_duration);
1321             }
1322             wtap_dump_flush(ld.wtap_pdh);
1323             sync_pipe_filename_to_parent(capture_opts->save_file);
1324                         ld.packets_sync_pipe = 0;
1325           } else {
1326             /* File switch failed: stop here */
1327             ld.go = FALSE;
1328             continue;
1329           }
1330         } else {
1331           /* single file, stop now */
1332           ld.go = FALSE;
1333           continue;
1334         }
1335       } /* cnd_autostop_size */
1336     } /* inpkts */
1337
1338     /* Only update once a second (Win32: 500ms) so as not to overload slow displays */
1339     cur_time = TIME_GET();
1340 #ifdef _WIN32
1341     if ( (cur_time - upd_time) > 500) {
1342 #else
1343     if (cur_time - upd_time > 0) {
1344 #endif
1345         upd_time = cur_time;
1346
1347       /*if (pcap_stats(pch, stats) >= 0) {
1348         *stats_known = TRUE;
1349       }*/
1350
1351       /* calculate and display running time */
1352       if(capture_opts->show_info) {
1353           cur_time -= start_time;
1354 #ifdef _WIN32
1355           capture_ui.running_time   = cur_time / 1000;
1356 #else
1357           capture_ui.running_time   = cur_time;
1358 #endif
1359           capture_ui.new_packets    = ld.packets_sync_pipe;
1360           capture_info_ui_update(&capture_ui);
1361       }
1362
1363       /* Let the parent process know. */
1364       if (ld.packets_sync_pipe) {
1365         /* do sync here */
1366         wtap_dump_flush(ld.wtap_pdh);
1367
1368           /* Send our parent a message saying we've written out "ld.sync_packets"
1369              packets to the capture file. */
1370         sync_pipe_packet_count_to_parent(ld.packets_sync_pipe);
1371
1372         ld.packets_sync_pipe = 0;
1373       }
1374
1375       /* check capture duration condition */
1376       if (cnd_autostop_duration != NULL && cnd_eval(cnd_autostop_duration)) {
1377         /* The maximum capture time has elapsed; stop the capture. */
1378         ld.go = FALSE;
1379         continue;
1380       }
1381       
1382       /* check capture file duration condition */
1383       if (cnd_file_duration != NULL && cnd_eval(cnd_file_duration)) {
1384         /* duration limit reached, do we have another file? */
1385         if (capture_opts->multi_files_on) {
1386           if (cnd_autostop_files != NULL && cnd_eval(cnd_autostop_files, ++autostop_files)) {
1387             /* no files left: stop here */
1388             ld.go = FALSE;
1389             continue;
1390           }
1391
1392           /* Switch to the next ringbuffer file */
1393           if (ringbuf_switch_file(&ld.wtap_pdh, &capture_opts->save_file, &save_file_fd, &ld.err)) {
1394             /* file switch succeeded: reset the conditions */
1395             cnd_reset(cnd_file_duration);
1396             if(cnd_autostop_size)
1397               cnd_reset(cnd_autostop_size);
1398             wtap_dump_flush(ld.wtap_pdh);
1399             sync_pipe_filename_to_parent(capture_opts->save_file);
1400                         ld.packets_sync_pipe = 0;
1401           } else {
1402             /* File switch failed: stop here */
1403                 ld.go = FALSE;
1404             continue;
1405           }
1406         } else {
1407           /* single file, stop now */
1408           ld.go = FALSE;
1409           continue;
1410         }
1411       } /* cnd_file_duration */
1412     }
1413
1414   } /* while (ld.go) */
1415
1416   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Capture child stopping ...");
1417
1418   /* close capture info dialog */
1419   if(capture_opts->show_info) {
1420     capture_info_ui_destroy(&capture_ui);
1421   }
1422
1423   /* delete stop conditions */
1424   if (cnd_file_duration != NULL)
1425     cnd_delete(cnd_file_duration);
1426   if (cnd_autostop_files != NULL)
1427     cnd_delete(cnd_autostop_files);
1428   if (cnd_autostop_size != NULL)
1429     cnd_delete(cnd_autostop_size);
1430   if (cnd_autostop_duration != NULL)
1431     cnd_delete(cnd_autostop_duration);
1432
1433   /* did we had a pcap (input) error? */
1434   if (ld.pcap_err) {
1435     g_snprintf(errmsg, sizeof(errmsg), "Error while capturing packets: %s",
1436       pcap_geterr(ld.pcap_h));
1437     sync_pipe_errmsg_to_parent(errmsg);
1438   }
1439 #ifndef _WIN32
1440     else if (ld.from_cap_pipe && ld.cap_pipe_err == PIPERR)
1441       sync_pipe_errmsg_to_parent(errmsg);
1442 #endif
1443
1444   /* did we had an error while capturing? */
1445   if (ld.err == 0) {
1446     write_ok = TRUE;
1447   } else {
1448     capture_loop_get_errmsg(errmsg, sizeof(errmsg), capture_opts->save_file, ld.err,
1449                               FALSE);
1450     sync_pipe_errmsg_to_parent(errmsg);
1451     write_ok = FALSE;
1452   }
1453
1454   /* close the wiretap (output) file */
1455   close_ok = capture_loop_close_output(capture_opts, &ld, &err_close);
1456
1457   /* If we've displayed a message about a write error, there's no point
1458      in displaying another message about an error on close. */
1459   if (!close_ok && write_ok) {
1460     capture_loop_get_errmsg(errmsg, sizeof(errmsg), capture_opts->save_file, err_close,
1461                 TRUE);
1462     sync_pipe_errmsg_to_parent(errmsg);
1463   }
1464
1465   /*
1466    * XXX We exhibit different behaviour between normal mode and sync mode
1467    * when the pipe is stdin and not already at EOF.  If we're a child, the
1468    * parent's stdin isn't closed, so if the user starts another capture,
1469    * cap_pipe_open_live() will very likely not see the expected magic bytes and
1470    * will say "Unrecognized libpcap format".  On the other hand, in normal
1471    * mode, cap_pipe_open_live() will say "End of file on pipe during open".
1472    */
1473
1474   /* get packet drop statistics from pcap */
1475   if(ld.pcap_h != NULL) {
1476     g_assert(!ld.from_cap_pipe);
1477     /* Get the capture statistics, so we know how many packets were
1478        dropped. */
1479     if (pcap_stats(ld.pcap_h, stats) >= 0) {
1480       *stats_known = TRUE;
1481       /* Let the parent process know. */
1482       sync_pipe_drops_to_parent(stats->ps_drop);
1483     } else {
1484       g_snprintf(errmsg, sizeof(errmsg),
1485                 "Can't get packet-drop statistics: %s",
1486                 pcap_geterr(ld.pcap_h));
1487       sync_pipe_errmsg_to_parent(errmsg);
1488     }
1489   }
1490
1491   /* close the input file (pcap or capture pipe) */
1492   capture_loop_close_input(&ld);
1493
1494   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Capture child stopped!");
1495
1496   /* ok, if the write and the close were successful. */
1497   return write_ok && close_ok;
1498
1499 error:
1500   if (capture_opts->multi_files_on) {
1501     /* cleanup ringbuffer */
1502     ringbuf_error_cleanup();
1503   } else {
1504     /* We can't use the save file, and we have no wtap_dump stream
1505        to close in order to close it, so close the FD directly. */
1506     eth_close(save_file_fd);
1507
1508     /* We couldn't even start the capture, so get rid of the capture
1509        file. */
1510     eth_unlink(capture_opts->save_file); /* silently ignore error */
1511     g_free(capture_opts->save_file);
1512   }
1513   capture_opts->save_file = NULL;
1514   sync_pipe_errmsg_to_parent(errmsg);
1515
1516   /* close the input file (pcap or cap_pipe) */
1517   capture_loop_close_input(&ld);
1518
1519   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Capture child stopped with error");
1520
1521   return FALSE;
1522 }
1523
1524
1525 void capture_loop_stop(void)
1526 {
1527     ld.go = FALSE;
1528 }
1529  
1530
1531 static void
1532 capture_loop_get_errmsg(char *errmsg, int errmsglen, const char *fname,
1533                           int err, gboolean is_close)
1534 {
1535   switch (err) {
1536
1537   case ENOSPC:
1538     g_snprintf(errmsg, errmsglen,
1539                 "Not all the packets could be written to the file"
1540                 " to which the capture was being saved\n"
1541                 "(\"%s\") because there is no space left on the file system\n"
1542                 "on which that file resides.",
1543                 fname);
1544     break;
1545
1546 #ifdef EDQUOT
1547   case EDQUOT:
1548     g_snprintf(errmsg, errmsglen,
1549                 "Not all the packets could be written to the file"
1550                 " to which the capture was being saved\n"
1551                 "(\"%s\") because you are too close to, or over,"
1552                 " your disk quota\n"
1553                 "on the file system on which that file resides.",
1554                 fname);
1555   break;
1556 #endif
1557
1558   case WTAP_ERR_CANT_CLOSE:
1559     g_snprintf(errmsg, errmsglen,
1560                 "The file to which the capture was being saved"
1561                 " couldn't be closed for some unknown reason.");
1562     break;
1563
1564   case WTAP_ERR_SHORT_WRITE:
1565     g_snprintf(errmsg, errmsglen,
1566                 "Not all the packets could be written to the file"
1567                 " to which the capture was being saved\n"
1568                 "(\"%s\").",
1569                 fname);
1570     break;
1571
1572   default:
1573     if (is_close) {
1574       g_snprintf(errmsg, errmsglen,
1575                 "The file to which the capture was being saved\n"
1576                 "(\"%s\") could not be closed: %s.",
1577                 fname, wtap_strerror(err));
1578     } else {
1579       g_snprintf(errmsg, errmsglen,
1580                 "An error occurred while writing to the file"
1581                 " to which the capture was being saved\n"
1582                 "(\"%s\"): %s.",
1583                 fname, wtap_strerror(err));
1584     }
1585     break;
1586   }
1587 }
1588
1589
1590 /* one packet was captured, process it */
1591 static void
1592 capture_loop_packet_cb(u_char *user, const struct pcap_pkthdr *phdr,
1593   const u_char *pd)
1594 {
1595   struct wtap_pkthdr whdr;
1596   union wtap_pseudo_header pseudo_header;
1597   loop_data *ld = (loop_data *) user;
1598   int err;
1599
1600   /* if the user told us to stop after x packets, do we have enough? */
1601   ld->packets_curr++;
1602   if ((ld->packets_max > 0) && (ld->packets_curr >= ld->packets_max))
1603   {
1604      ld->go = FALSE;
1605   }
1606
1607   /* Convert from libpcap to Wiretap format.
1608      If that fails, set "ld->go" to FALSE, to stop the capture, and set
1609      "ld->err" to the error. */
1610   pd = wtap_process_pcap_packet(ld->wtap_linktype, phdr, pd, &pseudo_header,
1611                                 &whdr, &err);
1612   if (pd == NULL) {
1613     ld->go = FALSE;
1614     ld->err = err;
1615     return;
1616   }
1617
1618   if (ld->wtap_pdh) {
1619     /* We're supposed to write the packet to a file; do so.
1620        If this fails, set "ld->go" to FALSE, to stop the capture, and set
1621        "ld->err" to the error. */
1622     if (!wtap_dump(ld->wtap_pdh, &whdr, &pseudo_header, pd, &err)) {
1623       ld->go = FALSE;
1624       ld->err = err;
1625     }
1626   }
1627
1628 #ifndef DUMPCAP
1629   /* if the capture info dialog is hidden, no need to create the packet info */
1630   if(!ld->show_info) {
1631       return;
1632   }
1633
1634   capture_info_packet(&ld->counts, ld->wtap_linktype, pd, whdr.caplen, pseudo_header);
1635 #endif
1636 }
1637
1638 #endif /* HAVE_LIBPCAP */
1639