Removed trailing whitespaces from .h and .c files using the
[obnox/wireshark/wip.git] / capture.c
1 /* capture.c
2  * Routines for packet capture windows
3  *
4  * $Id: capture.c,v 1.188 2002/08/13 18:12:11 guy Exp $
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 #ifdef HAVE_CONFIG_H
26 # include "config.h"
27 #endif
28
29 #ifdef HAVE_LIBPCAP
30
31 #ifdef HAVE_SYS_STAT_H
32 # include <sys/stat.h>
33 #endif
34
35 #ifdef HAVE_SYS_WAIT_H
36 # include <sys/wait.h>
37 #endif
38
39 #ifndef _WIN32
40 /*
41  * Define various POSIX macros (and, in the case of WCOREDUMP, non-POSIX
42  * macros) on UNIX systems that don't have them.
43  */
44 #ifndef WIFEXITED
45 # define WIFEXITED(status)      (((status) & 0177) == 0)
46 #endif
47 #ifndef WIFSTOPPED
48 # define WIFSTOPPED(status)     (((status) & 0177) == 0177)
49 #endif
50 #ifndef WIFSIGNALED
51 # define WIFSIGNALED(status)    (!WIFSTOPPED(status) && !WIFEXITED(status))
52 #endif
53 #ifndef WEXITSTATUS
54 # define WEXITSTATUS(status)    ((status) >> 8)
55 #endif
56 #ifndef WTERMSIG
57 # define WTERMSIG(status)       ((status) & 0177)
58 #endif
59 #ifndef WCOREDUMP
60 # define WCOREDUMP(status)      ((status) & 0200)
61 #endif
62 #ifndef WSTOPSIG
63 # define WSTOPSIG(status)       ((status) >> 8)
64 #endif
65 #endif /* _WIN32 */
66
67 #ifdef HAVE_IO_H
68 # include <io.h>
69 #endif
70
71 #include <gtk/gtk.h>
72 #include <stdlib.h>
73 #include <stdio.h>
74 #include <ctype.h>
75 #include <string.h>
76
77 #ifdef HAVE_FCNTL_H
78 #include <fcntl.h>
79 #endif
80
81 #ifdef HAVE_UNISTD_H
82 #include <unistd.h>
83 #endif
84
85 #include <time.h>
86
87 #ifdef HAVE_SYS_SOCKET_H
88 #include <sys/socket.h>
89 #endif
90
91 #ifdef HAVE_SYS_IOCTL_H
92 #include <sys/ioctl.h>
93 #endif
94
95 #include <signal.h>
96 #include <errno.h>
97
98 #include <pcap.h>
99
100 #ifdef NEED_SNPRINTF_H
101 # include "snprintf.h"
102 #endif
103
104 #ifdef _WIN32
105 #include <process.h>    /* For spawning child process */
106 #endif
107
108 /*
109  * XXX - the various BSDs appear to define BSD in <sys/param.h>; we don't
110  * want to include it if it's not present on this platform, however.
111  */
112 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__APPLE__)
113 #ifndef BSD
114 #define BSD
115 #endif /* BSD */
116 #endif /* defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) || defined(__APPLE__) */
117
118 /*
119  * We don't want to do a "select()" on the pcap_t's file descriptor on
120  * BSD (because "select()" doesn't work correctly on BPF devices on at
121  * least some releases of some flavors of BSD), and we don't want to do
122  * it on Windows (because "select()" is something for sockets, not for
123  * arbitrary handles).
124  *
125  * We *do* want to do it on other platforms, as, on other platforms (with
126  * the possible exception of Ultrix and Digital UNIX), the read timeout
127  * doesn't expire if no packets have arrived, so a "pcap_dispatch()" call
128  * will block until packets arrive, causing the UI to hang.
129  */
130 #if !defined(BSD) && !defined(_WIN32)
131 # define MUST_DO_SELECT
132 #endif
133
134 #include "gtk/main.h"
135 #include "gtk/gtkglobals.h"
136 #include <epan/packet.h>
137 #include "file.h"
138 #include "capture.h"
139 #include "util.h"
140 #include "pcap-util.h"
141 #include "simple_dialog.h"
142 #include "prefs.h"
143 #include "globals.h"
144 #include "conditions.h"
145 #include "capture_stop_conditions.h"
146 #include "ringbuffer.h"
147
148 #include "wiretap/libpcap.h"
149 #include "wiretap/wtap.h"
150 #include "wiretap/wtap-capture.h"
151
152 #include "packet-atalk.h"
153 #include "packet-atm.h"
154 #include "packet-clip.h"
155 #include "packet-eth.h"
156 #include "packet-fddi.h"
157 #include "packet-null.h"
158 #include "packet-ppp.h"
159 #include "packet-raw.h"
160 #include "packet-sll.h"
161 #include "packet-tr.h"
162 #include "packet-ieee80211.h"
163 #include "packet-chdlc.h"
164 #include "packet-prism.h"
165
166 #ifdef WIN32
167 #include "capture-wpcap.h"
168 #endif
169
170 /*
171  * Capture options.
172  */
173 capture_options capture_opts;
174
175 static int sync_pipe[2]; /* used to sync father */
176 enum PIPES { READ, WRITE }; /* Constants 0 and 1 for READ and WRITE */
177 int quit_after_cap; /* Makes a "capture only mode". Implies -k */
178 gboolean capture_child; /* if this is the child for "-S" */
179 static int fork_child = -1;     /* If not -1, in parent, process ID of child */
180 static guint cap_input_id;
181
182 /*
183  * Indications sent out on the sync pipe.
184  */
185 #define SP_CAPSTART     ';'     /* capture start message */
186 #define SP_PACKET_COUNT '*'     /* followed by count of packets captured since last message */
187 #define SP_ERROR_MSG    '!'     /* followed by length of error message that follows */
188 #define SP_DROPS        '#'     /* followed by count of packets dropped in capture */
189
190 #ifdef _WIN32
191 static guint cap_timer_id;
192 static int cap_timer_cb(gpointer); /* Win32 kludge to check for pipe input */
193 #endif
194
195 static void cap_file_input_cb(gpointer, gint, GdkInputCondition);
196 static void wait_for_child(gboolean);
197 #ifndef _WIN32
198 static char *signame(int);
199 #endif
200 static void capture_delete_cb(GtkWidget *, GdkEvent *, gpointer);
201 static void capture_stop_cb(GtkWidget *, gpointer);
202 static void capture_pcap_cb(guchar *, const struct pcap_pkthdr *,
203   const guchar *);
204 static void get_capture_file_io_error(char *, int, const char *, int, gboolean);
205 static void popup_errmsg(const char *);
206 static void send_errmsg_to_parent(const char *);
207 static float pct(gint, gint);
208 static void stop_capture(int signo);
209
210 typedef struct _loop_data {
211   gboolean       go;           /* TRUE as long as we're supposed to keep capturing */
212   gint           max;          /* Number of packets we're supposed to capture - 0 means infinite */
213   int            err;          /* if non-zero, error seen while capturing */
214   gint           linktype;
215   gint           sync_packets;
216   gboolean       pcap_err;     /* TRUE if error from pcap */
217   gboolean       from_pipe;    /* TRUE if we are capturing data from a pipe */
218   packet_counts  counts;
219   wtap_dumper   *pdh;
220 #ifndef _WIN32
221   gboolean       modified;     /* TRUE if data in the pipe uses modified pcap headers */
222   gboolean       byte_swapped; /* TRUE if data in the pipe is byte swapped */
223   unsigned int   bytes_to_read, bytes_read; /* Used by pipe_dispatch */
224   enum {
225          STATE_EXPECT_REC_HDR, STATE_READ_REC_HDR,
226          STATE_EXPECT_DATA,     STATE_READ_DATA
227        } pipe_state;
228
229   enum { PIPOK, PIPEOF, PIPERR, PIPNEXIST } pipe_err;
230 #endif
231 } loop_data;
232
233 #ifndef _WIN32
234 static void adjust_header(loop_data *, struct pcap_hdr *, struct pcaprec_hdr *);
235 static int pipe_open_live(char *, struct pcap_hdr *, loop_data *, char *, int);
236 static int pipe_dispatch(int, loop_data *, struct pcap_hdr *, \
237                 struct pcaprec_modified_hdr *, guchar *, char *, int);
238 #endif
239
240 /* Win32 needs the O_BINARY flag for open() */
241 #ifndef O_BINARY
242 #define O_BINARY        0
243 #endif
244
245 #ifdef _WIN32
246 /* Win32 needs a handle to the child capture process */
247 int child_process;
248 #endif
249
250 /* Add a string pointer to a NULL-terminated array of string pointers. */
251 static char **
252 add_arg(char **args, int *argc, char *arg)
253 {
254   /* Grow the array; "*argc" currently contains the number of string
255      pointers, *not* counting the NULL pointer at the end, so we have
256      to add 2 in order to get the new size of the array, including the
257      new pointer and the terminating NULL pointer. */
258   args = g_realloc(args, (*argc + 2) * sizeof (char *));
259
260   /* Stuff the pointer into the penultimate element of the array, which
261      is the one at the index specified by "*argc". */
262   args[*argc] = arg;
263
264   /* Now bump the count. */
265   (*argc)++;
266
267   /* We overwrite the NULL pointer; put it back right after the
268      element we added. */
269   args[*argc] = NULL;
270
271   return args;
272 }
273
274 #ifdef _WIN32
275 /* Given a string, return a pointer to a quote-encapsulated version of
276    the string, so we can pass it as an argument with "spawnvp" even
277    if it contains blanks. */
278 char *
279 quote_encapsulate(const char *string)
280 {
281   char *encapsulated_string;
282
283   encapsulated_string = g_new(char, strlen(string) + 3);
284   sprintf(encapsulated_string, "\"%s\"", string);
285   return encapsulated_string;
286 }
287 #endif
288
289 /* Open a specified file, or create a temporary file, and start a capture
290    to the file in question. */
291 void
292 do_capture(char *capfile_name)
293 {
294   char tmpname[128+1];
295   gboolean is_tempfile;
296   guchar c;
297   int i;
298   guint byte_count;
299   char *msg;
300   int err;
301   int capture_succeeded;
302   gboolean stats_known;
303   struct pcap_stat stats;
304
305   if (capfile_name != NULL) {
306     if (capture_opts.ringbuffer_on) {
307       /* ringbuffer is enabled */
308       cfile.save_file_fd = ringbuf_init(capfile_name,
309                                         capture_opts.ringbuffer_num_files);
310     } else {
311       /* Try to open/create the specified file for use as a capture buffer. */
312       cfile.save_file_fd = open(capfile_name, O_RDWR|O_BINARY|O_TRUNC|O_CREAT,
313                                 0600);
314     }
315     is_tempfile = FALSE;
316   } else {
317     /* Choose a random name for the capture buffer */
318     cfile.save_file_fd = create_tempfile(tmpname, sizeof tmpname, "ether");
319     capfile_name = g_strdup(tmpname);
320     is_tempfile = TRUE;
321   }
322   if (cfile.save_file_fd == -1) {
323     if (is_tempfile) {
324       simple_dialog(ESD_TYPE_CRIT, NULL,
325         "The temporary file to which the capture would be saved (\"%s\")"
326         "could not be opened: %s.", capfile_name, strerror(errno));
327     } else {
328       if (capture_opts.ringbuffer_on) {
329         ringbuf_error_cleanup();
330       }
331       simple_dialog(ESD_TYPE_CRIT, NULL,
332         file_open_error_message(errno, TRUE, WTAP_FILE_PCAP), capfile_name);
333     }
334     return;
335   }
336   close_cap_file(&cfile);
337   g_assert(cfile.save_file == NULL);
338   cfile.save_file = capfile_name;
339
340   if (capture_opts.sync_mode) { /* do the capture in a child process */
341     char ssnap[24];
342     char scount[24];                    /* need a constant for len of numbers */
343     char sautostop_filesize[24];        /* need a constant for len of numbers */
344     char sautostop_duration[24];        /* need a constant for len of numbers */
345     char save_file_fd[24];
346     char errmsg[1024+1];
347     int error;
348     int argc;
349     char **argv;
350 #ifdef _WIN32
351     char sync_pipe_fd[24];
352     char *fontstring;
353     char *filterstring;
354 #endif
355
356     /* Allocate the string pointer array with enough space for the
357        terminating NULL pointer. */
358     argc = 0;
359     argv = g_malloc(sizeof (char *));
360     *argv = NULL;
361
362     /* Now add those arguments used on all platforms. */
363     argv = add_arg(argv, &argc, CHILD_NAME);
364
365     argv = add_arg(argv, &argc, "-i");
366     argv = add_arg(argv, &argc, cfile.iface);
367
368     argv = add_arg(argv, &argc, "-w");
369     argv = add_arg(argv, &argc, cfile.save_file);
370
371     argv = add_arg(argv, &argc, "-W");
372     sprintf(save_file_fd,"%d",cfile.save_file_fd);      /* in lieu of itoa */
373     argv = add_arg(argv, &argc, save_file_fd);
374
375     if (capture_opts.has_autostop_count) {
376       argv = add_arg(argv, &argc, "-c");
377       sprintf(scount,"%d",capture_opts.autostop_count);
378       argv = add_arg(argv, &argc, scount);
379     }
380
381     if (capture_opts.has_snaplen) {
382       argv = add_arg(argv, &argc, "-s");
383       sprintf(ssnap,"%d",capture_opts.snaplen);
384       argv = add_arg(argv, &argc, ssnap);
385     }
386
387     if (capture_opts.has_autostop_filesize) {
388       argv = add_arg(argv, &argc, "-a");
389       sprintf(sautostop_filesize,"filesize:%d",capture_opts.autostop_filesize);
390       argv = add_arg(argv, &argc, sautostop_filesize);
391     }
392
393     if (capture_opts.has_autostop_duration) {
394       argv = add_arg(argv, &argc, "-a");
395       sprintf(sautostop_duration,"duration:%d",capture_opts.autostop_duration);
396       argv = add_arg(argv, &argc, sautostop_duration);
397     }
398
399     if (!capture_opts.promisc_mode)
400       argv = add_arg(argv, &argc, "-p");
401
402 #ifdef _WIN32
403     /* Create a pipe for the child process */
404
405     if(_pipe(sync_pipe, 512, O_BINARY) < 0) {
406       /* Couldn't create the pipe between parent and child. */
407       error = errno;
408       unlink(cfile.save_file);
409       g_free(cfile.save_file);
410       cfile.save_file = NULL;
411       simple_dialog(ESD_TYPE_CRIT, NULL, "Couldn't create sync pipe: %s",
412                         strerror(error));
413       return;
414     }
415
416     /* Convert font name to a quote-encapsulated string and pass to child */
417     argv = add_arg(argv, &argc, "-m");
418     fontstring = quote_encapsulate(prefs.gui_font_name);
419     argv = add_arg(argv, &argc, fontstring);
420
421     /* Convert pipe write handle to a string and pass to child */
422     argv = add_arg(argv, &argc, "-Z");
423     itoa(sync_pipe[WRITE], sync_pipe_fd, 10);
424     argv = add_arg(argv, &argc, sync_pipe_fd);
425
426     /* Convert filter string to a quote delimited string and pass to child */
427     if (cfile.cfilter != NULL && strlen(cfile.cfilter) != 0) {
428       argv = add_arg(argv, &argc, "-f");
429       filterstring = quote_encapsulate(cfile.cfilter);
430       argv = add_arg(argv, &argc, filterstring);
431     }
432
433     /* Spawn process */
434     fork_child = spawnvp(_P_NOWAIT, ethereal_path, argv);
435     g_free(fontstring);
436     g_free(filterstring);
437     /* Keep a copy for later evaluation by _cwait() */
438     child_process = fork_child;
439 #else
440     signal(SIGCHLD, SIG_IGN);
441     if (pipe(sync_pipe) < 0) {
442       /* Couldn't create the pipe between parent and child. */
443       error = errno;
444       unlink(cfile.save_file);
445       g_free(cfile.save_file);
446       cfile.save_file = NULL;
447       simple_dialog(ESD_TYPE_CRIT, NULL, "Couldn't create sync pipe: %s",
448                         strerror(error));
449       return;
450     }
451
452     argv = add_arg(argv, &argc, "-m");
453     argv = add_arg(argv, &argc, prefs.gui_font_name);
454
455     if (cfile.cfilter != NULL && strlen(cfile.cfilter) != 0) {
456       argv = add_arg(argv, &argc, "-f");
457       argv = add_arg(argv, &argc, cfile.cfilter);
458     }
459
460     if ((fork_child = fork()) == 0) {
461       /*
462        * Child process - run Ethereal with the right arguments to make
463        * it just pop up the live capture dialog box and capture with
464        * the specified capture parameters, writing to the specified file.
465        *
466        * args: -i interface specification
467        * -w file to write
468        * -W file descriptor to write
469        * -c count to capture
470        * -s snaplen
471        * -m / -b fonts
472        * -f "filter expression"
473        */
474       close(1);
475       dup(sync_pipe[WRITE]);
476       close(sync_pipe[READ]);
477       execvp(ethereal_path, argv);
478       snprintf(errmsg, sizeof errmsg, "Couldn't run %s in child process: %s",
479                 ethereal_path, strerror(errno));
480       send_errmsg_to_parent(errmsg);
481
482       /* Exit with "_exit()", so that we don't close the connection
483          to the X server (and cause stuff buffered up by our parent but
484          not yet sent to be sent, as that stuff should only be sent by
485          our parent). */
486       _exit(2);
487     }
488 #endif
489
490     /* Parent process - read messages from the child process over the
491        sync pipe. */
492     g_free(argv);       /* free up arg array */
493
494     /* Close the write side of the pipe, so that only the child has it
495        open, and thus it completely closes, and thus returns to us
496        an EOF indication, if the child closes it (either deliberately
497        or by exiting abnormally). */
498     close(sync_pipe[WRITE]);
499
500     /* Close the save file FD, as we won't be using it - we'll be opening
501        it and reading the save file through Wiretap. */
502     close(cfile.save_file_fd);
503
504     if (fork_child == -1) {
505       /* We couldn't even create the child process. */
506       error = errno;
507       close(sync_pipe[READ]);
508       unlink(cfile.save_file);
509       g_free(cfile.save_file);
510       cfile.save_file = NULL;
511       simple_dialog(ESD_TYPE_CRIT, NULL, "Couldn't create child process: %s",
512                         strerror(error));
513       return;
514     }
515
516     /* Read a byte count from "sync_pipe[READ]", terminated with a
517        colon; if the count is 0, the child process created the
518        capture file and we should start reading from it, otherwise
519        the capture couldn't start and the count is a count of bytes
520        of error message, and we should display the message. */
521     byte_count = 0;
522     for (;;) {
523       i = read(sync_pipe[READ], &c, 1);
524       if (i == 0) {
525         /* EOF - the child process died.
526            Close the read side of the sync pipe, remove the capture file,
527            and report the failure. */
528         close(sync_pipe[READ]);
529         unlink(cfile.save_file);
530         g_free(cfile.save_file);
531         cfile.save_file = NULL;
532         wait_for_child(TRUE);
533         return;
534       }
535       if (c == SP_CAPSTART || c == SP_ERROR_MSG)
536         break;
537       if (!isdigit(c)) {
538         /* Child process handed us crap.
539            Close the read side of the sync pipe, remove the capture file,
540            and report the failure. */
541         close(sync_pipe[READ]);
542         unlink(cfile.save_file);
543         g_free(cfile.save_file);
544         cfile.save_file = NULL;
545         simple_dialog(ESD_TYPE_WARN, NULL,
546                         "Capture child process sent us a bad message");
547         return;
548       }
549       byte_count = byte_count*10 + c - '0';
550     }
551     if (c == SP_CAPSTART) {
552       /* Success.  Open the capture file, and set up to read it. */
553       err = start_tail_cap_file(cfile.save_file, is_tempfile, &cfile);
554       if (err == 0) {
555         /* We were able to open and set up to read the capture file;
556            arrange that our callback be called whenever it's possible
557            to read from the sync pipe, so that it's called when
558            the child process wants to tell us something. */
559 #ifdef _WIN32
560         /* Tricky to use pipes in win9x, as no concept of wait.  NT can
561            do this but that doesn't cover all win32 platforms.  GTK can do
562            this but doesn't seem to work over processes.  Attempt to do
563            something similar here, start a timer and check for data on every
564            timeout. */
565         cap_timer_id = gtk_timeout_add(1000, cap_timer_cb, NULL);
566 #else
567         cap_input_id = gtk_input_add_full(sync_pipe[READ],
568                                        GDK_INPUT_READ|GDK_INPUT_EXCEPTION,
569                                        cap_file_input_cb,
570                                        NULL,
571                                        (gpointer) &cfile,
572                                        NULL);
573 #endif
574       } else {
575         /* We weren't able to open the capture file; user has been
576            alerted. Close the sync pipe. */
577
578         close(sync_pipe[READ]);
579
580         /* Don't unlink the save file - leave it around, for debugging
581            purposes. */
582         g_free(cfile.save_file);
583         cfile.save_file = NULL;
584       }
585     } else {
586       /* Failure - the child process sent us a message indicating
587          what the problem was. */
588       if (byte_count == 0) {
589         /* Zero-length message? */
590         simple_dialog(ESD_TYPE_WARN, NULL,
591                 "Capture child process failed, but its error message was empty.");
592       } else {
593         msg = g_malloc(byte_count + 1);
594         if (msg == NULL) {
595           simple_dialog(ESD_TYPE_WARN, NULL,
596                 "Capture child process failed, but its error message was too big.");
597         } else {
598           i = read(sync_pipe[READ], msg, byte_count);
599           msg[byte_count] = '\0';
600           if (i < 0) {
601             simple_dialog(ESD_TYPE_WARN, NULL,
602                   "Capture child process failed: Error %s reading its error message.",
603                   strerror(errno));
604           } else if (i == 0) {
605             simple_dialog(ESD_TYPE_WARN, NULL,
606                   "Capture child process failed: EOF reading its error message.");
607             wait_for_child(FALSE);
608           } else
609             simple_dialog(ESD_TYPE_CRIT, NULL, msg);
610           g_free(msg);
611         }
612
613         /* Close the sync pipe. */
614         close(sync_pipe[READ]);
615
616         /* Get rid of the save file - the capture never started. */
617         unlink(cfile.save_file);
618         g_free(cfile.save_file);
619         cfile.save_file = NULL;
620       }
621     }
622   } else {
623     /* Not sync mode. */
624     capture_succeeded = capture(&stats_known, &stats);
625     if (quit_after_cap) {
626       /* DON'T unlink the save file.  Presumably someone wants it. */
627       gtk_exit(0);
628     }
629     if (capture_succeeded) {
630       /* Capture succeeded; read in the capture file. */
631       if ((err = open_cap_file(cfile.save_file, is_tempfile, &cfile)) == 0) {
632         /* Set the read filter to NULL. */
633         cfile.rfcode = NULL;
634
635         /* Get the packet-drop statistics.
636
637            XXX - there are currently no packet-drop statistics stored
638            in libpcap captures, and that's what we're reading.
639
640            At some point, we will add support in Wiretap to return
641            packet-drop statistics for capture file formats that store it,
642            and will make "read_cap_file()" get those statistics from
643            Wiretap.  We clear the statistics (marking them as "not known")
644            in "open_cap_file()", and "read_cap_file()" will only fetch
645            them and mark them as known if Wiretap supplies them, so if
646            we get the statistics now, after calling "open_cap_file()" but
647            before calling "read_cap_file()", the values we store will
648            be used by "read_cap_file()".
649
650            If a future libpcap capture file format stores the statistics,
651            we'll put them into the capture file that we write, and will
652            thus not have to set them here - "read_cap_file()" will get
653            them from the file and use them. */
654         if (stats_known) {
655           cfile.drops_known = TRUE;
656
657           /* XXX - on some systems, libpcap doesn't bother filling in
658              "ps_ifdrop" - it doesn't even set it to zero - so we don't
659              bother looking at it.
660
661              Ideally, libpcap would have an interface that gave us
662              several statistics - perhaps including various interface
663              error statistics - and would tell us which of them it
664              supplies, allowing us to display only the ones it does. */
665           cfile.drops = stats.ps_drop;
666         }
667         switch (read_cap_file(&cfile, &err)) {
668
669         case READ_SUCCESS:
670         case READ_ERROR:
671           /* Just because we got an error, that doesn't mean we were unable
672              to read any of the file; we handle what we could get from the
673              file. */
674           break;
675
676         case READ_ABORTED:
677           /* Exit by leaving the main loop, so that any quit functions
678              we registered get called. */
679           gtk_main_quit();
680           return;
681         }
682       }
683     }
684     /* We're not doing a capture any more, so we don't have a save
685        file. */
686     if (capture_opts.ringbuffer_on) {
687       ringbuf_free();
688     } else {
689       g_free(cfile.save_file);
690     }
691     cfile.save_file = NULL;
692   }
693 }
694
695 #ifdef _WIN32
696 /* The timer has expired, see if there's stuff to read from the pipe,
697    if so call the cap_file_input_cb */
698 static gint
699 cap_timer_cb(gpointer data)
700 {
701   HANDLE handle;
702   DWORD avail = 0;
703   gboolean result, result1;
704   DWORD childstatus;
705
706   /* Oddly enough although Named pipes don't work on win9x,
707      PeekNamedPipe does !!! */
708   handle = (HANDLE) _get_osfhandle (sync_pipe[READ]);
709   result = PeekNamedPipe(handle, NULL, 0, NULL, &avail, NULL);
710
711   /* Get the child process exit status */
712   result1 = GetExitCodeProcess((HANDLE)child_process, &childstatus);
713
714   /* If the Peek returned an error, or there are bytes to be read
715      or the childwatcher thread has terminated then call the normal
716      callback */
717   if (!result || avail > 0 || childstatus != STILL_ACTIVE) {
718
719     /* avoid reentrancy problems and stack overflow */
720     gtk_timeout_remove(cap_timer_id);
721
722     /* And call the real handler */
723     cap_file_input_cb((gpointer) &cfile, 0, 0);
724
725     /* Return false so that the timer is not run again */
726     return FALSE;
727   }
728   else {
729     /* No data so let timer run again */
730     return TRUE;
731   }
732 }
733 #endif
734
735 /* There's stuff to read from the sync pipe, meaning the child has sent
736    us a message, or the sync pipe has closed, meaning the child has
737    closed it (perhaps because it exited). */
738 static void 
739 cap_file_input_cb(gpointer data, gint source _U_,
740   GdkInputCondition condition _U_)
741 {
742   capture_file *cf = (capture_file *)data;
743 #define BUFSIZE 4096
744   char buffer[BUFSIZE+1], *p = buffer, *q = buffer, *msg, *r;
745   int  nread, msglen, chars_to_copy;
746   int  to_read = 0;
747   int  err;
748
749 #ifndef _WIN32
750   /* avoid reentrancy problems and stack overflow */
751   gtk_input_remove(cap_input_id);
752 #endif
753
754   if ((nread = read(sync_pipe[READ], buffer, BUFSIZE)) <= 0) {
755     /* The child has closed the sync pipe, meaning it's not going to be
756        capturing any more packets.  Pick up its exit status, and
757        complain if it did anything other than exit with status 0. */
758     wait_for_child(FALSE);
759       
760     /* Read what remains of the capture file, and finish the capture.
761        XXX - do something if this fails? */
762     switch (finish_tail_cap_file(cf, &err)) {
763
764     case READ_SUCCESS:
765     case READ_ERROR:
766       /* Just because we got an error, that doesn't mean we were unable
767          to read any of the file; we handle what we could get from the
768          file. */
769       break;
770
771     case READ_ABORTED:
772       /* Exit by leaving the main loop, so that any quit functions
773          we registered get called. */
774       gtk_main_quit();
775       return;
776     }
777
778     /* We're not doing a capture any more, so we don't have a save
779        file. */
780     g_free(cf->save_file);
781     cf->save_file = NULL;
782
783     return;
784   }
785
786   buffer[nread] = '\0';
787
788   while (nread != 0) {
789     /* look for (possibly multiple) indications */
790     switch (*q) {
791     case SP_PACKET_COUNT :
792       to_read += atoi(p);
793       p = q + 1;
794       q++;
795       nread--;
796       break;
797     case SP_DROPS :
798       cf->drops_known = TRUE;
799       cf->drops = atoi(p);
800       p = q + 1;
801       q++;
802       nread--;
803       break;
804     case SP_ERROR_MSG :
805       msglen = atoi(p);
806       p = q + 1;
807       q++;
808       nread--;
809
810       /* Read the entire message.
811          XXX - if the child hasn't sent it all yet, this could cause us
812          to hang until they do. */
813       msg = g_malloc(msglen + 1);
814       r = msg;
815       while (msglen != 0) {
816         if (nread == 0) {
817           /* Read more. */
818           if ((nread = read(sync_pipe[READ], buffer, BUFSIZE)) <= 0)
819             break;
820           p = buffer;
821           q = buffer;
822         }
823         chars_to_copy = MIN(msglen, nread);
824         memcpy(r, q, chars_to_copy);
825         r += chars_to_copy;
826         q += chars_to_copy;
827         nread -= chars_to_copy;
828         msglen -= chars_to_copy;
829       }
830       *r = '\0';
831       simple_dialog(ESD_TYPE_CRIT, NULL, msg);
832       g_free(msg);
833       break;
834     default :
835       q++;
836       nread--;
837       break;
838     } 
839   }
840
841   /* Read from the capture file the number of records the child told us
842      it added.
843      XXX - do something if this fails? */
844   switch (continue_tail_cap_file(cf, to_read, &err)) {
845
846   case READ_SUCCESS:
847   case READ_ERROR:
848     /* Just because we got an error, that doesn't mean we were unable
849        to read any of the file; we handle what we could get from the
850        file.
851
852        XXX - abort on a read error? */
853     break;
854
855   case READ_ABORTED:
856     /* Kill the child capture process; the user wants to exit, and we
857        shouldn't just leave it running. */
858 #ifdef _WIN32
859     /* XXX - kill it. */
860 #else
861     kill(fork_child, SIGTERM);  /* SIGTERM so it can clean up if necessary */
862 #endif
863     break;
864   }
865
866   /* restore pipe handler */
867 #ifdef _WIN32
868   cap_timer_id = gtk_timeout_add(1000, cap_timer_cb, NULL);
869 #else
870   cap_input_id = gtk_input_add_full (sync_pipe[READ],
871                                      GDK_INPUT_READ|GDK_INPUT_EXCEPTION,
872                                      cap_file_input_cb,
873                                      NULL,
874                                      (gpointer) cf,
875                                      NULL);
876 #endif
877 }
878
879 static void
880 wait_for_child(gboolean always_report)
881 {
882   int  wstatus;
883
884 #ifdef _WIN32
885   /* XXX - analyze the wait stuatus and display more information
886      in the dialog box? */
887   if (_cwait(&wstatus, child_process, _WAIT_CHILD) == -1) {
888     simple_dialog(ESD_TYPE_WARN, NULL, "Child capture process stopped unexpectedly");
889   }
890 #else
891   if (wait(&wstatus) != -1) {
892     if (WIFEXITED(wstatus)) {
893       /* The child exited; display its exit status, if it's not zero,
894          and even if it's zero if "always_report" is true. */
895       if (always_report || WEXITSTATUS(wstatus) != 0) {
896         simple_dialog(ESD_TYPE_WARN, NULL,
897                       "Child capture process exited: exit status %d",
898                       WEXITSTATUS(wstatus));
899       }
900     } else if (WIFSTOPPED(wstatus)) {
901       /* It stopped, rather than exiting.  "Should not happen." */
902       simple_dialog(ESD_TYPE_WARN, NULL,
903                     "Child capture process stopped: %s",
904                     signame(WSTOPSIG(wstatus)));
905     } else if (WIFSIGNALED(wstatus)) {
906       /* It died with a signal. */
907       simple_dialog(ESD_TYPE_WARN, NULL,
908                     "Child capture process died: %s%s",
909                     signame(WTERMSIG(wstatus)),
910                     WCOREDUMP(wstatus) ? " - core dumped" : "");
911     } else {
912       /* What?  It had to either have exited, or stopped, or died with
913          a signal; what happened here? */
914       simple_dialog(ESD_TYPE_WARN, NULL,
915                     "Child capture process died: wait status %#o", wstatus);
916     }
917   }
918
919   /* No more child process. */
920   fork_child = -1;
921 #endif
922 }
923
924 #ifndef _WIN32
925 static char *
926 signame(int sig)
927 {
928   char *sigmsg;
929   static char sigmsg_buf[6+1+3+1];
930
931   switch (sig) {
932
933   case SIGHUP:
934     sigmsg = "Hangup";
935     break;
936
937   case SIGINT:
938     sigmsg = "Interrupted";
939     break;
940
941   case SIGQUIT:
942     sigmsg = "Quit";
943     break;
944
945   case SIGILL:
946     sigmsg = "Illegal instruction";
947     break;
948
949   case SIGTRAP:
950     sigmsg = "Trace trap";
951     break;
952
953   case SIGABRT:
954     sigmsg = "Abort";
955     break;
956
957   case SIGFPE:
958     sigmsg = "Arithmetic exception";
959     break;
960
961   case SIGKILL:
962     sigmsg = "Killed";
963     break;
964
965   case SIGBUS:
966     sigmsg = "Bus error";
967     break;
968
969   case SIGSEGV:
970     sigmsg = "Segmentation violation";
971     break;
972
973   /* http://metalab.unc.edu/pub/Linux/docs/HOWTO/GCC-HOWTO 
974      Linux is POSIX compliant.  These are not POSIX-defined signals ---
975      ISO/IEC 9945-1:1990 (IEEE Std 1003.1-1990), paragraph B.3.3.1.1 sez:
976
977         ``The signals SIGBUS, SIGEMT, SIGIOT, SIGTRAP, and SIGSYS
978         were omitted from POSIX.1 because their behavior is
979         implementation dependent and could not be adequately catego-
980         rized.  Conforming implementations may deliver these sig-
981         nals, but must document the circumstances under which they
982         are delivered and note any restrictions concerning their
983         delivery.''
984
985      So we only check for SIGSYS on those systems that happen to
986      implement them (a system can be POSIX-compliant and implement
987      them, it's just that POSIX doesn't *require* a POSIX-compliant
988      system to implement them).
989    */
990
991 #ifdef SIGSYS
992   case SIGSYS:
993     sigmsg = "Bad system call";
994     break;
995 #endif
996
997   case SIGPIPE:
998     sigmsg = "Broken pipe";
999     break;
1000
1001   case SIGALRM:
1002     sigmsg = "Alarm clock";
1003     break;
1004
1005   case SIGTERM:
1006     sigmsg = "Terminated";
1007     break;
1008
1009   default:
1010     sprintf(sigmsg_buf, "Signal %d", sig);
1011     sigmsg = sigmsg_buf;
1012     break;
1013   }
1014   return sigmsg;
1015 }
1016 #endif
1017
1018 /*
1019  * Timeout, in milliseconds, for reads from the stream of captured packets.
1020  */
1021 #define CAP_READ_TIMEOUT        250
1022
1023 #ifndef _WIN32
1024 /* Take carre of byte order in the libpcap headers read from pipes.
1025  * (function taken from wiretap/libpcap.c) */
1026 static void
1027 adjust_header(loop_data *ld, struct pcap_hdr *hdr, struct pcaprec_hdr *rechdr)
1028 {
1029   if (ld->byte_swapped) {
1030     /* Byte-swap the record header fields. */
1031     rechdr->ts_sec = BSWAP32(rechdr->ts_sec);
1032     rechdr->ts_usec = BSWAP32(rechdr->ts_usec);
1033     rechdr->incl_len = BSWAP32(rechdr->incl_len);
1034     rechdr->orig_len = BSWAP32(rechdr->orig_len);
1035   }
1036
1037   /* In file format version 2.3, the "incl_len" and "orig_len" fields were
1038      swapped, in order to match the BPF header layout.
1039
1040      Unfortunately, some files were, according to a comment in the "libpcap"
1041      source, written with version 2.3 in their headers but without the
1042      interchanged fields, so if "incl_len" is greater than "orig_len" - which
1043      would make no sense - we assume that we need to swap them.  */
1044   if (hdr->version_major == 2 &&
1045       (hdr->version_minor < 3 ||
1046        (hdr->version_minor == 3 && rechdr->incl_len > rechdr->orig_len))) {
1047     guint32 temp;
1048
1049     temp = rechdr->orig_len;
1050     rechdr->orig_len = rechdr->incl_len;
1051     rechdr->incl_len = temp;
1052   }
1053 }
1054
1055 /* Mimic pcap_open_live() for pipe captures 
1056  * We check if "pipename" is "-" (stdin) or a FIFO, open it, and read the
1057  * header.
1058  * N.B. : we can't read the libpcap formats used in RedHat 6.1 or SuSE 6.3
1059  * because we can't seek on pipes (see wiretap/libpcap.c for details) */
1060 static int
1061 pipe_open_live(char *pipename, struct pcap_hdr *hdr, loop_data *ld,
1062                  char *errmsg, int errmsgl)
1063 {
1064   struct stat pipe_stat;
1065   int         fd;
1066   guint32     magic;
1067   int         b, sel_ret;
1068   unsigned int bytes_read;
1069   fd_set      rfds;
1070   struct timeval timeout;
1071
1072   /*
1073    * XXX Ethereal blocks until we return
1074    */
1075   if (strcmp(pipename, "-") == 0)
1076     fd = 0; /* read from stdin */
1077   else {
1078     if (stat(pipename, &pipe_stat) < 0) {
1079       if (errno == ENOENT || errno == ENOTDIR)
1080         ld->pipe_err = PIPNEXIST;
1081       else {
1082         snprintf(errmsg, errmsgl,
1083           "The capture session could not be initiated "
1084           "due to error on pipe: %s", strerror(errno));
1085         ld->pipe_err = PIPERR;
1086       }
1087       return -1;
1088     }
1089     if (! S_ISFIFO(pipe_stat.st_mode)) {
1090       if (S_ISCHR(pipe_stat.st_mode)) {
1091         /*
1092          * Assume the user specified an interface on a system where
1093          * interfaces are in /dev.  Pretend we haven't seen it.
1094          */
1095          ld->pipe_err = PIPNEXIST;
1096       } else {
1097         snprintf(errmsg, errmsgl,
1098             "The capture session could not be initiated because\n"
1099             "\"%s\" is neither an interface nor a pipe", pipename);
1100         ld->pipe_err = PIPERR;
1101       }
1102       return -1;
1103     }
1104     fd = open(pipename, O_RDONLY | O_NONBLOCK);
1105     if (fd == -1) {
1106       snprintf(errmsg, errmsgl,
1107           "The capture session could not be initiated "
1108           "due to error on pipe open: %s", strerror(errno));
1109       ld->pipe_err = PIPERR;
1110       return -1;
1111     }
1112   }
1113
1114   ld->from_pipe = TRUE;
1115
1116   /* read the pcap header */
1117   FD_ZERO(&rfds);
1118   bytes_read = 0;
1119   while (bytes_read < sizeof magic) {
1120     FD_SET(fd, &rfds);
1121     timeout.tv_sec = 0;
1122     timeout.tv_usec = CAP_READ_TIMEOUT*1000;
1123     sel_ret = select(fd+1, &rfds, NULL, NULL, &timeout);
1124     if (sel_ret < 0) {
1125       snprintf(errmsg, errmsgl,
1126         "Unexpected error from select: %s", strerror(errno));
1127       goto error;
1128     } else if (sel_ret > 0) {
1129       b = read(fd, &magic+bytes_read, sizeof magic-bytes_read);
1130       if (b <= 0) {
1131         if (b == 0)
1132           snprintf(errmsg, errmsgl, "End of file on pipe during open");
1133         else
1134           snprintf(errmsg, errmsgl, "Error on pipe during open: %s",
1135             strerror(errno));
1136         goto error;
1137       }
1138       bytes_read += b;
1139     }
1140   }
1141
1142   switch (magic) {
1143   case PCAP_MAGIC:
1144     /* Host that wrote it has our byte order, and was running
1145        a program using either standard or ss990417 libpcap. */
1146     ld->byte_swapped = FALSE;
1147     ld->modified = FALSE;
1148     break;
1149   case PCAP_MODIFIED_MAGIC:
1150     /* Host that wrote it has our byte order, but was running
1151        a program using either ss990915 or ss991029 libpcap. */
1152     ld->byte_swapped = FALSE;
1153     ld->modified = TRUE;
1154     break;
1155   case PCAP_SWAPPED_MAGIC:
1156     /* Host that wrote it has a byte order opposite to ours,
1157        and was running a program using either standard or
1158        ss990417 libpcap. */
1159     ld->byte_swapped = TRUE;
1160     ld->modified = FALSE;
1161     break;
1162   case PCAP_SWAPPED_MODIFIED_MAGIC:
1163     /* Host that wrote it out has a byte order opposite to
1164        ours, and was running a program using either ss990915
1165        or ss991029 libpcap. */
1166     ld->byte_swapped = TRUE;
1167     ld->modified = TRUE;
1168     break;
1169   default:
1170     /* Not a "libpcap" type we know about. */
1171     snprintf(errmsg, errmsgl, "Unrecognized libpcap format");
1172     goto error;
1173   }
1174
1175   /* Read the rest of the header */
1176   bytes_read = 0;
1177   while (bytes_read < sizeof(struct pcap_hdr)) {
1178     FD_SET(fd, &rfds);
1179     timeout.tv_sec = 0;
1180     timeout.tv_usec = CAP_READ_TIMEOUT*1000;
1181     sel_ret = select(fd+1, &rfds, NULL, NULL, &timeout);
1182     if (sel_ret < 0) {
1183       snprintf(errmsg, errmsgl,
1184         "Unexpected error from select: %s", strerror(errno));
1185       goto error;
1186     } else if (sel_ret > 0) {
1187       b = read(fd, ((char *)hdr)+bytes_read,
1188             sizeof(struct pcap_hdr) - bytes_read);
1189       if (b <= 0) {
1190         if (b == 0)
1191           snprintf(errmsg, errmsgl, "End of file on pipe during open");
1192         else
1193           snprintf(errmsg, errmsgl, "Error on pipe during open: %s",
1194             strerror(errno));
1195         goto error;
1196       }
1197       bytes_read += b;
1198     }
1199   }
1200
1201   if (ld->byte_swapped) {
1202     /* Byte-swap the header fields about which we care. */
1203     hdr->version_major = BSWAP16(hdr->version_major);
1204     hdr->version_minor = BSWAP16(hdr->version_minor);
1205     hdr->snaplen = BSWAP32(hdr->snaplen);
1206     hdr->network = BSWAP32(hdr->network);
1207   }
1208
1209   if (hdr->version_major < 2) {
1210     snprintf(errmsg, errmsgl, "Unable to read old libpcap format");
1211     goto error;
1212   }
1213
1214   ld->pipe_state = STATE_EXPECT_REC_HDR;
1215   ld->pipe_err = PIPOK;
1216   return fd;
1217
1218 error:
1219   ld->pipe_err = PIPERR;
1220   close(fd);
1221   return -1;
1222
1223 }
1224
1225 /* We read one record from the pipe, take care of byte order in the record
1226  * header, write the record in the capture file, and update capture statistics. */
1227
1228 static int
1229 pipe_dispatch(int fd, loop_data *ld, struct pcap_hdr *hdr,
1230                 struct pcaprec_modified_hdr *rechdr, guchar *data,
1231                 char *errmsg, int errmsgl)
1232 {
1233   struct pcap_pkthdr phdr;
1234   int b;
1235   enum { PD_REC_HDR_READ, PD_DATA_READ, PD_PIPE_EOF, PD_PIPE_ERR,
1236           PD_ERR } result;
1237
1238   switch (ld->pipe_state) {
1239
1240   case STATE_EXPECT_REC_HDR:
1241     ld->bytes_to_read = ld->modified ?
1242       sizeof(struct pcaprec_modified_hdr) : sizeof(struct pcaprec_hdr);
1243     ld->bytes_read = 0;
1244     ld->pipe_state = STATE_READ_REC_HDR;
1245     /* Fall through */
1246
1247   case STATE_READ_REC_HDR:
1248     b = read(fd, ((char *)rechdr)+ld->bytes_read,
1249       ld->bytes_to_read - ld->bytes_read);
1250     if (b <= 0) {
1251       if (b == 0)
1252         result = PD_PIPE_EOF;
1253       else
1254         result = PD_PIPE_ERR;
1255       break;
1256     }
1257     if ((ld->bytes_read += b) < ld->bytes_to_read)
1258         return 0;
1259     result = PD_REC_HDR_READ;
1260     break;
1261
1262   case STATE_EXPECT_DATA:
1263     ld->bytes_read = 0;
1264     ld->pipe_state = STATE_READ_DATA;
1265     /* Fall through */
1266
1267   case STATE_READ_DATA:
1268     b = read(fd, data+ld->bytes_read, rechdr->hdr.incl_len - ld->bytes_read);
1269     if (b <= 0) {
1270       if (b == 0)
1271         result = PD_PIPE_EOF;
1272       else
1273         result = PD_PIPE_ERR;
1274       break;
1275     }
1276     if ((ld->bytes_read += b) < rechdr->hdr.incl_len)
1277       return 0;
1278     result = PD_DATA_READ;
1279     break;
1280
1281   default:
1282     snprintf(errmsg, errmsgl, "pipe_dispatch: invalid state");
1283     result = PD_ERR;
1284
1285   } /* switch (ld->pipe_state) */
1286
1287   /*
1288    * We've now read as much data as we were expecting, so process it.
1289    */
1290   switch (result) {
1291
1292   case PD_REC_HDR_READ:
1293     /* We've read the header. Take care of byte order. */
1294     adjust_header(ld, hdr, &rechdr->hdr);
1295     if (rechdr->hdr.incl_len > WTAP_MAX_PACKET_SIZE) {
1296       snprintf(errmsg, errmsgl, "Frame %u too long (%d bytes)",
1297         ld->counts.total+1, rechdr->hdr.incl_len);
1298       break;
1299     }
1300     ld->pipe_state = STATE_EXPECT_DATA;
1301     return 0;
1302
1303   case PD_DATA_READ:
1304     /* Fill in a "struct pcap_pkthdr", and process the packet. */
1305     phdr.ts.tv_sec = rechdr->hdr.ts_sec;
1306     phdr.ts.tv_usec = rechdr->hdr.ts_usec;
1307     phdr.caplen = rechdr->hdr.incl_len;
1308     phdr.len = rechdr->hdr.orig_len;
1309   
1310     capture_pcap_cb((guchar *)ld, &phdr, data);
1311   
1312     ld->pipe_state = STATE_EXPECT_REC_HDR;
1313     return 1;
1314
1315   case PD_PIPE_EOF:
1316     ld->pipe_err = PIPEOF;
1317     return -1;
1318
1319   case PD_PIPE_ERR:
1320     snprintf(errmsg, errmsgl, "Error reading from pipe: %s",
1321       strerror(errno));
1322     /* Fall through */
1323   case PD_ERR:
1324     break;
1325   }
1326
1327   ld->pipe_err = PIPERR;
1328   /* Return here rather than inside the switch to prevent GCC warning */
1329   return -1;
1330 }
1331 #endif
1332
1333 /*
1334  * This needs to be static, so that the SIGUSR1 handler can clear the "go"
1335  * flag.
1336  */
1337 static loop_data   ld;
1338
1339 /* Do the low-level work of a capture.
1340    Returns TRUE if it succeeds, FALSE otherwise. */
1341 int
1342 capture(gboolean *stats_known, struct pcap_stat *stats)
1343 {
1344   GtkWidget  *cap_w, *main_vb, *stop_bt, *counts_tb;
1345   pcap_t     *pch;
1346   int         pcap_encap;
1347   int         file_snaplen;
1348   gchar       open_err_str[PCAP_ERRBUF_SIZE];
1349   gchar       lookup_net_err_str[PCAP_ERRBUF_SIZE];
1350   gchar       label_str[64];
1351   bpf_u_int32 netnum, netmask;
1352   struct bpf_program fcode;
1353   time_t      upd_time, cur_time;
1354   int         err, inpkts;
1355   condition  *cnd_stop_capturesize = NULL;
1356   condition  *cnd_stop_timeout = NULL;
1357   unsigned int i;
1358   static const char capstart_msg = SP_CAPSTART;
1359   char        errmsg[4096+1];
1360   gboolean    dump_ok;
1361   fd_set      set1;
1362   struct timeval timeout;
1363   struct {
1364       const gchar *title;
1365       gint *value_ptr;
1366       GtkWidget *label, *value, *percent;
1367   } counts[] = {
1368       { "Total", &ld.counts.total, NULL, NULL, NULL },
1369       { "SCTP", &ld.counts.sctp, NULL, NULL, NULL },
1370       { "TCP", &ld.counts.tcp, NULL, NULL, NULL },
1371       { "UDP", &ld.counts.udp, NULL, NULL, NULL },
1372       { "ICMP", &ld.counts.icmp, NULL, NULL, NULL },
1373       { "OSPF", &ld.counts.ospf, NULL, NULL, NULL },
1374       { "GRE", &ld.counts.gre, NULL, NULL, NULL },
1375       { "NetBIOS", &ld.counts.netbios, NULL, NULL, NULL },
1376       { "IPX", &ld.counts.ipx, NULL, NULL, NULL },
1377       { "VINES", &ld.counts.vines, NULL, NULL, NULL },
1378       { "Other", &ld.counts.other, NULL, NULL, NULL }
1379   };
1380
1381 #define N_COUNTS (sizeof counts / sizeof counts[0])
1382
1383 #ifdef _WIN32 
1384   WORD wVersionRequested; 
1385   WSADATA wsaData; 
1386 #else
1387   static const char ppamsg[] = "can't find PPA for ";
1388   char       *libpcap_warn;
1389   int         sel_ret;
1390   int         pipe_fd = -1;
1391   struct pcap_hdr hdr;
1392   struct pcaprec_modified_hdr rechdr;
1393   guchar pcap_data[WTAP_MAX_PACKET_SIZE];
1394 #endif
1395 #ifdef MUST_DO_SELECT
1396   int         pcap_fd = 0;
1397 #endif
1398
1399 /* Size of buffer to hold decimal representation of
1400    signed/unsigned 64-bit int */
1401 #define DECISIZE 20
1402
1403   /* Initialize Windows Socket if we are in a WIN32 OS 
1404      This needs to be done before querying the interface for network/netmask */
1405 #ifdef _WIN32 
1406   wVersionRequested = MAKEWORD( 1, 1 ); 
1407   err = WSAStartup( wVersionRequested, &wsaData ); 
1408   if (err!=0) { 
1409     snprintf(errmsg, sizeof errmsg, 
1410       "Couldn't initialize Windows Sockets."); 
1411         pch=NULL; 
1412     goto error; 
1413   } 
1414 #endif 
1415
1416   ld.go             = TRUE;
1417   ld.counts.total   = 0;
1418   if (capture_opts.has_autostop_count)
1419     ld.max          = capture_opts.autostop_count;
1420   else
1421     ld.max          = 0;        /* no limit */
1422   ld.err            = 0;        /* no error seen yet */
1423   ld.linktype       = WTAP_ENCAP_UNKNOWN;
1424   ld.pcap_err       = FALSE;
1425   ld.from_pipe      = FALSE;
1426   ld.sync_packets   = 0;
1427   ld.counts.sctp    = 0;
1428   ld.counts.tcp     = 0;
1429   ld.counts.udp     = 0;
1430   ld.counts.icmp    = 0;
1431   ld.counts.ospf    = 0;
1432   ld.counts.gre     = 0;
1433   ld.counts.ipx     = 0;
1434   ld.counts.netbios = 0;
1435   ld.counts.vines   = 0;
1436   ld.counts.other   = 0;
1437   ld.pdh            = NULL;
1438
1439   /* We haven't yet gotten the capture statistics. */
1440   *stats_known      = FALSE;
1441
1442   /* Open the network interface to capture from it.
1443      Some versions of libpcap may put warnings into the error buffer
1444      if they succeed; to tell if that's happened, we have to clear
1445      the error buffer, and check if it's still a null string.  */
1446   open_err_str[0] = '\0';
1447   pch = pcap_open_live(cfile.iface,
1448                        capture_opts.has_snaplen ? capture_opts.snaplen :
1449                                                   WTAP_MAX_PACKET_SIZE,
1450                        capture_opts.promisc_mode, CAP_READ_TIMEOUT,
1451                        open_err_str);
1452
1453   if (pch == NULL) {
1454 #ifdef _WIN32
1455     /* Well, we couldn't start the capture.
1456        If this is a child process that does the capturing in sync
1457        mode or fork mode, it shouldn't do any UI stuff until we pop up the
1458        capture-progress window, and, since we couldn't start the
1459        capture, we haven't popped it up. */
1460     if (!capture_child) {
1461       while (gtk_events_pending()) gtk_main_iteration();
1462     }
1463
1464     /* On Win32 OSes, the capture devices are probably available to all
1465        users; don't warn about permissions problems.
1466
1467        Do, however, warn that WAN devices aren't supported. */
1468     snprintf(errmsg, sizeof errmsg,
1469         "The capture session could not be initiated (%s).\n"
1470         "Please check that you have the proper interface specified.\n"
1471         "\n"
1472         "Note that the driver Ethereal uses for packet capture on Windows\n"
1473         "doesn't support capturing on PPP/WAN interfaces in Windows NT/2000/XP/.NET Server.\n",
1474         open_err_str);
1475     goto error;
1476 #else
1477     /* try to open cfile.iface as a pipe */
1478     pipe_fd = pipe_open_live(cfile.iface, &hdr, &ld, errmsg, sizeof errmsg);
1479
1480     if (pipe_fd == -1) {
1481
1482       /* If this is a child process that does the capturing in sync
1483        * mode or fork mode, it shouldn't do any UI stuff until we pop up the
1484        * capture-progress window, and, since we couldn't start the
1485        * capture, we haven't popped it up.
1486        */
1487       if (!capture_child) {
1488         while (gtk_events_pending()) gtk_main_iteration();
1489       }
1490
1491       if (ld.pipe_err == PIPNEXIST) {
1492         /* Pipe doesn't exist, so output message for interface */
1493
1494         /* If we got a "can't find PPA for XXX" message, warn the user (who
1495            is running Ethereal on HP-UX) that they don't have a version
1496            of libpcap that properly handles HP-UX (libpcap 0.6.x and later
1497            versions, which properly handle HP-UX, say "can't find /dev/dlpi
1498            PPA for XXX" rather than "can't find PPA for XXX"). */
1499         if (strncmp(open_err_str, ppamsg, sizeof ppamsg - 1) == 0)
1500           libpcap_warn =
1501             "\n\n"
1502             "You are running Ethereal with a version of the libpcap library\n"
1503             "that doesn't handle HP-UX network devices well; this means that\n"
1504             "Ethereal may not be able to capture packets.\n"
1505             "\n"
1506             "To fix this, you should install libpcap 0.6.2, or a later version\n"
1507             "of libpcap, rather than libpcap 0.4 or 0.5.x.  It is available in\n"
1508             "packaged binary form from the Software Porting And Archive Centre\n"
1509             "for HP-UX; the Centre is at http://hpux.connect.org.uk/ - the page\n"
1510             "at the URL lists a number of mirror sites.";
1511         else
1512           libpcap_warn = "";
1513         snprintf(errmsg, sizeof errmsg,
1514           "The capture session could not be initiated (%s).\n"
1515           "Please check to make sure you have sufficient permissions, and that\n"
1516           "you have the proper interface or pipe specified.%s", open_err_str,
1517           libpcap_warn);
1518       }
1519       /*
1520        * Else pipe (or file) does exist and pipe_open_live() has
1521        * filled in errmsg
1522        */
1523       goto error;
1524     } else
1525       /* pipe_open_live() succeeded; don't want
1526          error message from pcap_open_live() */
1527       open_err_str[0] = '\0';
1528 #endif
1529   }
1530
1531   /* capture filters only work on real interfaces */
1532   if (cfile.cfilter && !ld.from_pipe) {
1533     /* A capture filter was specified; set it up. */
1534     if (pcap_lookupnet(cfile.iface, &netnum, &netmask, lookup_net_err_str) < 0) {
1535       /*
1536        * Well, we can't get the netmask for this interface; it's used
1537        * only for filters that check for broadcast IP addresses, so
1538        * we just punt and use 0.  It might be nice to warn the user,
1539        * but that's a pain in a GUI application, as it'd involve popping
1540        * up a message box, and it's not clear how often this would make
1541        * a difference (only filters that check for IP broadcast addresses
1542        * use the netmask).
1543        */
1544       netmask = 0;
1545     }
1546     if (pcap_compile(pch, &fcode, cfile.cfilter, 1, netmask) < 0) {
1547       snprintf(errmsg, sizeof errmsg, "Unable to parse filter string (%s).",
1548         pcap_geterr(pch));
1549       goto error;
1550     }
1551     if (pcap_setfilter(pch, &fcode) < 0) {
1552       snprintf(errmsg, sizeof errmsg, "Can't install filter (%s).",
1553         pcap_geterr(pch));
1554       goto error;
1555     }
1556   }
1557
1558   /* Set up to write to the capture file. */
1559 #ifndef _WIN32
1560   if (ld.from_pipe) {
1561     pcap_encap = hdr.network;
1562     file_snaplen = hdr.snaplen;
1563   } else
1564 #endif
1565   {
1566     pcap_encap = get_pcap_linktype(pch, cfile.iface);
1567     file_snaplen = pcap_snapshot(pch);
1568   }
1569   ld.linktype = wtap_pcap_encap_to_wtap_encap(pcap_encap);
1570   if (ld.linktype == WTAP_ENCAP_UNKNOWN) {
1571     snprintf(errmsg, sizeof errmsg,
1572         "The network you're capturing from is of a type"
1573         " that Ethereal doesn't support (data link type %d).", pcap_encap);
1574     goto error;
1575   }
1576   if (capture_opts.ringbuffer_on) {
1577     ld.pdh = ringbuf_init_wtap_dump_fdopen(WTAP_FILE_PCAP, ld.linktype, 
1578       file_snaplen, &err);
1579   } else {
1580     ld.pdh = wtap_dump_fdopen(cfile.save_file_fd, WTAP_FILE_PCAP,
1581       ld.linktype, file_snaplen, &err);
1582   }
1583
1584   if (ld.pdh == NULL) {
1585     /* We couldn't set up to write to the capture file. */
1586     switch (err) {
1587
1588     case WTAP_ERR_CANT_OPEN:
1589       strcpy(errmsg, "The file to which the capture would be saved"
1590                " couldn't be created for some unknown reason.");
1591       break;
1592
1593     case WTAP_ERR_SHORT_WRITE:
1594       strcpy(errmsg, "A full header couldn't be written to the file"
1595                " to which the capture would be saved.");
1596       break;
1597
1598     default:
1599       if (err < 0) {
1600         snprintf(errmsg, sizeof(errmsg),
1601                      "The file to which the capture would be"
1602                      " saved (\"%s\") could not be opened: Error %d.",
1603                         cfile.save_file, err);
1604       } else {
1605         snprintf(errmsg, sizeof(errmsg),
1606                      "The file to which the capture would be"
1607                      " saved (\"%s\") could not be opened: %s.",
1608                         cfile.save_file, strerror(err));
1609       }
1610       break;
1611     }
1612     goto error;
1613   }
1614
1615   /* Does "open_err_str" contain a non-empty string?  If so, "pcap_open_live()"
1616      returned a warning; print it, but keep capturing. */
1617   if (open_err_str[0] != '\0')
1618     g_warning("%s.", open_err_str);
1619
1620   /* XXX - capture SIGTERM and close the capture, in case we're on a
1621      Linux 2.0[.x] system and you have to explicitly close the capture
1622      stream in order to turn promiscuous mode off?  We need to do that
1623      in other places as well - and I don't think that works all the
1624      time in any case, due to libpcap bugs. */
1625
1626   if (capture_child) {
1627     /* Well, we should be able to start capturing.
1628
1629        This is the child process for a sync mode capture, so sync out
1630        the capture file, so the header makes it to the file system,
1631        and send a "capture started successfully and capture file created"
1632        message to our parent so that they'll open the capture file and
1633        update its windows to indicate that we have a live capture in
1634        progress. */
1635     fflush(wtap_dump_file(ld.pdh));
1636     write(1, &capstart_msg, 1);
1637   }
1638
1639   cap_w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1640   gtk_window_set_title(GTK_WINDOW(cap_w), "Ethereal: Capture");
1641   gtk_window_set_modal(GTK_WINDOW(cap_w), TRUE);
1642
1643   /* Container for capture display widgets */
1644   main_vb = gtk_vbox_new(FALSE, 1);
1645   gtk_container_border_width(GTK_CONTAINER(main_vb), 5);
1646   gtk_container_add(GTK_CONTAINER(cap_w), main_vb);
1647   gtk_widget_show(main_vb);
1648
1649   /* Individual statistic elements */
1650   counts_tb = gtk_table_new(N_COUNTS, 3, TRUE);
1651   gtk_box_pack_start(GTK_BOX(main_vb), counts_tb, TRUE, TRUE, 3);
1652   gtk_widget_show(counts_tb);
1653
1654   for (i = 0; i < N_COUNTS; i++) {
1655       counts[i].label = gtk_label_new(counts[i].title);
1656       gtk_misc_set_alignment(GTK_MISC(counts[i].label), 0.0f, 0.0f);
1657
1658       counts[i].value = gtk_label_new("0");
1659       gtk_misc_set_alignment(GTK_MISC(counts[i].value), 0.0f, 0.0f);
1660
1661       counts[i].percent = gtk_label_new("0.0%");
1662       gtk_misc_set_alignment(GTK_MISC(counts[i].percent), 0.0f, 0.0f);
1663
1664       gtk_table_attach_defaults(GTK_TABLE(counts_tb),
1665                                 counts[i].label, 0, 1, i, i + 1);
1666
1667       gtk_table_attach(GTK_TABLE(counts_tb),
1668                        counts[i].value,
1669                        1, 2, i, i + 1, 0, 0, 5, 0);
1670
1671       gtk_table_attach_defaults(GTK_TABLE(counts_tb),
1672                                 counts[i].percent, 2, 3, i, i + 1);
1673
1674       gtk_widget_show(counts[i].label);
1675       gtk_widget_show(counts[i].value);
1676       gtk_widget_show(counts[i].percent);
1677   }
1678
1679   /* allow user to either click a stop button, or the close button on
1680         the window to stop a capture in progress. */
1681   stop_bt = gtk_button_new_with_label ("Stop");
1682   gtk_signal_connect(GTK_OBJECT(stop_bt), "clicked",
1683     GTK_SIGNAL_FUNC(capture_stop_cb), (gpointer) &ld);
1684   gtk_signal_connect(GTK_OBJECT(cap_w), "delete_event",
1685         GTK_SIGNAL_FUNC(capture_delete_cb), (gpointer) &ld);
1686   gtk_box_pack_end(GTK_BOX(main_vb), stop_bt, FALSE, FALSE, 3);
1687   GTK_WIDGET_SET_FLAGS(stop_bt, GTK_CAN_DEFAULT);
1688   gtk_widget_grab_default(stop_bt);
1689   GTK_WIDGET_SET_FLAGS(stop_bt, GTK_CAN_DEFAULT);
1690   gtk_widget_grab_default(stop_bt);
1691   gtk_widget_show(stop_bt);
1692
1693   gtk_widget_show(cap_w);
1694
1695   upd_time = time(NULL);
1696 #ifdef MUST_DO_SELECT
1697   if (!ld.from_pipe) pcap_fd = pcap_fileno(pch);
1698 #endif
1699
1700 #ifndef _WIN32
1701   /*
1702    * Catch SIGUSR1, so that we exit cleanly if the parent process
1703    * kills us with it due to the user selecting "Capture->Stop".
1704    */
1705   if (capture_child)
1706     signal(SIGUSR1, stop_capture);
1707 #endif
1708   /* initialize capture stop conditions */ 
1709   init_capture_stop_conditions();
1710   /* create stop conditions */
1711   if (capture_opts.has_autostop_filesize)
1712     cnd_stop_capturesize =
1713         cnd_new(CND_CLASS_CAPTURESIZE,(long)capture_opts.autostop_filesize * 1000); 
1714   if (capture_opts.has_autostop_duration)
1715     cnd_stop_timeout =
1716         cnd_new(CND_CLASS_TIMEOUT,(gint32)capture_opts.autostop_duration);
1717
1718   while (ld.go) {
1719     while (gtk_events_pending()) gtk_main_iteration();
1720
1721 #ifndef _WIN32
1722     if (ld.from_pipe) {
1723       FD_ZERO(&set1);
1724       FD_SET(pipe_fd, &set1);
1725       timeout.tv_sec = 0;
1726       timeout.tv_usec = CAP_READ_TIMEOUT*1000;
1727       sel_ret = select(pipe_fd+1, &set1, NULL, NULL, &timeout);
1728       if (sel_ret <= 0) {
1729         inpkts = 0;
1730         if (sel_ret < 0 && errno != EINTR) {
1731           snprintf(errmsg, sizeof(errmsg),
1732             "Unexpected error from select: %s", strerror(errno));
1733           popup_errmsg(errmsg);
1734           ld.go = FALSE;
1735         }
1736       } else {
1737         /*
1738          * "select()" says we can read from the pipe without blocking
1739          */
1740         inpkts = pipe_dispatch(pipe_fd, &ld, &hdr, &rechdr, pcap_data,
1741           errmsg, sizeof errmsg);
1742         if (inpkts < 0) {
1743           ld.go = FALSE;
1744         }
1745       }
1746     }
1747     else
1748 #endif
1749     {
1750 #ifdef MUST_DO_SELECT
1751       /*
1752        * Sigh.  The semantics of the read timeout argument to
1753        * "pcap_open_live()" aren't particularly well specified by
1754        * the "pcap" man page - at least with the BSD BPF code, the
1755        * intent appears to be, at least in part, a way of cutting
1756        * down the number of reads done on a capture, by blocking
1757        * until the buffer fills or a timer expires - and the Linux
1758        * libpcap doesn't actually support it, so we can't use it
1759        * to break out of the "pcap_dispatch()" every 1/4 of a second
1760        * or so.  Linux's libpcap is not the only libpcap that doesn't
1761        * support the read timeout.
1762        *
1763        * Furthermore, at least on Solaris, the bufmod STREAMS module's
1764        * read timeout won't go off if no data has arrived, i.e. it cannot
1765        * be used to guarantee that a read from a DLPI stream will return
1766        * within a specified amount of time regardless of whether any
1767        * data arrives or not.
1768        *
1769        * Thus, on all platforms other than BSD, we do a "select()" on the
1770        * file descriptor for the capture, with a timeout of CAP_READ_TIMEOUT
1771        * milliseconds, or CAP_READ_TIMEOUT*1000 microseconds.
1772        *
1773        * "select()", on BPF devices, doesn't work as you might expect;
1774        * at least on some versions of some flavors of BSD, the timer
1775        * doesn't start until a read is done, so it won't expire if
1776        * only a "select()" or "poll()" is posted.
1777        */
1778       FD_ZERO(&set1);
1779       FD_SET(pcap_fd, &set1);
1780       timeout.tv_sec = 0;
1781       timeout.tv_usec = CAP_READ_TIMEOUT*1000;
1782       sel_ret = select(pcap_fd+1, &set1, NULL, NULL, &timeout);
1783       if (sel_ret > 0) {
1784         /*
1785          * "select()" says we can read from it without blocking; go for
1786          * it.
1787          */
1788         inpkts = pcap_dispatch(pch, 1, capture_pcap_cb, (guchar *) &ld);
1789         if (inpkts < 0) {
1790           ld.pcap_err = TRUE;
1791           ld.go = FALSE;
1792         }
1793       } else {
1794         inpkts = 0;
1795         if (sel_ret < 0 && errno != EINTR) {
1796           snprintf(errmsg, sizeof(errmsg),
1797             "Unexpected error from select: %s", strerror(errno));
1798           popup_errmsg(errmsg);
1799           ld.go = FALSE;
1800         }
1801       }
1802 #else
1803       inpkts = pcap_dispatch(pch, 1, capture_pcap_cb, (guchar *) &ld);
1804       if (inpkts < 0) {
1805         ld.pcap_err = TRUE;
1806         ld.go = FALSE;
1807       }
1808 #endif
1809     }
1810
1811     if (inpkts > 0) {
1812       ld.sync_packets += inpkts;
1813       /* check capture stop conditons */
1814       if (cnd_stop_capturesize != NULL && cnd_eval(cnd_stop_capturesize, 
1815                     (guint32)wtap_get_bytes_dumped(ld.pdh))){
1816         /* Capture file reached its maximum size. */
1817         if (capture_opts.ringbuffer_on) {
1818           /* Switch to the next ringbuffer file */
1819           if (ringbuf_switch_file(&cfile, &ld.pdh, &ld.err)) {
1820             /* File switch succeeded: reset the condition */
1821             cnd_reset(cnd_stop_capturesize);
1822           } else {
1823             /* File switch failed: stop here */
1824             ld.go = FALSE;
1825             continue;
1826           }
1827         } else {
1828           /* no ringbuffer - just stop */
1829           ld.go = FALSE;
1830         }
1831       }
1832     }
1833
1834     /* Only update once a second so as not to overload slow displays */
1835     cur_time = time(NULL);
1836     if (cur_time > upd_time) {
1837       upd_time = cur_time;
1838
1839       if (ld.sync_packets) {
1840
1841         for (i = 0; i < N_COUNTS; i++) {
1842             snprintf(label_str, sizeof(label_str), "%d",
1843                      *counts[i].value_ptr);
1844   
1845             gtk_label_set(GTK_LABEL(counts[i].value), label_str);
1846   
1847             snprintf(label_str, sizeof(label_str), "(%.1f%%)",
1848                      pct(*counts[i].value_ptr, ld.counts.total));
1849   
1850             gtk_label_set(GTK_LABEL(counts[i].percent), label_str);
1851         }
1852
1853         /* do sync here, too */
1854         fflush(wtap_dump_file(ld.pdh));
1855
1856         if (capture_child) {
1857           /* This is the child process for a sync mode capture, so send
1858              our parent a message saying we've written out "ld.sync_packets"
1859              packets to the capture file. */
1860           char tmp[DECISIZE+1+1];
1861           sprintf(tmp, "%d%c", ld.sync_packets, SP_PACKET_COUNT);
1862           write(1, tmp, strlen(tmp));
1863         }
1864
1865         ld.sync_packets = 0;
1866
1867       }
1868
1869       if (cnd_stop_timeout != NULL && cnd_eval(cnd_stop_timeout)) {
1870         /* The specified capture time has elapsed; stop the capture. */
1871         ld.go = FALSE;
1872       }
1873     }
1874   } /* while (ld.go) */
1875     
1876   /* delete stop conditions */
1877   if (cnd_stop_capturesize != NULL)
1878     cnd_delete(cnd_stop_capturesize);
1879   if (cnd_stop_timeout != NULL)
1880     cnd_delete(cnd_stop_timeout);
1881
1882   if (ld.pcap_err) {
1883     snprintf(errmsg, sizeof(errmsg), "Error while capturing packets: %s",
1884       pcap_geterr(pch));
1885     popup_errmsg(errmsg);
1886 #ifdef _WIN32
1887   }
1888 #else
1889   } else if (ld.from_pipe && ld.pipe_err == PIPERR)
1890       popup_errmsg(errmsg);
1891 #endif
1892
1893   if (ld.err != 0) {
1894     get_capture_file_io_error(errmsg, sizeof(errmsg), cfile.save_file, ld.err,
1895                               FALSE);
1896     popup_errmsg(errmsg);
1897
1898     /* A write failed, so we've already told the user there's a problem;
1899        if the close fails, there's no point in telling them about that
1900        as well. */
1901     if (capture_opts.ringbuffer_on) {
1902       ringbuf_wtap_dump_close(&cfile, &err);
1903     } else {
1904       wtap_dump_close(ld.pdh, &err);
1905     }
1906    } else {
1907     if (capture_opts.ringbuffer_on) {
1908       dump_ok = ringbuf_wtap_dump_close(&cfile, &err);
1909     } else {
1910       dump_ok = wtap_dump_close(ld.pdh, &err);
1911     }
1912     if (!dump_ok) {
1913       get_capture_file_io_error(errmsg, sizeof(errmsg), cfile.save_file, err,
1914                                 TRUE);
1915       popup_errmsg(errmsg);
1916     }
1917   }
1918
1919 #ifndef _WIN32
1920   /*
1921    * XXX We exhibit different behaviour between normal mode and sync mode
1922    * when the pipe is stdin and not already at EOF.  If we're a child, the
1923    * parent's stdin isn't closed, so if the user starts another capture,
1924    * pipe_open_live() will very likely not see the expected magic bytes and
1925    * will say "Unrecognized libpcap format".  On the other hand, in normal
1926    * mode, pipe_open_live() will say "End of file on pipe during open".
1927    */
1928   if (ld.from_pipe && pipe_fd >= 0)
1929     close(pipe_fd);
1930   else
1931 #endif
1932   {
1933     /* Get the capture statistics, so we know how many packets were
1934        dropped. */
1935     if (pcap_stats(pch, stats) >= 0) {
1936       *stats_known = TRUE;
1937       if (capture_child) {
1938         /* Let the parent process know. */
1939         char tmp[DECISIZE+1+1];
1940         sprintf(tmp, "%d%c", stats->ps_drop, SP_DROPS);
1941         write(1, tmp, strlen(tmp));
1942       }
1943     } else {
1944       snprintf(errmsg, sizeof(errmsg),
1945                 "Can't get packet-drop statistics: %s",
1946                 pcap_geterr(pch));
1947       popup_errmsg(errmsg);
1948     }
1949     pcap_close(pch);
1950   }
1951
1952 #ifdef WIN32
1953   /* Shut down windows sockets */
1954   WSACleanup();
1955 #endif
1956
1957   gtk_grab_remove(GTK_WIDGET(cap_w));
1958   gtk_widget_destroy(GTK_WIDGET(cap_w));
1959
1960   return TRUE;
1961
1962 error:
1963   if (capture_opts.ringbuffer_on) {
1964     /* cleanup ringbuffer */
1965     ringbuf_error_cleanup();
1966   } else {
1967     /* We can't use the save file, and we have no wtap_dump stream
1968        to close in order to close it, so close the FD directly. */
1969     close(cfile.save_file_fd);
1970
1971     /* We couldn't even start the capture, so get rid of the capture
1972        file. */
1973     unlink(cfile.save_file); /* silently ignore error */
1974     g_free(cfile.save_file);
1975   }
1976   cfile.save_file = NULL;
1977   popup_errmsg(errmsg);
1978
1979 #ifndef WIN32
1980   if (ld.from_pipe) {
1981     if (pipe_fd >= 0)
1982       close(pipe_fd);
1983   } else
1984 #endif
1985   {
1986     if (pch != NULL)
1987       pcap_close(pch);
1988   }
1989
1990   return FALSE;
1991 }
1992
1993 static void
1994 get_capture_file_io_error(char *errmsg, int errmsglen, const char *fname,
1995                           int err, gboolean is_close)
1996 {
1997   switch (err) {
1998
1999   case ENOSPC:
2000     snprintf(errmsg, errmsglen,
2001                 "Not all the packets could be written to the file"
2002                 " to which the capture was being saved\n"
2003                 "(\"%s\") because there is no space left on the file system\n"
2004                 "on which that file resides.",
2005                 fname);
2006     break;
2007
2008 #ifdef EDQUOT
2009   case EDQUOT:
2010     snprintf(errmsg, errmsglen,
2011                 "Not all the packets could be written to the file"
2012                 " to which the capture was being saved\n"
2013                 "(\"%s\") because you are too close to, or over,"
2014                 " your disk quota\n"
2015                 "on the file system on which that file resides.",
2016                 fname);
2017   break;
2018 #endif
2019
2020   case WTAP_ERR_CANT_CLOSE:
2021     snprintf(errmsg, errmsglen,
2022                 "The file to which the capture was being saved"
2023                 " couldn't be closed for some unknown reason.");
2024     break;
2025
2026   case WTAP_ERR_SHORT_WRITE:
2027     snprintf(errmsg, errmsglen,
2028                 "Not all the packets could be written to the file"
2029                 " to which the capture was being saved\n"
2030                 "(\"%s\").",
2031                 fname);
2032     break;
2033
2034   default:
2035     if (is_close) {
2036       snprintf(errmsg, errmsglen,
2037                 "The file to which the capture was being saved\n"
2038                 "(\"%s\") could not be closed: %s.",
2039                 fname, wtap_strerror(err));
2040     } else {
2041       snprintf(errmsg, errmsglen,
2042                 "An error occurred while writing to the file"
2043                 " to which the capture was being saved\n"
2044                 "(\"%s\"): %s.",
2045                 fname, wtap_strerror(err));
2046     }
2047     break;
2048   }
2049 }
2050
2051 static void
2052 popup_errmsg(const char *errmsg)
2053 {
2054   if (capture_child) {
2055     /* This is the child process for a sync mode capture.
2056        Send the error message to our parent, so they can display a
2057        dialog box containing it. */
2058     send_errmsg_to_parent(errmsg);
2059   } else {
2060     /* Display the dialog box ourselves; there's no parent. */
2061     simple_dialog(ESD_TYPE_CRIT, NULL, "%s", errmsg);
2062   }
2063 }
2064
2065 static void
2066 send_errmsg_to_parent(const char *errmsg)
2067 {
2068     int msglen = strlen(errmsg);
2069     char lenbuf[DECISIZE+1+1];
2070
2071     sprintf(lenbuf, "%u%c", msglen, SP_ERROR_MSG);
2072     write(1, lenbuf, strlen(lenbuf));
2073     write(1, errmsg, msglen);
2074 }
2075
2076 static float
2077 pct(gint num, gint denom) {
2078   if (denom) {
2079     return (float) num * 100.0 / (float) denom;
2080   } else {
2081     return 0.0;
2082   }
2083 }
2084
2085 static void
2086 stop_capture(int signo _U_)
2087 {
2088   ld.go = FALSE;
2089 }
2090
2091 static void
2092 capture_delete_cb(GtkWidget *w _U_, GdkEvent *event _U_, gpointer data) {
2093   capture_stop_cb(NULL, data);
2094 }
2095
2096 static void
2097 capture_stop_cb(GtkWidget *w _U_, gpointer data) {
2098   loop_data *ld = (loop_data *) data;
2099   
2100   ld->go = FALSE;
2101 }
2102
2103 void
2104 capture_stop(void)
2105 {
2106   /*
2107    * XXX - find some way of signaling the child in Win32.
2108    */
2109 #ifndef _WIN32
2110   if (fork_child != -1)
2111       kill(fork_child, SIGUSR1);
2112 #endif
2113 }
2114
2115 void
2116 kill_capture_child(void)
2117 {
2118   /*
2119    * XXX - find some way of signaling the child in Win32.
2120    */
2121 #ifndef _WIN32
2122   if (fork_child != -1)
2123     kill(fork_child, SIGTERM);  /* SIGTERM so it can clean up if necessary */
2124 #endif
2125 }
2126
2127 static void
2128 capture_pcap_cb(guchar *user, const struct pcap_pkthdr *phdr,
2129   const guchar *pd)
2130 {
2131   struct wtap_pkthdr whdr;
2132   union wtap_pseudo_header pseudo_header;
2133   loop_data *ld = (loop_data *) user;
2134   int err;
2135
2136   if ((++ld->counts.total >= ld->max) && (ld->max > 0)) 
2137   {
2138      ld->go = FALSE;
2139   }
2140
2141   /* Convert from libpcap to Wiretap format.
2142      If that fails, set "ld->go" to FALSE, to stop the capture, and set
2143      "ld->err" to the error. */
2144   pd = wtap_process_pcap_packet(ld->linktype, phdr, pd, &pseudo_header,
2145                                 &whdr, &err);
2146   if (pd == NULL) {
2147     ld->go = FALSE;
2148     ld->err = err;
2149     return;
2150   }
2151
2152   if (ld->pdh) {
2153     /* We're supposed to write the packet to a file; do so.
2154        If this fails, set "ld->go" to FALSE, to stop the capture, and set
2155        "ld->err" to the error. */
2156     if (!wtap_dump(ld->pdh, &whdr, &pseudo_header, pd, &err)) {
2157       ld->go = FALSE;
2158       ld->err = err;
2159     }
2160   }
2161
2162   switch (ld->linktype) {
2163     case WTAP_ENCAP_ETHERNET:
2164       capture_eth(pd, 0, whdr.caplen, &ld->counts);
2165       break;
2166     case WTAP_ENCAP_FDDI:
2167     case WTAP_ENCAP_FDDI_BITSWAPPED:
2168       capture_fddi(pd, whdr.caplen, &ld->counts);
2169       break;
2170     case WTAP_ENCAP_PRISM_HEADER:
2171       capture_prism(pd, 0, whdr.caplen, &ld->counts);
2172       break;
2173     case WTAP_ENCAP_TOKEN_RING:
2174       capture_tr(pd, 0, whdr.caplen, &ld->counts);
2175       break;
2176     case WTAP_ENCAP_NULL:
2177       capture_null(pd, whdr.caplen, &ld->counts);
2178       break;
2179     case WTAP_ENCAP_PPP:
2180       capture_ppp_hdlc(pd, 0, whdr.caplen, &ld->counts);
2181       break;
2182     case WTAP_ENCAP_RAW_IP:
2183       capture_raw(pd, whdr.caplen, &ld->counts);
2184       break;
2185     case WTAP_ENCAP_SLL:
2186       capture_sll(pd, whdr.caplen, &ld->counts);
2187       break;
2188     case WTAP_ENCAP_LINUX_ATM_CLIP:
2189       capture_clip(pd, whdr.caplen, &ld->counts);
2190       break;
2191     case WTAP_ENCAP_IEEE_802_11:
2192     case WTAP_ENCAP_IEEE_802_11_WITH_RADIO:
2193       capture_ieee80211(pd, 0, whdr.caplen, &ld->counts);
2194       break;
2195     case WTAP_ENCAP_CHDLC:
2196       capture_chdlc(pd, 0, whdr.caplen, &ld->counts);
2197       break;
2198     case WTAP_ENCAP_LOCALTALK:
2199       capture_llap(&ld->counts);
2200       break;
2201     case WTAP_ENCAP_ATM_SNIFFER:
2202       capture_atm(&pseudo_header, pd, whdr.caplen, &ld->counts);
2203       break;
2204     /* XXX - some ATM drivers on FreeBSD might prepend a 4-byte ATM
2205        pseudo-header to DLT_ATM_RFC1483, with LLC header following;
2206        we might have to implement that at some point. */
2207   }
2208 }
2209
2210 #endif /* HAVE_LIBPCAP */