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