change all file offsets from long to gint64 so we can - theoretically - handle files...
[obnox/wireshark/wip.git] / capture_sync.c
1 /* capture_sync.c
2  * Synchronisation between Wireshark capture parent and child instances
3  *
4  * $Id$
5  *
6  * Wireshark - Network traffic analyzer
7  * By Gerald Combs <gerald@wireshark.org>
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 #include <glib.h>
32 #include <stdio.h>
33 #include <ctype.h>
34 #include <string.h>
35
36 #ifdef HAVE_UNISTD_H
37 #include <unistd.h>
38 #endif
39
40 #include <signal.h>
41
42 #ifdef _WIN32
43 #include <fcntl.h>
44 #include "epan/unicode-utils.h"
45 #endif
46
47 #ifdef HAVE_SYS_WAIT_H
48 # include <sys/wait.h>
49 #endif
50
51 #include "capture-pcap-util.h"
52
53 #ifndef _WIN32
54 /*
55  * Define various POSIX macros (and, in the case of WCOREDUMP, non-POSIX
56  * macros) on UNIX systems that don't have them.
57  */
58 #ifndef WIFEXITED
59 # define WIFEXITED(status)      (((status) & 0177) == 0)
60 #endif
61 #ifndef WIFSTOPPED
62 # define WIFSTOPPED(status)     (((status) & 0177) == 0177)
63 #endif
64 #ifndef WIFSIGNALED
65 # define WIFSIGNALED(status)    (!WIFSTOPPED(status) && !WIFEXITED(status))
66 #endif
67 #ifndef WEXITSTATUS
68 # define WEXITSTATUS(status)    ((status) >> 8)
69 #endif
70 #ifndef WTERMSIG
71 # define WTERMSIG(status)       ((status) & 0177)
72 #endif
73 #ifndef WCOREDUMP
74 # define WCOREDUMP(status)      ((status) & 0200)
75 #endif
76 #ifndef WSTOPSIG
77 # define WSTOPSIG(status)       ((status) >> 8)
78 #endif
79 #endif /* _WIN32 */
80
81 #include <epan/packet.h>
82 #include <epan/prefs.h>
83
84 #include "globals.h"
85 #include "file.h"
86 #include <epan/filesystem.h>
87
88 #include "capture.h"
89 #include "capture_sync.h"
90 #include "simple_dialog.h"
91
92 #include "sync_pipe.h"
93
94 #ifdef _WIN32
95 #include "capture-wpcap.h"
96 #endif
97 #include "ui_util.h"
98 #include "file_util.h"
99 #include "log.h"
100
101 #ifdef _WIN32
102 #include <process.h>    /* For spawning child process */
103 #endif
104
105
106
107 #ifndef _WIN32
108 static const char *sync_pipe_signame(int);
109 #endif
110
111
112 static gboolean sync_pipe_input_cb(gint source, gpointer user_data);
113 static void sync_pipe_wait_for_child(capture_options *capture_opts);
114
115
116
117 /* Append an arg (realloc) to an argc/argv array */
118 /* (add a string pointer to a NULL-terminated array of string pointers) */
119 static const char **
120 sync_pipe_add_arg(const char **args, int *argc, const char *arg)
121 {
122   /* Grow the array; "*argc" currently contains the number of string
123      pointers, *not* counting the NULL pointer at the end, so we have
124      to add 2 in order to get the new size of the array, including the
125      new pointer and the terminating NULL pointer. */
126   args = g_realloc( (gpointer) args, (*argc + 2) * sizeof (char *));
127
128   /* Stuff the pointer into the penultimate element of the array, which
129      is the one at the index specified by "*argc". */
130   args[*argc] = arg;
131
132   /* Now bump the count. */
133   (*argc)++;
134
135   /* We overwrite the NULL pointer; put it back right after the
136      element we added. */
137   args[*argc] = NULL;
138
139   return args;
140 }
141
142
143
144 #ifdef _WIN32
145 /* Quote the argument element if necessary, so that it will get
146  * reconstructed correctly in the C runtime startup code.  Note that
147  * the unquoting algorithm in the C runtime is really weird, and
148  * rather different than what Unix shells do. See stdargv.c in the C
149  * runtime sources (in the Platform SDK, in src/crt).
150  *
151  * Stolen from GLib's protect_argv(), an internal routine that quotes
152  * string in an argument list so that they arguments will be handled
153  * correctly in the command-line string passed to CreateProcess()
154  * if that string is constructed by gluing those strings together.
155  */
156 static gchar *
157 protect_arg (const gchar *argv)
158 {
159     gchar *new_arg;
160     const gchar *p = argv;
161     gchar *q;
162     gint len = 0;
163     gboolean need_dblquotes = FALSE;
164
165     while (*p) {
166         if (*p == ' ' || *p == '\t')
167             need_dblquotes = TRUE;
168         else if (*p == '"')
169             len++;
170         else if (*p == '\\') {
171             const gchar *pp = p;
172
173             while (*pp && *pp == '\\')
174                 pp++;
175             if (*pp == '"')
176                 len++;
177         }
178         len++;
179         p++;
180     }
181
182     q = new_arg = g_malloc (len + need_dblquotes*2 + 1);
183     p = argv;
184
185     if (need_dblquotes)
186         *q++ = '"';
187
188     while (*p) {
189         if (*p == '"')
190             *q++ = '\\';
191         else if (*p == '\\') {
192             const gchar *pp = p;
193
194             while (*pp && *pp == '\\')
195                 pp++;
196             if (*pp == '"')
197                 *q++ = '\\';
198         }
199         *q++ = *p;
200         p++;
201     }
202
203     if (need_dblquotes)
204         *q++ = '"';
205     *q++ = '\0';
206
207     return new_arg;
208 }
209 #endif
210
211
212
213 #define ARGV_NUMBER_LEN 24
214
215 /* a new capture run: start a new dumpcap task and hand over parameters through command line */
216 gboolean
217 sync_pipe_start(capture_options *capture_opts) {
218     char ssnap[ARGV_NUMBER_LEN];
219     char scount[ARGV_NUMBER_LEN];
220     char sfilesize[ARGV_NUMBER_LEN];
221     char sfile_duration[ARGV_NUMBER_LEN];
222     char sring_num_files[ARGV_NUMBER_LEN];
223     char sautostop_files[ARGV_NUMBER_LEN];
224     char sautostop_filesize[ARGV_NUMBER_LEN];
225     char sautostop_duration[ARGV_NUMBER_LEN];
226 #ifdef _WIN32
227     char buffer_size[ARGV_NUMBER_LEN];
228     HANDLE sync_pipe_read;                  /* pipe used to send messages from child to parent */
229     HANDLE sync_pipe_write;                 /* pipe used to send messages from child to parent */
230     HANDLE signal_pipe_read;                /* pipe used to send messages from parent to child (currently only stop) */
231     HANDLE signal_pipe_write;               /* pipe used to send messages from parent to child (currently only stop) */
232     GString *args = g_string_sized_new(200);
233     gchar *quoted_arg;
234     SECURITY_ATTRIBUTES sa;
235     STARTUPINFO si;
236     PROCESS_INFORMATION pi;
237     int i;
238 #else
239     char errmsg[1024+1];
240     int sync_pipe[2];                       /* pipe used to send messages from child to parent */
241     enum PIPES { PIPE_READ, PIPE_WRITE };   /* Constants 0 and 1 for PIPE_READ and PIPE_WRITE */
242 #endif
243     int sync_pipe_read_fd;
244     const char *progfile_dir;
245     char *exename;
246     int argc;
247     const char **argv;
248
249
250     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_start");
251     capture_opts_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, capture_opts);
252
253     capture_opts->fork_child = -1;
254
255     progfile_dir = get_progfile_dir();
256     if (progfile_dir == NULL) {
257       /* We don't know where to find dumpcap. */
258       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "We don't know where to find dumpcap.");
259       return FALSE;
260     }
261
262     /* Allocate the string pointer array with enough space for the
263        terminating NULL pointer. */
264     argc = 0;
265     argv = g_malloc(sizeof (char *));
266     *argv = NULL;
267
268     /* take Wireshark's absolute program path and replace "Wireshark" with "dumpcap" */
269     exename = g_strdup_printf("%s" G_DIR_SEPARATOR_S "dumpcap", progfile_dir);
270
271     /* Make that the first argument in the argument list (argv[0]). */
272     argv = sync_pipe_add_arg(argv, &argc, exename);
273
274     argv = sync_pipe_add_arg(argv, &argc, "-i");
275     argv = sync_pipe_add_arg(argv, &argc, capture_opts->iface);
276
277     if (capture_opts->has_snaplen) {
278       argv = sync_pipe_add_arg(argv, &argc, "-s");
279       g_snprintf(ssnap, ARGV_NUMBER_LEN, "%d",capture_opts->snaplen);
280       argv = sync_pipe_add_arg(argv, &argc, ssnap);
281     }
282
283     if (capture_opts->linktype != -1) {
284       argv = sync_pipe_add_arg(argv, &argc, "-y");
285 #ifdef HAVE_PCAP_DATALINK_VAL_TO_NAME
286       g_snprintf(ssnap, ARGV_NUMBER_LEN, "%s",linktype_val_to_name(capture_opts->linktype));
287 #else
288       /* we can't get the type name, just treat it as a number */
289       g_snprintf(ssnap, ARGV_NUMBER_LEN, "%d",capture_opts->linktype);
290 #endif
291       argv = sync_pipe_add_arg(argv, &argc, ssnap);
292     }
293
294     if(capture_opts->multi_files_on) {
295       if (capture_opts->has_autostop_filesize) {
296         argv = sync_pipe_add_arg(argv, &argc, "-b");
297         g_snprintf(sfilesize, ARGV_NUMBER_LEN, "filesize:%d",capture_opts->autostop_filesize);
298         argv = sync_pipe_add_arg(argv, &argc, sfilesize);
299       }
300
301       if (capture_opts->has_file_duration) {
302         argv = sync_pipe_add_arg(argv, &argc, "-b");
303         g_snprintf(sfile_duration, ARGV_NUMBER_LEN, "duration:%d",capture_opts->file_duration);
304         argv = sync_pipe_add_arg(argv, &argc, sfile_duration);
305       }
306
307       if (capture_opts->has_ring_num_files) {
308         argv = sync_pipe_add_arg(argv, &argc, "-b");
309         g_snprintf(sring_num_files, ARGV_NUMBER_LEN, "files:%d",capture_opts->ring_num_files);
310         argv = sync_pipe_add_arg(argv, &argc, sring_num_files);
311       }
312
313       if (capture_opts->has_autostop_files) {
314         argv = sync_pipe_add_arg(argv, &argc, "-a");
315         g_snprintf(sautostop_files, ARGV_NUMBER_LEN, "files:%d",capture_opts->autostop_files);
316         argv = sync_pipe_add_arg(argv, &argc, sautostop_files);
317       }
318     } else {
319         if (capture_opts->has_autostop_filesize) {
320           argv = sync_pipe_add_arg(argv, &argc, "-a");
321           g_snprintf(sautostop_filesize, ARGV_NUMBER_LEN, "filesize:%d",capture_opts->autostop_filesize);
322           argv = sync_pipe_add_arg(argv, &argc, sautostop_filesize);
323         }
324     }
325
326     if (capture_opts->has_autostop_packets) {
327       argv = sync_pipe_add_arg(argv, &argc, "-c");
328       g_snprintf(scount, ARGV_NUMBER_LEN, "%d",capture_opts->autostop_packets);
329       argv = sync_pipe_add_arg(argv, &argc, scount);
330     }
331
332     if (capture_opts->has_autostop_duration) {
333       argv = sync_pipe_add_arg(argv, &argc, "-a");
334       g_snprintf(sautostop_duration, ARGV_NUMBER_LEN, "duration:%d",capture_opts->autostop_duration);
335       argv = sync_pipe_add_arg(argv, &argc, sautostop_duration);
336     }
337
338     if (!capture_opts->promisc_mode)
339       argv = sync_pipe_add_arg(argv, &argc, "-p");
340
341     /* dumpcap should be running in capture child mode (hidden feature) */
342 #ifndef DEBUG_CHILD
343     argv = sync_pipe_add_arg(argv, &argc, "-Z");
344 #endif
345
346 #ifdef _WIN32
347     argv = sync_pipe_add_arg(argv, &argc, "-B");
348     g_snprintf(buffer_size, ARGV_NUMBER_LEN, "%d",capture_opts->buffer_size);
349     argv = sync_pipe_add_arg(argv, &argc, buffer_size);
350 #endif
351
352     if (capture_opts->cfilter != NULL && strlen(capture_opts->cfilter) != 0) {
353       argv = sync_pipe_add_arg(argv, &argc, "-f");
354       argv = sync_pipe_add_arg(argv, &argc, capture_opts->cfilter);
355     }
356
357     if(capture_opts->save_file) {
358       argv = sync_pipe_add_arg(argv, &argc, "-w");
359       argv = sync_pipe_add_arg(argv, &argc, capture_opts->save_file);
360     }
361
362 #ifdef _WIN32
363     /* init SECURITY_ATTRIBUTES */
364     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
365     sa.bInheritHandle = TRUE;
366     sa.lpSecurityDescriptor = NULL;
367
368     /* Create a pipe for the child process */
369     /* (inrease this value if you have trouble while fast capture file switches) */
370     if (! CreatePipe(&sync_pipe_read, &sync_pipe_write, &sa, 5120)) {
371       /* Couldn't create the pipe between parent and child. */
372       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Couldn't create sync pipe: %s",
373                         strerror(errno));
374       g_free( (gpointer) argv);
375       return FALSE;
376     }
377
378     /* Create a pipe for the parent process */
379     if (! CreatePipe(&signal_pipe_read, &signal_pipe_write, &sa, 512)) {
380       /* Couldn't create the signal pipe between parent and child. */
381       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Couldn't create signal pipe: %s",
382                         strerror(errno));
383       CloseHandle(sync_pipe_read);
384       CloseHandle(sync_pipe_write);
385       g_free( (gpointer) argv);
386       return FALSE;
387     }
388
389     /* init STARTUPINFO */
390     memset(&si, 0, sizeof(si));
391     si.cb           = sizeof(si);
392 #ifdef DEBUG_CHILD
393     si.dwFlags = STARTF_USESHOWWINDOW;
394     si.wShowWindow  = SW_SHOW;
395 #else
396     si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
397     si.wShowWindow  = SW_HIDE;  /* this hides the console window */
398     si.hStdInput = signal_pipe_read;
399     si.hStdOutput = sync_pipe_write;
400     si.hStdError = sync_pipe_write;
401     /*si.hStdError = (HANDLE) _get_osfhandle(2);*/
402 #endif
403
404     /* convert args array into a single string */
405     /* XXX - could change sync_pipe_add_arg() instead */
406     /* there is a drawback here: the length is internally limited to 1024 bytes */
407     for(i=0; argv[i] != 0; i++) {
408         if(i != 0) g_string_append_c(args, ' ');    /* don't prepend a space before the path!!! */
409         quoted_arg = protect_arg(argv[i]);
410         g_string_append(args, quoted_arg);
411         g_free(quoted_arg);
412     }
413
414     /* call dumpcap */
415     if(!CreateProcess(NULL, utf_8to16(args->str), NULL, NULL, TRUE,
416                       CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi)) {
417       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
418                     "Couldn't run %s in child process: error %u",
419                     args->str, GetLastError());
420       CloseHandle(sync_pipe_read);
421       CloseHandle(sync_pipe_write);
422       g_free( (gpointer) argv);
423       return FALSE;
424     }
425     capture_opts->fork_child = (int) pi.hProcess;
426     g_string_free(args, TRUE);
427
428     /* associate the operating system filehandle to a C run-time file handle */
429     /* (good file handle infos at: http://www.flounder.com/handles.htm) */
430     sync_pipe_read_fd = _open_osfhandle( (long) sync_pipe_read, _O_BINARY);
431
432     /* associate the operating system filehandle to a C run-time file handle */
433     capture_opts->signal_pipe_write_fd = _open_osfhandle( (long) signal_pipe_write, _O_BINARY);
434
435     /* child owns the read side now, close our handle */
436     CloseHandle(signal_pipe_read);
437 #else /* _WIN32 */
438     if (pipe(sync_pipe) < 0) {
439       /* Couldn't create the pipe between parent and child. */
440       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Couldn't create sync pipe: %s",
441                         strerror(errno));
442       g_free(argv);
443       return FALSE;
444     }
445
446     if ((capture_opts->fork_child = fork()) == 0) {
447       /*
448        * Child process - run dumpcap with the right arguments to make
449        * it just capture with the specified capture parameters
450        */
451       eth_close(1);
452       dup(sync_pipe[PIPE_WRITE]);
453       eth_close(sync_pipe[PIPE_READ]);
454       execv(exename, argv);
455       g_snprintf(errmsg, sizeof errmsg, "Couldn't run %s in child process: %s",
456                 exename, strerror(errno));
457       sync_pipe_errmsg_to_parent(errmsg, "");
458
459       /* Exit with "_exit()", so that we don't close the connection
460          to the X server (and cause stuff buffered up by our parent but
461          not yet sent to be sent, as that stuff should only be sent by
462          our parent). */
463       _exit(2);
464     }
465
466     sync_pipe_read_fd = sync_pipe[PIPE_READ];
467 #endif
468
469     g_free(exename);
470
471     /* Parent process - read messages from the child process over the
472        sync pipe. */
473     g_free( (gpointer) argv);   /* free up arg array */
474
475     /* Close the write side of the pipe, so that only the child has it
476        open, and thus it completely closes, and thus returns to us
477        an EOF indication, if the child closes it (either deliberately
478        or by exiting abnormally). */
479 #ifdef _WIN32
480     CloseHandle(sync_pipe_write);
481 #else
482     eth_close(sync_pipe[PIPE_WRITE]);
483 #endif
484
485     if (capture_opts->fork_child == -1) {
486       /* We couldn't even create the child process. */
487       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
488                         "Couldn't create child process: %s", strerror(errno));
489       eth_close(sync_pipe_read_fd);
490 #ifdef _WIN32
491       eth_close(capture_opts->signal_pipe_write_fd);
492 #endif
493       return FALSE;
494     }
495
496     /* we might wait for a moment till child is ready, so update screen now */
497     main_window_update();
498
499     /* We were able to set up to read the capture file;
500        arrange that our callback be called whenever it's possible
501        to read from the sync pipe, so that it's called when
502        the child process wants to tell us something. */
503
504     /* we have a running capture, now wait for the real capture filename */
505     pipe_input_set_handler(sync_pipe_read_fd, (gpointer) capture_opts,
506         &capture_opts->fork_child, sync_pipe_input_cb);
507
508     return TRUE;
509 }
510
511
512
513 /* read a number of bytes from a pipe */
514 /* (blocks until enough bytes read or an error occurs) */
515 static int
516 pipe_read_bytes(int pipe, char *bytes, int required) {
517     int newly;
518     int offset = 0;
519
520
521     while(required) {
522         newly = read(pipe, &bytes[offset], required);
523         if (newly == 0) {
524             /* EOF */
525             g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
526                   "read from pipe %d: EOF (capture closed?)", pipe);
527             return offset;
528         }
529         if (newly < 0) {
530             /* error */
531             g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
532                   "read from pipe %d: error(%u): %s", pipe, errno, strerror(errno));
533             return newly;
534         }
535
536         required -= newly;
537         offset += newly;
538     }
539
540     return offset;
541 }
542
543 /* convert header values (indicator and 4-byte length) */
544 static void
545 pipe_convert_header(const guchar *header, int header_len, char *indicator, int *block_len) {    
546
547     g_assert(header_len == 4);
548
549     /* convert header values */
550     *indicator = header[0];
551     *block_len = header[1]<<16 | header[2]<<8 | header[3];
552 }
553
554 /* read a message from the sending pipe in the standard format
555    (1-byte message indicator, 3-byte message length (excluding length
556    and indicator field), and the rest is the message) */
557 static int
558 pipe_read_block(int pipe, char *indicator, int len, char *msg) {
559     int required;
560     int newly;
561     guchar header[4];
562
563
564     /* read header (indicator and 3-byte length) */
565     newly = pipe_read_bytes(pipe, header, 4);
566     if(newly != 4) {
567         g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
568               "read %d failed to read header: %u", pipe, newly);
569         return -1;
570     }
571
572     /* convert header values */
573     pipe_convert_header(header, 4, indicator, &required);
574
575     /* only indicator with no value? */
576     if(required == 0) {
577         g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
578               "read %d indicator: %c empty value", pipe, *indicator);
579         return 4;
580     }
581
582     /* does the data fit into the given buffer? */
583     if(required > len) {
584         g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
585               "read %d length error, required %d > len %d, indicator: %u",
586               pipe, required, len, *indicator);
587
588         /* we have a problem here, try to read some more bytes from the pipe to debug where the problem really is */
589         memcpy(msg, header, sizeof(header));
590         newly = read(pipe, &msg[sizeof(header)], len-sizeof(header));
591         g_warning("Unknown message from dumpcap, try to show it as a string: %s", msg);
592         return -1;
593     }
594     len = required;
595
596     /* read the actual block data */
597     newly = pipe_read_bytes(pipe, msg, required);
598     if(newly != required) {
599         g_warning("Unknown message from dumpcap, try to show it as a string: %s", msg);
600         return -1;
601     }
602
603     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
604           "read %d ok indicator: %c len: %u msg: %s", pipe, *indicator,
605           len, msg);
606     return newly + 4;
607 }
608
609
610 /* There's stuff to read from the sync pipe, meaning the child has sent
611    us a message, or the sync pipe has closed, meaning the child has
612    closed it (perhaps because it exited). */
613 static gboolean
614 sync_pipe_input_cb(gint source, gpointer user_data)
615 {
616   capture_options *capture_opts = (capture_options *)user_data;
617   char buffer[SP_MAX_MSG_LEN+1];
618   int  nread;
619   char indicator;
620   int  primary_len;
621   char * primary_msg;
622   int  secondary_len;
623   char * secondary_msg;
624
625
626   nread = pipe_read_block(source, &indicator, SP_MAX_MSG_LEN, buffer);
627   if(nread <= 0) {
628     if (nread == 0)
629       g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
630             "sync_pipe_input_cb: child has closed sync_pipe");
631     else
632       g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
633             "sync_pipe_input_cb: error reading from sync pipe");
634
635     /* The child has closed the sync pipe, meaning it's not going to be
636        capturing any more packets.  Pick up its exit status, and
637        complain if it did anything other than exit with status 0.
638
639        We don't have to worry about killing the child, if the sync pipe 
640        returned an error. Usually this error is caused as the child killed itself 
641        while going down. Even in the rare cases that this isn't the case, 
642        the child will get an error when writing to the broken pipe the next time, 
643        cleaning itself up then. */
644     sync_pipe_wait_for_child(capture_opts);
645
646 #ifdef _WIN32
647     eth_close(capture_opts->signal_pipe_write_fd);
648 #endif
649     capture_input_closed(capture_opts);
650     return FALSE;
651   }
652
653   /* we got a valid message block from the child, process it */
654   switch(indicator) {
655   case SP_FILE:
656     if(!capture_input_new_file(capture_opts, buffer)) {
657       g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_input_cb: file failed, closing capture");
658
659       /* We weren't able to open the new capture file; user has been
660          alerted. Close the sync pipe. */
661       eth_close(source);
662
663       /* the child has send us a filename which we couldn't open.
664          this probably means, the child is creating files faster than we can handle it.
665          this should only be the case for very fast file switches
666          we can't do much more than telling the child to stop
667          (this is the "emergency brake" if user e.g. wants to switch files every second) */
668       sync_pipe_stop(capture_opts);
669     }
670     break;
671   case SP_PACKET_COUNT:
672     nread = atoi(buffer);
673     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_input_cb: new packets %u", nread);
674     capture_input_new_packets(capture_opts, nread);
675     break;
676   case SP_ERROR_MSG:
677     /* convert primary message */
678     pipe_convert_header(buffer, 4, &indicator, &primary_len);
679     primary_msg = buffer+4;
680     /* convert secondary message */
681     pipe_convert_header(primary_msg + primary_len, 4, &indicator, &secondary_len);
682     secondary_msg = primary_msg + primary_len + 4;
683     /* message output */
684     capture_input_error_message(capture_opts, primary_msg, secondary_msg);
685     /* the capture child will close the sync_pipe, nothing to do for now */
686     /* (an error message doesn't mean we have to stop capturing) */
687     break;
688   case SP_BAD_FILTER:
689     capture_input_cfilter_error_message(capture_opts, buffer);
690     /* the capture child will close the sync_pipe, nothing to do for now */
691     break;
692   case SP_DROPS:
693     capture_input_drops(capture_opts, atoi(buffer));
694     break;
695   default:
696     g_assert_not_reached();
697   }
698
699   return TRUE;
700 }
701
702
703
704 /* the child process is going down, wait until it's completely terminated */
705 static void
706 sync_pipe_wait_for_child(capture_options *capture_opts)
707 {
708   int  wstatus;
709
710
711   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_wait_for_child: wait till child closed");
712   g_assert(capture_opts->fork_child != -1);
713
714 #ifdef _WIN32
715   if (_cwait(&wstatus, capture_opts->fork_child, _WAIT_CHILD) == -1) {
716     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
717                 "Child capture process stopped unexpectedly (errno:%u)", errno);
718   }
719 #else
720   if (wait(&wstatus) != -1) {
721     if (WIFEXITED(wstatus)) {
722       /* The child exited; display its exit status, if it seems uncommon (0=ok, 1=error) */
723       /* the child will inform us about errors through the sync_pipe, which will popup */
724       /* an error message, so don't popup another one */
725
726       /* If there are situations where the child won't send us such an error message, */
727       /* this should be fixed in the child and not here! */
728       if (WEXITSTATUS(wstatus) != 0 && WEXITSTATUS(wstatus) != 1) {
729         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
730                       "Child capture process exited: exit status %d",
731                       WEXITSTATUS(wstatus));
732       }
733     } else if (WIFSTOPPED(wstatus)) {
734       /* It stopped, rather than exiting.  "Should not happen." */
735       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
736                     "Child capture process stopped: %s",
737                     sync_pipe_signame(WSTOPSIG(wstatus)));
738     } else if (WIFSIGNALED(wstatus)) {
739       /* It died with a signal. */
740       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
741                     "Child capture process died: %s%s",
742                     sync_pipe_signame(WTERMSIG(wstatus)),
743                     WCOREDUMP(wstatus) ? " - core dumped" : "");
744     } else {
745       /* What?  It had to either have exited, or stopped, or died with
746          a signal; what happened here? */
747       simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
748                     "Child capture process died: wait status %#o", wstatus);
749     }
750   }
751 #endif
752
753   /* No more child process. */
754   capture_opts->fork_child = -1;
755
756   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_wait_for_child: capture child closed");
757 }
758
759
760 #ifndef _WIN32
761 /* convert signal to corresponding name */
762 static const char *
763 sync_pipe_signame(int sig)
764 {
765   const char *sigmsg;
766   static char sigmsg_buf[6+1+3+1];
767
768   switch (sig) {
769
770   case SIGHUP:
771     sigmsg = "Hangup";
772     break;
773
774   case SIGINT:
775     sigmsg = "Interrupted";
776     break;
777
778   case SIGQUIT:
779     sigmsg = "Quit";
780     break;
781
782   case SIGILL:
783     sigmsg = "Illegal instruction";
784     break;
785
786   case SIGTRAP:
787     sigmsg = "Trace trap";
788     break;
789
790   case SIGABRT:
791     sigmsg = "Abort";
792     break;
793
794   case SIGFPE:
795     sigmsg = "Arithmetic exception";
796     break;
797
798   case SIGKILL:
799     sigmsg = "Killed";
800     break;
801
802   case SIGBUS:
803     sigmsg = "Bus error";
804     break;
805
806   case SIGSEGV:
807     sigmsg = "Segmentation violation";
808     break;
809
810   /* http://metalab.unc.edu/pub/Linux/docs/HOWTO/GCC-HOWTO
811      Linux is POSIX compliant.  These are not POSIX-defined signals ---
812      ISO/IEC 9945-1:1990 (IEEE Std 1003.1-1990), paragraph B.3.3.1.1 sez:
813
814         ``The signals SIGBUS, SIGEMT, SIGIOT, SIGTRAP, and SIGSYS
815         were omitted from POSIX.1 because their behavior is
816         implementation dependent and could not be adequately catego-
817         rized.  Conforming implementations may deliver these sig-
818         nals, but must document the circumstances under which they
819         are delivered and note any restrictions concerning their
820         delivery.''
821
822      So we only check for SIGSYS on those systems that happen to
823      implement them (a system can be POSIX-compliant and implement
824      them, it's just that POSIX doesn't *require* a POSIX-compliant
825      system to implement them).
826    */
827
828 #ifdef SIGSYS
829   case SIGSYS:
830     sigmsg = "Bad system call";
831     break;
832 #endif
833
834   case SIGPIPE:
835     sigmsg = "Broken pipe";
836     break;
837
838   case SIGALRM:
839     sigmsg = "Alarm clock";
840     break;
841
842   case SIGTERM:
843     sigmsg = "Terminated";
844     break;
845
846   default:
847         /* Returning a static buffer is ok in the context we use it here */
848     g_snprintf(sigmsg_buf, sizeof sigmsg_buf, "Signal %d", sig);
849     sigmsg = sigmsg_buf;
850     break;
851   }
852   return sigmsg;
853 }
854 #endif
855
856
857 #ifdef _WIN32
858 /* tell the child through the signal pipe that we want to quit the capture */
859 static void
860 signal_pipe_capquit_to_child(capture_options *capture_opts)
861 {
862     const char quit_msg[] = "QUIT";
863     int ret;
864
865
866     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "signal_pipe_capquit_to_child");
867
868     /* it doesn't matter *what* we send here, the first byte will stop the capture */
869     /* simply sending a "QUIT" string */
870     /*pipe_write_block(capture_opts->signal_pipe_write_fd, SP_QUIT, quit_msg);*/
871     ret = write(capture_opts->signal_pipe_write_fd, quit_msg, sizeof quit_msg);
872     if(ret == -1) {
873         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_WARNING,
874               "signal_pipe_capquit_to_child: %d header: error %s", capture_opts->signal_pipe_write_fd, strerror(errno));
875     }
876 }
877 #endif
878
879
880 /* user wants to stop the capture run */
881 void
882 sync_pipe_stop(capture_options *capture_opts)
883 {
884   if (capture_opts->fork_child != -1) {
885 #ifndef _WIN32
886     /* send the SIGUSR1 signal to close the capture child gracefully. */
887     kill(capture_opts->fork_child, SIGUSR1);
888 #else
889     /* Win32 doesn't have the kill() system call, use the special signal pipe
890        instead to close the capture child gracefully. */
891     signal_pipe_capquit_to_child(capture_opts);
892 #endif
893   }
894 }
895
896
897 /* Wireshark has to exit, force the capture child to close */
898 void
899 sync_pipe_kill(capture_options *capture_opts)
900 {
901   if (capture_opts->fork_child != -1) {
902 #ifndef _WIN32
903       kill(capture_opts->fork_child, SIGTERM);  /* SIGTERM so it can clean up if necessary */
904 #else
905       /* Remark: This is not the preferred method of closing a process!
906        * the clean way would be getting the process id of the child process,
907        * then getting window handle hWnd of that process (using EnumChildWindows),
908        * and then do a SendMessage(hWnd, WM_CLOSE, 0, 0)
909        *
910        * Unfortunately, I don't know how to get the process id from the
911        * handle.  OpenProcess will get an handle (not a window handle)
912        * from the process ID; it will not get a window handle from the
913        * process ID.  (How could it?  A process can have more than one
914        * window.  For that matter, a process might have *no* windows,
915        * as a process running dumpcap, the normal child process program,
916        * probably does.)
917        *
918        * Hint: GenerateConsoleCtrlEvent() will only work if both processes are
919        * running in the same console; that's not necessarily the case for
920        * us, as we might not be running in a console.
921        * And this also will require to have the process id.
922        */
923       TerminateProcess((HANDLE) (capture_opts->fork_child), 0);
924 #endif
925   }
926 }
927
928 #endif /* HAVE_LIBPCAP */