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