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