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