Fix a comment; this includes describing an additional way in which we
[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 #ifdef HAVE_FCNTL_H
41 #include <fcntl.h>
42 #endif
43
44 #include <signal.h>
45
46 #ifdef _WIN32
47 #include <wsutil/unicode-utils.h>
48 #endif
49
50 #ifdef HAVE_SYS_WAIT_H
51 # include <sys/wait.h>
52 #endif
53
54 #include "capture-pcap-util.h"
55
56 #ifndef _WIN32
57 /*
58  * Define various POSIX macros (and, in the case of WCOREDUMP, non-POSIX
59  * macros) on UNIX systems that don't have them.
60  */
61 #ifndef WIFEXITED
62 # define WIFEXITED(status)      (((status) & 0177) == 0)
63 #endif
64 #ifndef WIFSTOPPED
65 # define WIFSTOPPED(status)     (((status) & 0177) == 0177)
66 #endif
67 #ifndef WIFSIGNALED
68 # define WIFSIGNALED(status)    (!WIFSTOPPED(status) && !WIFEXITED(status))
69 #endif
70 #ifndef WEXITSTATUS
71 # define WEXITSTATUS(status)    ((status) >> 8)
72 #endif
73 #ifndef WTERMSIG
74 # define WTERMSIG(status)       ((status) & 0177)
75 #endif
76 #ifndef WCOREDUMP
77 # define WCOREDUMP(status)      ((status) & 0200)
78 #endif
79 #ifndef WSTOPSIG
80 # define WSTOPSIG(status)       ((status) >> 8)
81 #endif
82 #endif /* _WIN32 */
83
84 #include <epan/packet.h>
85 #include <epan/prefs.h>
86
87 #include "globals.h"
88 #include "file.h"
89 #include <epan/filesystem.h>
90 #include <epan/report_err.h>
91
92 #include "capture.h"
93 #include "capture_sync.h"
94
95 #include "sync_pipe.h"
96
97 #ifdef _WIN32
98 #include "capture-wpcap.h"
99 #endif
100 #include "ui_util.h"
101 #include <wsutil/file_util.h>
102 #include "log.h"
103
104 #ifdef _WIN32
105 #include <process.h>    /* For spawning child process */
106 #endif
107
108
109
110 #ifndef _WIN32
111 static const char *sync_pipe_signame(int);
112 #endif
113
114
115 static gboolean sync_pipe_input_cb(gint source, gpointer user_data);
116 static int sync_pipe_wait_for_child(int fork_child, gchar **msgp);
117 static void pipe_convert_header(const guchar *header, int header_len, char *indicator, int *block_len);
118 static int pipe_read_block(int pipe_fd, char *indicator, int len, char *msg,
119                            char **err_msg);
120
121
122
123 /* Append an arg (realloc) to an argc/argv array */
124 /* (add a string pointer to a NULL-terminated array of string pointers) */
125 static const char **
126 sync_pipe_add_arg(const char **args, int *argc, const char *arg)
127 {
128     /* Grow the array; "*argc" currently contains the number of string
129        pointers, *not* counting the NULL pointer at the end, so we have
130        to add 2 in order to get the new size of the array, including the
131        new pointer and the terminating NULL pointer. */
132     args = g_realloc( (gpointer) args, (*argc + 2) * sizeof (char *));
133
134     /* Stuff the pointer into the penultimate element of the array, which
135        is the one at the index specified by "*argc". */
136     args[*argc] = g_strdup(arg);
137     /* Now bump the count. */
138     (*argc)++;
139
140     /* We overwrite the NULL pointer; put it back right after the
141        element we added. */
142     args[*argc] = NULL;
143
144     return args;
145 }
146
147
148
149 #ifdef _WIN32
150 /* Quote the argument element if necessary, so that it will get
151  * reconstructed correctly in the C runtime startup code.  Note that
152  * the unquoting algorithm in the C runtime is really weird, and
153  * rather different than what Unix shells do. See stdargv.c in the C
154  * runtime sources (in the Platform SDK, in src/crt).
155  *
156  * Stolen from GLib's protect_argv(), an internal routine that quotes
157  * string in an argument list so that they arguments will be handled
158  * correctly in the command-line string passed to CreateProcess()
159  * if that string is constructed by gluing those strings together.
160  */
161 static gchar *
162 protect_arg (const gchar *argv)
163 {
164     gchar *new_arg;
165     const gchar *p = argv;
166     gchar *q;
167     gint len = 0;
168     gboolean need_dblquotes = FALSE;
169
170     while (*p) {
171         if (*p == ' ' || *p == '\t')
172             need_dblquotes = TRUE;
173         else if (*p == '"')
174             len++;
175         else if (*p == '\\') {
176             const gchar *pp = p;
177
178             while (*pp && *pp == '\\')
179                 pp++;
180             if (*pp == '"')
181                 len++;
182         }
183         len++;
184         p++;
185     }
186
187     q = new_arg = g_malloc (len + need_dblquotes*2 + 1);
188     p = argv;
189
190     if (need_dblquotes)
191         *q++ = '"';
192
193     while (*p) {
194         if (*p == '"')
195             *q++ = '\\';
196         else if (*p == '\\') {
197             const gchar *pp = p;
198
199             while (*pp && *pp == '\\')
200                 pp++;
201             if (*pp == '"')
202                 *q++ = '\\';
203         }
204         *q++ = *p;
205         p++;
206     }
207
208     if (need_dblquotes)
209         *q++ = '"';
210     *q++ = '\0';
211
212     return new_arg;
213 }
214
215 /*
216  * Generate a string for a Win32 error.
217  */
218 #define ERRBUF_SIZE    1024
219 static const char *
220 win32strerror(DWORD error)
221 {
222     static char errbuf[ERRBUF_SIZE+1];
223     size_t errlen;
224     char *p;
225
226     FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, error, 0, errbuf,
227                    ERRBUF_SIZE, NULL);
228
229     /*
230      * "FormatMessage()" "helpfully" sticks CR/LF at the end of the
231      * message.  Get rid of it.
232      */
233     errlen = strlen(errbuf);
234     if (errlen >= 2) {
235         errbuf[errlen - 1] = '\0';
236         errbuf[errlen - 2] = '\0';
237     }
238     p = strchr(errbuf, '\0');
239     g_snprintf(p, (gulong)(sizeof errbuf - (p-errbuf)), " (%lu)", error);
240     return errbuf;
241 }
242
243 /*
244  * Generate a string for a Win32 exception code.
245  */
246 static const char *
247 win32strexception(DWORD exception)
248 {
249     static char errbuf[ERRBUF_SIZE+1];
250     static const struct exception_msg {
251         int code;
252         char *msg;
253     } exceptions[] = {
254         { EXCEPTION_ACCESS_VIOLATION, "Access violation" },
255         { EXCEPTION_ARRAY_BOUNDS_EXCEEDED, "Array bounds exceeded" },
256         { EXCEPTION_BREAKPOINT, "Breakpoint" },
257         { EXCEPTION_DATATYPE_MISALIGNMENT, "Data type misalignment" },
258         { EXCEPTION_FLT_DENORMAL_OPERAND, "Denormal floating-point operand" },
259         { EXCEPTION_FLT_DIVIDE_BY_ZERO, "Floating-point divide by zero" },
260         { EXCEPTION_FLT_INEXACT_RESULT, "Floating-point inexact result" },
261         { EXCEPTION_FLT_INVALID_OPERATION, "Invalid floating-point operation" },
262         { EXCEPTION_FLT_OVERFLOW, "Floating-point overflow" },
263         { EXCEPTION_FLT_STACK_CHECK, "Floating-point stack check" },
264         { EXCEPTION_FLT_UNDERFLOW, "Floating-point underflow" },
265         { EXCEPTION_GUARD_PAGE, "Guard page violation" },
266         { EXCEPTION_ILLEGAL_INSTRUCTION, "Illegal instruction" },
267         { EXCEPTION_IN_PAGE_ERROR, "Page-in error" },
268         { EXCEPTION_INT_DIVIDE_BY_ZERO, "Integer divide by zero" },
269         { EXCEPTION_INT_OVERFLOW, "Integer overflow" },
270         { EXCEPTION_INVALID_DISPOSITION, "Invalid disposition" },
271         { EXCEPTION_INVALID_HANDLE, "Invalid handle" },
272         { EXCEPTION_NONCONTINUABLE_EXCEPTION, "Non-continuable exception" },
273         { EXCEPTION_PRIV_INSTRUCTION, "Privileged instruction" },
274         { EXCEPTION_SINGLE_STEP, "Single-step complete" },
275         { EXCEPTION_STACK_OVERFLOW, "Stack overflow" },
276         { 0, NULL }
277     };
278 #define N_EXCEPTIONS    (sizeof exceptions / sizeof exceptions[0])
279     int i;
280
281     for (i = 0; i < N_EXCEPTIONS; i++) {
282         if (exceptions[i].code == exception)
283             return exceptions[i].msg;
284     }
285     g_snprintf(errbuf, (gulong)sizeof errbuf, "Exception 0x%08x", exception);
286     return errbuf;
287 }
288 #endif
289
290 /* Initialize an argument list and add dumpcap to it. */
291 static const char **
292 init_pipe_args(int *argc) {
293     const char **argv;
294     const char *progfile_dir;
295     char *exename;
296
297     progfile_dir = get_progfile_dir();
298     if (progfile_dir == NULL) {
299       return NULL;
300     }
301
302     /* Allocate the string pointer array with enough space for the
303        terminating NULL pointer. */
304     *argc = 0;
305     argv = g_malloc(sizeof (char *));
306     *argv = NULL;
307
308     /* take Wireshark's absolute program path and replace "Wireshark" with "dumpcap" */
309     exename = g_strdup_printf("%s" G_DIR_SEPARATOR_S "dumpcap", progfile_dir);
310
311     /* Make that the first argument in the argument list (argv[0]). */
312     argv = sync_pipe_add_arg(argv, argc, exename);
313
314     return argv;
315 }
316
317 #define ARGV_NUMBER_LEN 24
318 /* a new capture run: start a new dumpcap task and hand over parameters through command line */
319 gboolean
320 sync_pipe_start(capture_options *capture_opts) {
321     char ssnap[ARGV_NUMBER_LEN];
322     char sdlt[ARGV_NUMBER_LEN];
323     char scount[ARGV_NUMBER_LEN];
324     char sfilesize[ARGV_NUMBER_LEN];
325     char sfile_duration[ARGV_NUMBER_LEN];
326     char sring_num_files[ARGV_NUMBER_LEN];
327     char sautostop_files[ARGV_NUMBER_LEN];
328     char sautostop_filesize[ARGV_NUMBER_LEN];
329     char sautostop_duration[ARGV_NUMBER_LEN];
330 #ifdef HAVE_PCAP_REMOTE
331     char sauth[256];
332 #endif
333 #ifdef HAVE_PCAP_SETSAMPLING
334     char ssampling[ARGV_NUMBER_LEN];
335 #endif
336
337 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
338     char buffer_size[ARGV_NUMBER_LEN];
339 #endif
340
341 #ifdef _WIN32
342     HANDLE sync_pipe_read;                  /* pipe used to send messages from child to parent */
343     HANDLE sync_pipe_write;                 /* pipe used to send messages from child to parent */
344     HANDLE signal_pipe;                     /* named pipe used to send messages from parent to child (currently only stop) */
345     GString *args = g_string_sized_new(200);
346     gchar *quoted_arg;
347     SECURITY_ATTRIBUTES sa;
348     STARTUPINFO si;
349     PROCESS_INFORMATION pi;
350     char control_id[ARGV_NUMBER_LEN];
351     gchar *signal_pipe_name;
352 #else
353     char errmsg[1024+1];
354     int sync_pipe[2];                       /* pipe used to send messages from child to parent */
355     enum PIPES { PIPE_READ, PIPE_WRITE };   /* Constants 0 and 1 for PIPE_READ and PIPE_WRITE */
356 #endif
357     int sync_pipe_read_fd;
358     int argc;
359     const char **argv;
360     int i;
361     guint j;
362     interface_options interface_opts;
363
364     if (capture_opts->ifaces->len > 1)
365         capture_opts->use_pcapng = TRUE;
366     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_start");
367     capture_opts_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, capture_opts);
368
369     capture_opts->fork_child = -1;
370
371     argv = init_pipe_args(&argc);
372     if (!argv) {
373         /* We don't know where to find dumpcap. */
374         report_failure("We don't know where to find dumpcap.");
375         return FALSE;
376     }
377
378     if (capture_opts->ifaces->len > 1)
379         argv = sync_pipe_add_arg(argv, &argc, "-t");
380
381     if (capture_opts->use_pcapng)
382         argv = sync_pipe_add_arg(argv, &argc, "-n");
383     else
384         argv = sync_pipe_add_arg(argv, &argc, "-P");
385
386     if (capture_opts->multi_files_on) {
387         if (capture_opts->has_autostop_filesize) {
388             argv = sync_pipe_add_arg(argv, &argc, "-b");
389             g_snprintf(sfilesize, ARGV_NUMBER_LEN, "filesize:%d",capture_opts->autostop_filesize);
390             argv = sync_pipe_add_arg(argv, &argc, sfilesize);
391         }
392
393         if (capture_opts->has_file_duration) {
394             argv = sync_pipe_add_arg(argv, &argc, "-b");
395             g_snprintf(sfile_duration, ARGV_NUMBER_LEN, "duration:%d",capture_opts->file_duration);
396             argv = sync_pipe_add_arg(argv, &argc, sfile_duration);
397         }
398
399         if (capture_opts->has_ring_num_files) {
400             argv = sync_pipe_add_arg(argv, &argc, "-b");
401             g_snprintf(sring_num_files, ARGV_NUMBER_LEN, "files:%d",capture_opts->ring_num_files);
402             argv = sync_pipe_add_arg(argv, &argc, sring_num_files);
403         }
404
405         if (capture_opts->has_autostop_files) {
406             argv = sync_pipe_add_arg(argv, &argc, "-a");
407             g_snprintf(sautostop_files, ARGV_NUMBER_LEN, "files:%d",capture_opts->autostop_files);
408             argv = sync_pipe_add_arg(argv, &argc, sautostop_files);
409         }
410     } else {
411         if (capture_opts->has_autostop_filesize) {
412             argv = sync_pipe_add_arg(argv, &argc, "-a");
413             g_snprintf(sautostop_filesize, ARGV_NUMBER_LEN, "filesize:%d",capture_opts->autostop_filesize);
414             argv = sync_pipe_add_arg(argv, &argc, sautostop_filesize);
415         }
416     }
417
418     if (capture_opts->has_autostop_packets) {
419         argv = sync_pipe_add_arg(argv, &argc, "-c");
420         g_snprintf(scount, ARGV_NUMBER_LEN, "%d",capture_opts->autostop_packets);
421         argv = sync_pipe_add_arg(argv, &argc, scount);
422     }
423
424     if (capture_opts->has_autostop_duration) {
425         argv = sync_pipe_add_arg(argv, &argc, "-a");
426         g_snprintf(sautostop_duration, ARGV_NUMBER_LEN, "duration:%d",capture_opts->autostop_duration);
427         argv = sync_pipe_add_arg(argv, &argc, sautostop_duration);
428     }
429
430     for (j = 0; j < capture_opts->ifaces->len; j++) {
431         interface_opts = g_array_index(capture_opts->ifaces, interface_options, j);
432
433         argv = sync_pipe_add_arg(argv, &argc, "-i");
434         argv = sync_pipe_add_arg(argv, &argc, interface_opts.name);
435
436         if (interface_opts.cfilter != NULL && strlen(interface_opts.cfilter) != 0) {
437             argv = sync_pipe_add_arg(argv, &argc, "-f");
438             argv = sync_pipe_add_arg(argv, &argc, interface_opts.cfilter);
439         }
440         if (interface_opts.snaplen != WTAP_MAX_PACKET_SIZE) {
441             argv = sync_pipe_add_arg(argv, &argc, "-s");
442             g_snprintf(ssnap, ARGV_NUMBER_LEN, "%d", interface_opts.snaplen);
443             argv = sync_pipe_add_arg(argv, &argc, ssnap);
444         }
445
446         if (interface_opts.linktype != -1) {
447             argv = sync_pipe_add_arg(argv, &argc, "-y");
448             g_snprintf(sdlt, ARGV_NUMBER_LEN, "%s", linktype_val_to_name(interface_opts.linktype));
449             argv = sync_pipe_add_arg(argv, &argc, sdlt);
450         }
451
452         if (!interface_opts.promisc_mode) {
453             argv = sync_pipe_add_arg(argv, &argc, "-p");
454         }
455
456 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
457         if (interface_opts.buffer_size != 1) {
458             argv = sync_pipe_add_arg(argv, &argc, "-B");
459             g_snprintf(buffer_size, ARGV_NUMBER_LEN, "%d", interface_opts.buffer_size);
460             argv = sync_pipe_add_arg(argv, &argc, buffer_size);
461         }
462 #endif
463
464         if (interface_opts.monitor_mode) {
465             argv = sync_pipe_add_arg(argv, &argc, "-I");
466         }
467
468 #ifdef HAVE_PCAP_REMOTE
469         if (interface_opts.datatx_udp)
470             argv = sync_pipe_add_arg(argv, &argc, "-u");
471
472         if (!interface_opts.nocap_rpcap)
473             argv = sync_pipe_add_arg(argv, &argc, "-r");
474
475         if (interface_opts.auth_type == CAPTURE_AUTH_PWD) {
476             argv = sync_pipe_add_arg(argv, &argc, "-A");
477             g_snprintf(sauth, sizeof(sauth), "%s:%s",
478                        interface_opts.auth_username,
479                        interface_opts.auth_password);
480             argv = sync_pipe_add_arg(argv, &argc, sauth);
481         }
482 #endif
483
484 #ifdef HAVE_PCAP_SETSAMPLING
485         if (interface_opts.sampling_method != CAPTURE_SAMP_NONE) {
486             argv = sync_pipe_add_arg(argv, &argc, "-m");
487             g_snprintf(ssampling, ARGV_NUMBER_LEN, "%s:%d",
488                        interface_opts.sampling_method == CAPTURE_SAMP_BY_COUNT ? "count" :
489                        interface_opts.sampling_method == CAPTURE_SAMP_BY_TIMER ? "timer" :
490                        "undef",
491                        interface_opts.sampling_param);
492             argv = sync_pipe_add_arg(argv, &argc, ssampling);
493         }
494 #endif
495     }
496
497     /* dumpcap should be running in capture child mode (hidden feature) */
498 #ifndef DEBUG_CHILD
499     argv = sync_pipe_add_arg(argv, &argc, "-Z");
500 #ifdef _WIN32
501     g_snprintf(control_id, ARGV_NUMBER_LEN, "%d", GetCurrentProcessId());
502     argv = sync_pipe_add_arg(argv, &argc, control_id);
503 #else
504     argv = sync_pipe_add_arg(argv, &argc, SIGNAL_PIPE_CTRL_ID_NONE);
505 #endif
506 #endif
507
508     if (capture_opts->save_file) {
509         argv = sync_pipe_add_arg(argv, &argc, "-w");
510         argv = sync_pipe_add_arg(argv, &argc, capture_opts->save_file);
511     }
512     for (i = 0; i < argc; i++) {
513         g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "argv[%d]: %s", i, argv[i]);
514     }
515
516 #ifdef _WIN32
517     /* init SECURITY_ATTRIBUTES */
518     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
519     sa.bInheritHandle = TRUE;
520     sa.lpSecurityDescriptor = NULL;
521
522     /* Create a pipe for the child process */
523     /* (increase this value if you have trouble while fast capture file switches) */
524     if (! CreatePipe(&sync_pipe_read, &sync_pipe_write, &sa, 5120)) {
525         /* Couldn't create the pipe between parent and child. */
526         report_failure("Couldn't create sync pipe: %s",
527                        win32strerror(GetLastError()));
528         for (i = 0; i < argc; i++) {
529             g_free( (gpointer) argv[i]);
530         }
531         g_free( (gpointer) argv);
532         return FALSE;
533     }
534
535     /* Create the signal pipe */
536     signal_pipe_name = g_strdup_printf(SIGNAL_PIPE_FORMAT, control_id);
537     signal_pipe = CreateNamedPipe(utf_8to16(signal_pipe_name),
538                                   PIPE_ACCESS_OUTBOUND, PIPE_TYPE_BYTE, 1, 65535, 65535, 0, NULL);
539     g_free(signal_pipe_name);
540
541     if (signal_pipe == INVALID_HANDLE_VALUE) {
542         /* Couldn't create the signal pipe between parent and child. */
543         report_failure("Couldn't create signal pipe: %s",
544                        win32strerror(GetLastError()));
545         for (i = 0; i < argc; i++) {
546             g_free( (gpointer) argv[i]);
547         }
548         g_free( (gpointer) argv);
549         return FALSE;
550     }
551
552     /* init STARTUPINFO */
553     memset(&si, 0, sizeof(si));
554     si.cb           = sizeof(si);
555 #ifdef DEBUG_CHILD
556     si.dwFlags = STARTF_USESHOWWINDOW;
557     si.wShowWindow  = SW_SHOW;
558 #else
559     si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
560     si.wShowWindow  = SW_HIDE;  /* this hides the console window */
561     si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
562     si.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
563     si.hStdError = sync_pipe_write;
564     /*si.hStdError = (HANDLE) _get_osfhandle(2);*/
565 #endif
566
567     /* convert args array into a single string */
568     /* XXX - could change sync_pipe_add_arg() instead */
569     /* there is a drawback here: the length is internally limited to 1024 bytes */
570     for(i=0; argv[i] != 0; i++) {
571         if(i != 0) g_string_append_c(args, ' ');    /* don't prepend a space before the path!!! */
572         quoted_arg = protect_arg(argv[i]);
573         g_string_append(args, quoted_arg);
574         g_free(quoted_arg);
575     }
576
577     /* call dumpcap */
578     if(!CreateProcess(NULL, utf_8to16(args->str), NULL, NULL, TRUE,
579                       CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi)) {
580         report_failure("Couldn't run %s in child process: %s",
581                        args->str, win32strerror(GetLastError()));
582         CloseHandle(sync_pipe_read);
583         CloseHandle(sync_pipe_write);
584         for (i = 0; i < argc; i++) {
585             g_free( (gpointer) argv[i]);
586         }
587         g_free( (gpointer) argv);
588         return FALSE;
589     }
590     capture_opts->fork_child = (int) pi.hProcess;
591     g_string_free(args, TRUE);
592
593     /* associate the operating system filehandle to a C run-time file handle */
594     /* (good file handle infos at: http://www.flounder.com/handles.htm) */
595     sync_pipe_read_fd = _open_osfhandle( (long) sync_pipe_read, _O_BINARY);
596
597     /* associate the operating system filehandle to a C run-time file handle */
598     capture_opts->signal_pipe_write_fd = _open_osfhandle( (long) signal_pipe, _O_BINARY);
599
600 #else /* _WIN32 */
601     if (pipe(sync_pipe) < 0) {
602         /* Couldn't create the pipe between parent and child. */
603         report_failure("Couldn't create sync pipe: %s", g_strerror(errno));
604         for (i = 0; i < argc; i++) {
605             g_free( (gpointer) argv[i]);
606         }
607         g_free(argv);
608         return FALSE;
609     }
610
611     if ((capture_opts->fork_child = fork()) == 0) {
612         /*
613          * Child process - run dumpcap with the right arguments to make
614          * it just capture with the specified capture parameters
615          */
616         dup2(sync_pipe[PIPE_WRITE], 2);
617         ws_close(sync_pipe[PIPE_READ]);
618         execv(argv[0], (gpointer)argv);
619         g_snprintf(errmsg, sizeof errmsg, "Couldn't run %s in child process: %s",
620                    argv[0], g_strerror(errno));
621         sync_pipe_errmsg_to_parent(2, errmsg, "");
622
623         /* Exit with "_exit()", so that we don't close the connection
624            to the X server (and cause stuff buffered up by our parent but
625            not yet sent to be sent, as that stuff should only be sent by
626            our parent).  We've sent an error message to the parent, so
627            we exit with an exit status of 1 (any exit status other than
628            0 or 1 will cause an additional message to report that exit
629            status, over and above the error message we sent to the parent). */
630         _exit(1);
631     }
632
633     sync_pipe_read_fd = sync_pipe[PIPE_READ];
634 #endif
635
636     for (i = 0; i < argc; i++) {
637         g_free( (gpointer) argv[i]);
638     }
639
640     /* Parent process - read messages from the child process over the
641        sync pipe. */
642     g_free( (gpointer) argv);   /* free up arg array */
643
644     /* Close the write side of the pipe, so that only the child has it
645        open, and thus it completely closes, and thus returns to us
646        an EOF indication, if the child closes it (either deliberately
647        or by exiting abnormally). */
648 #ifdef _WIN32
649     CloseHandle(sync_pipe_write);
650 #else
651     ws_close(sync_pipe[PIPE_WRITE]);
652 #endif
653
654     if (capture_opts->fork_child == -1) {
655         /* We couldn't even create the child process. */
656         report_failure("Couldn't create child process: %s", g_strerror(errno));
657         ws_close(sync_pipe_read_fd);
658 #ifdef _WIN32
659         ws_close(capture_opts->signal_pipe_write_fd);
660 #endif
661         return FALSE;
662     }
663
664     capture_opts->fork_child_status = 0;
665
666     /* we might wait for a moment till child is ready, so update screen now */
667     main_window_update();
668
669     /* We were able to set up to read the capture file;
670        arrange that our callback be called whenever it's possible
671        to read from the sync pipe, so that it's called when
672        the child process wants to tell us something. */
673
674     /* we have a running capture, now wait for the real capture filename */
675     pipe_input_set_handler(sync_pipe_read_fd, (gpointer) capture_opts,
676                            &capture_opts->fork_child, sync_pipe_input_cb);
677
678     return TRUE;
679 }
680
681 /*
682  * Open two pipes to dumpcap with the supplied arguments, one for its
683  * standard output and one for its standard error.
684  *
685  * On success, *msg is unchanged and 0 is returned; data_read_fd,
686  * messsage_read_fd, and fork_child point to the standard output pipe's
687  * file descriptor, the standard error pipe's file descriptor, and
688  * the child's PID/handle, respectively.
689  *
690  * On failure, *msg points to an error message for the failure, and -1 is
691  * returned, in which case *msg must be freed with g_free().
692  */
693 /* XXX - This duplicates a lot of code in sync_pipe_start() */
694 /* XXX - assumes PIPE_BUF_SIZE > SP_MAX_MSG_LEN */
695 #define PIPE_BUF_SIZE 5120
696 static int
697 sync_pipe_open_command(const char** argv, int *data_read_fd,
698                        int *message_read_fd, int *fork_child, gchar **msg)
699 {
700     enum PIPES { PIPE_READ, PIPE_WRITE };   /* Constants 0 and 1 for PIPE_READ and PIPE_WRITE */
701 #ifdef _WIN32
702     HANDLE sync_pipe[2];                    /* pipe used to send messages from child to parent */
703     HANDLE data_pipe[2];                    /* pipe used to send data from child to parent */
704     GString *args = g_string_sized_new(200);
705     gchar *quoted_arg;
706     SECURITY_ATTRIBUTES sa;
707     STARTUPINFO si;
708     PROCESS_INFORMATION pi;
709 #else
710     char errmsg[1024+1];
711     int sync_pipe[2];                       /* pipe used to send messages from child to parent */
712     int data_pipe[2];                       /* pipe used to send data from child to parent */
713 #endif
714     int i;
715     *fork_child = -1;
716     *data_read_fd = -1;
717     *message_read_fd = -1;
718     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_open_command");
719
720     if (!msg) {
721         /* We can't return anything */
722 #ifdef _WIN32
723         g_string_free(args, TRUE);
724 #endif
725         return -1;
726     }
727
728 #ifdef _WIN32
729     /* init SECURITY_ATTRIBUTES */
730     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
731     sa.bInheritHandle = TRUE;
732     sa.lpSecurityDescriptor = NULL;
733
734     /* Create a pipe for the child process to send us messages */
735     /* (increase this value if you have trouble while fast capture file switches) */
736     if (! CreatePipe(&sync_pipe[PIPE_READ], &sync_pipe[PIPE_WRITE], &sa, 5120)) {
737         /* Couldn't create the message pipe between parent and child. */
738         *msg = g_strdup_printf("Couldn't create sync pipe: %s",
739                                win32strerror(GetLastError()));
740         for (i = 0; argv[i] != NULL; i++) {
741             g_free( (gpointer) argv[i]);
742         }
743         g_free( (gpointer) argv);
744         return -1;
745     }
746
747     /* Create a pipe for the child process to send us data */
748     /* (increase this value if you have trouble while fast capture file switches) */
749     if (! CreatePipe(&data_pipe[PIPE_READ], &data_pipe[PIPE_WRITE], &sa, 5120)) {
750         /* Couldn't create the message pipe between parent and child. */
751         *msg = g_strdup_printf("Couldn't create data pipe: %s",
752                                win32strerror(GetLastError()));
753         CloseHandle(sync_pipe[PIPE_READ]);
754         CloseHandle(sync_pipe[PIPE_WRITE]);
755         for (i = 0; argv[i] != NULL; i++) {
756             g_free( (gpointer) argv[i]);
757         }
758         g_free( (gpointer) argv);
759         return -1;
760     }
761
762     /* init STARTUPINFO */
763     memset(&si, 0, sizeof(si));
764     si.cb           = sizeof(si);
765 #ifdef DEBUG_CHILD
766     si.dwFlags = STARTF_USESHOWWINDOW;
767     si.wShowWindow  = SW_SHOW;
768 #else
769     si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
770     si.wShowWindow  = SW_HIDE;  /* this hides the console window */
771     si.hStdInput = NULL;
772     si.hStdOutput = data_pipe[PIPE_WRITE];
773     si.hStdError = sync_pipe[PIPE_WRITE];
774 #endif
775
776     /* convert args array into a single string */
777     /* XXX - could change sync_pipe_add_arg() instead */
778     /* there is a drawback here: the length is internally limited to 1024 bytes */
779     for(i=0; argv[i] != 0; i++) {
780         if(i != 0) g_string_append_c(args, ' ');    /* don't prepend a space before the path!!! */
781         quoted_arg = protect_arg(argv[i]);
782         g_string_append(args, quoted_arg);
783         g_free(quoted_arg);
784     }
785
786     /* call dumpcap */
787     if(!CreateProcess(NULL, utf_8to16(args->str), NULL, NULL, TRUE,
788                       CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi)) {
789         *msg = g_strdup_printf("Couldn't run %s in child process: %s",
790                                args->str, win32strerror(GetLastError()));
791         CloseHandle(data_pipe[PIPE_READ]);
792         CloseHandle(data_pipe[PIPE_WRITE]);
793         CloseHandle(sync_pipe[PIPE_READ]);
794         CloseHandle(sync_pipe[PIPE_WRITE]);
795         for (i = 0; argv[i] != NULL; i++) {
796             g_free( (gpointer) argv[i]);
797         }
798         g_free( (gpointer) argv);
799         return -1;
800     }
801     *fork_child = (int) pi.hProcess;
802     g_string_free(args, TRUE);
803
804     /* associate the operating system filehandles to C run-time file handles */
805     /* (good file handle infos at: http://www.flounder.com/handles.htm) */
806     *data_read_fd = _open_osfhandle( (long) data_pipe[PIPE_READ], _O_BINARY);
807     *message_read_fd = _open_osfhandle( (long) sync_pipe[PIPE_READ], _O_BINARY);
808 #else /* _WIN32 */
809     /* Create a pipe for the child process to send us messages */
810     if (pipe(sync_pipe) < 0) {
811         /* Couldn't create the message pipe between parent and child. */
812         *msg = g_strdup_printf("Couldn't create sync pipe: %s", g_strerror(errno));
813         for (i = 0; argv[i] != NULL; i++) {
814             g_free( (gpointer) argv[i]);
815         }
816         g_free(argv);
817         return -1;
818     }
819
820     /* Create a pipe for the child process to send us data */
821     if (pipe(data_pipe) < 0) {
822         /* Couldn't create the data pipe between parent and child. */
823         *msg = g_strdup_printf("Couldn't create data pipe: %s", g_strerror(errno));
824         ws_close(sync_pipe[PIPE_READ]);
825         ws_close(sync_pipe[PIPE_WRITE]);
826         for (i = 0; argv[i] != NULL; i++) {
827             g_free( (gpointer) argv[i]);
828         }
829         g_free(argv);
830         return -1;
831     }
832
833     if ((*fork_child = fork()) == 0) {
834         /*
835          * Child process - run dumpcap with the right arguments to make
836          * it just capture with the specified capture parameters
837          */
838         dup2(data_pipe[PIPE_WRITE], 1);
839         ws_close(data_pipe[PIPE_READ]);
840         ws_close(data_pipe[PIPE_WRITE]);
841         dup2(sync_pipe[PIPE_WRITE], 2);
842         ws_close(sync_pipe[PIPE_READ]);
843         ws_close(sync_pipe[PIPE_WRITE]);
844         execv(argv[0], (gpointer)argv);
845         g_snprintf(errmsg, sizeof errmsg, "Couldn't run %s in child process: %s",
846                    argv[0], g_strerror(errno));
847         sync_pipe_errmsg_to_parent(2, errmsg, "");
848
849         /* Exit with "_exit()", so that we don't close the connection
850            to the X server (and cause stuff buffered up by our parent but
851            not yet sent to be sent, as that stuff should only be sent by
852            our parent).  We've sent an error message to the parent, so
853            we exit with an exit status of 1 (any exit status other than
854            0 or 1 will cause an additional message to report that exit
855            status, over and above the error message we sent to the parent). */
856         _exit(1);
857     }
858
859     *data_read_fd = data_pipe[PIPE_READ];
860     *message_read_fd = sync_pipe[PIPE_READ];
861 #endif
862
863     for (i = 0; argv[i] != NULL; i++) {
864         g_free( (gpointer) argv[i]);
865     }
866
867     /* Parent process - read messages from the child process over the
868        sync pipe. */
869     g_free( (gpointer) argv);   /* free up arg array */
870
871     /* Close the write sides of the pipes, so that only the child has them
872        open, and thus they completely close, and thus return to us
873        an EOF indication, if the child closes them (either deliberately
874        or by exiting abnormally). */
875 #ifdef _WIN32
876     CloseHandle(data_pipe[PIPE_WRITE]);
877     CloseHandle(sync_pipe[PIPE_WRITE]);
878 #else
879     ws_close(data_pipe[PIPE_WRITE]);
880     ws_close(sync_pipe[PIPE_WRITE]);
881 #endif
882
883     if (*fork_child == -1) {
884         /* We couldn't even create the child process. */
885         *msg = g_strdup_printf("Couldn't create child process: %s", g_strerror(errno));
886         ws_close(*data_read_fd);
887         ws_close(*message_read_fd);
888         return -1;
889     }
890
891     /* we might wait for a moment till child is ready, so update screen now */
892     main_window_update();
893     return 0;
894 }
895
896 /*
897  * Wait for dumpcap to finish.  On success, *msg is unchanged, and 0 is
898  * returned.  On failure, *msg points to an error message for the
899  * failure, and -1 is returned.  In the latter case, *msg must be
900  * freed with g_free().
901  */
902 static int
903 sync_pipe_close_command(int *data_read_fd, int *message_read_fd,
904                         int *fork_child, gchar **msg)
905 {
906     ws_close(*data_read_fd);
907     if (message_read_fd != NULL)
908         ws_close(*message_read_fd);
909
910 #ifdef _WIN32
911     /* XXX - Should we signal the child somehow? */
912     sync_pipe_kill(*fork_child);
913 #endif
914
915     return sync_pipe_wait_for_child(*fork_child, msg);
916 }
917
918 /*
919  * Run dumpcap with the supplied arguments.
920  *
921  * On success, *data points to a buffer containing the dumpcap output,
922  * *primary_msg and *secondary_message are NULL, and 0 is returned; *data
923  * must be freed with g_free().
924  *
925  * On failure, *data is NULL, *primary_msg points to an error message,
926  * *secondary_msg either points to an additional error message or is
927  * NULL, and -1 is returned; *primary_msg, and *secondary_msg if not NULL,
928  * must be freed with g_free().
929  */
930 /* XXX - This duplicates a lot of code in sync_pipe_start() */
931 /* XXX - assumes PIPE_BUF_SIZE > SP_MAX_MSG_LEN */
932 #define PIPE_BUF_SIZE 5120
933 static int
934 sync_pipe_run_command(const char** argv, gchar **data, gchar **primary_msg,
935                       gchar **secondary_msg)
936 {
937     gchar *msg;
938     int data_pipe_read_fd, sync_pipe_read_fd, fork_child, ret;
939     char *wait_msg;
940     gchar buffer[PIPE_BUF_SIZE+1];
941     int  nread;
942     char indicator;
943     int  primary_msg_len;
944     char *primary_msg_text;
945     int  secondary_msg_len;
946     char *secondary_msg_text;
947     char *combined_msg;
948     GString *data_buf = NULL;
949     int count;
950
951     ret = sync_pipe_open_command(argv, &data_pipe_read_fd, &sync_pipe_read_fd,
952                                  &fork_child, &msg);
953     if (ret == -1) {
954         *primary_msg = msg;
955         *secondary_msg = NULL;
956         *data = NULL;
957         return -1;
958     }
959
960     /*
961      * We were able to set up to read dumpcap's output.  Do so.
962      *
963      * First, wait for an SP_ERROR_MSG message or SP_SUCCESS message.
964      */
965     nread = pipe_read_block(sync_pipe_read_fd, &indicator, SP_MAX_MSG_LEN,
966                             buffer, primary_msg);
967     if(nread <= 0) {
968         /* We got a read error from the sync pipe, or we got no data at
969            all from the sync pipe, so we're not going to be getting any
970            data or error message from the child process.  Pick up its
971            exit status, and complain.
972
973            We don't have to worry about killing the child, if the sync pipe
974            returned an error. Usually this error is caused as the child killed
975            itself while going down. Even in the rare cases that this isn't the
976            case, the child will get an error when writing to the broken pipe
977            the next time, cleaning itself up then. */
978         ret = sync_pipe_wait_for_child(fork_child, &wait_msg);
979         if(nread == 0) {
980             /* We got an EOF from the sync pipe.  That means that it exited
981                before giving us any data to read.  If ret is -1, we report
982                that as a bad exit (e.g., exiting due to a signal); otherwise,
983                we report it as a premature exit. */
984             if (ret == -1)
985                 *primary_msg = wait_msg;
986             else
987                 *primary_msg = g_strdup("Child dumpcap closed sync pipe prematurely");
988         } else {
989             /* We got an error from the sync pipe.  If ret is -1, report
990                both the sync pipe I/O error and the wait error. */
991             if (ret == -1) {
992                 combined_msg = g_strdup_printf("%s\n\n%s", *primary_msg, wait_msg);
993                 g_free(*primary_msg);
994                 g_free(wait_msg);
995                 *primary_msg = combined_msg;
996             }
997         }
998         *secondary_msg = NULL;
999
1000         return -1;
1001     }
1002
1003     /* we got a valid message block from the child, process it */
1004     switch(indicator) {
1005
1006     case SP_ERROR_MSG:
1007         /*
1008          * Error from dumpcap; there will be a primary message and a
1009          * secondary message.
1010          */
1011
1012         /* convert primary message */
1013         pipe_convert_header(buffer, 4, &indicator, &primary_msg_len);
1014         primary_msg_text = buffer+4;
1015         /* convert secondary message */
1016         pipe_convert_header(primary_msg_text + primary_msg_len, 4, &indicator,
1017                             &secondary_msg_len);
1018         secondary_msg_text = primary_msg_text + primary_msg_len + 4;
1019         /* the capture child will close the sync_pipe, nothing to do */
1020
1021         /*
1022          * Pick up the child status.
1023          */
1024         ret = sync_pipe_close_command(&data_pipe_read_fd, &sync_pipe_read_fd,
1025                                       &fork_child, &msg);
1026         if (ret == -1) {
1027             /*
1028              * Child process failed unexpectedly, or wait failed; msg is the
1029              * error message.
1030              */
1031             *primary_msg = msg;
1032             *secondary_msg = NULL;
1033         } else {
1034             /*
1035              * Child process failed, but returned the expected exit status.
1036              * Return the messages it gave us, and indicate failure.
1037              */
1038             *primary_msg = g_strdup(primary_msg_text);
1039             *secondary_msg = g_strdup(secondary_msg_text);
1040             ret = -1;
1041         }
1042         *data = NULL;
1043         break;
1044
1045     case SP_SUCCESS:
1046         /* read the output from the command */
1047         data_buf = g_string_new("");
1048         while ((count = ws_read(data_pipe_read_fd, buffer, PIPE_BUF_SIZE)) > 0) {
1049             buffer[count] = '\0';
1050             g_string_append(data_buf, buffer);
1051         }
1052
1053         /*
1054          * Pick up the child status.
1055          */
1056         ret = sync_pipe_close_command(&data_pipe_read_fd, &sync_pipe_read_fd,
1057                                       &fork_child, &msg);
1058         if (ret == -1) {
1059             /*
1060              * Child process failed unexpectedly, or wait failed; msg is the
1061              * error message.
1062              */
1063             *primary_msg = msg;
1064             *secondary_msg = NULL;
1065             g_string_free(data_buf, TRUE);
1066             *data = NULL;
1067         } else {
1068             /*
1069              * Child process succeeded.
1070              */
1071             *primary_msg = NULL;
1072             *secondary_msg = NULL;
1073             *data = data_buf->str;
1074             g_string_free(data_buf, FALSE);
1075         }
1076         break;
1077
1078     default:
1079         /*
1080          * Pick up the child status.
1081          */
1082         ret = sync_pipe_close_command(&data_pipe_read_fd, &sync_pipe_read_fd,
1083                                       &fork_child, &msg);
1084         if (ret == -1) {
1085             /*
1086              * Child process failed unexpectedly, or wait failed; msg is the
1087              * error message.
1088              */
1089             *primary_msg = msg;
1090             *secondary_msg = NULL;
1091         } else {
1092             /*
1093              * Child process returned an unknown status.
1094              */
1095             *primary_msg = g_strdup_printf("dumpcap process gave an unexpected message type: 0x%02x",
1096                                            indicator);
1097             *secondary_msg = NULL;
1098             ret = -1;
1099         }
1100         *data = NULL;
1101         break;
1102     }
1103     return ret;
1104 }
1105
1106 /*
1107  * Get the list of interfaces using dumpcap.
1108  *
1109  * On success, *data points to a buffer containing the dumpcap output,
1110  * *primary_msg and *secondary_msg are NULL, and 0 is returned.  *data
1111  * must be freed with g_free().
1112  *
1113  * On failure, *data is NULL, *primary_msg points to an error message,
1114  * *secondary_msg either points to an additional error message or is
1115  * NULL, and -1 is returned; *primary_msg, and *secondary_msg if not NULL,
1116  * must be freed with g_free().
1117  */
1118 int
1119 sync_interface_list_open(gchar **data, gchar **primary_msg,
1120                          gchar **secondary_msg)
1121 {
1122     int argc;
1123     const char **argv;
1124
1125     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_interface_list_open");
1126
1127     argv = init_pipe_args(&argc);
1128
1129     if (!argv) {
1130         *primary_msg = g_strdup("We don't know where to find dumpcap.");
1131         *secondary_msg = NULL;
1132         *data = NULL;
1133         return -1;
1134     }
1135
1136     /* Ask for the interface list */
1137     argv = sync_pipe_add_arg(argv, &argc, "-D");
1138
1139 #ifndef DEBUG_CHILD
1140     /* Run dumpcap in capture child mode */
1141     argv = sync_pipe_add_arg(argv, &argc, "-Z");
1142     argv = sync_pipe_add_arg(argv, &argc, SIGNAL_PIPE_CTRL_ID_NONE);
1143 #endif
1144     return sync_pipe_run_command(argv, data, primary_msg, secondary_msg);
1145 }
1146
1147 /*
1148  * Get the capabilities of an interface using dumpcap.
1149  *
1150  * On success, *data points to a buffer containing the dumpcap output,
1151  * *primary_msg and *secondary_msg are NULL, and 0 is returned.  *data
1152  * must be freed with g_free().
1153  *
1154  * On failure, *data is NULL, *primary_msg points to an error message,
1155  * *secondary_msg either points to an additional error message or is
1156  * NULL, and -1 is returned; *primary_msg, and *secondary_msg if not NULL,
1157  * must be freed with g_free().
1158  */
1159 int
1160 sync_if_capabilities_open(const gchar *ifname, gboolean monitor_mode,
1161                           gchar **data, gchar **primary_msg,
1162                           gchar **secondary_msg)
1163 {
1164     int argc;
1165     const char **argv;
1166
1167     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_linktype_list_open");
1168
1169     argv = init_pipe_args(&argc);
1170
1171     if (!argv) {
1172         *primary_msg = g_strdup("We don't know where to find dumpcap.");
1173         *secondary_msg = NULL;
1174         *data = NULL;
1175         return -1;
1176     }
1177
1178     /* Ask for the interface capabilities */
1179     argv = sync_pipe_add_arg(argv, &argc, "-i");
1180     argv = sync_pipe_add_arg(argv, &argc, ifname);
1181     argv = sync_pipe_add_arg(argv, &argc, "-L");
1182     if (monitor_mode)
1183         argv = sync_pipe_add_arg(argv, &argc, "-I");
1184
1185 #ifndef DEBUG_CHILD
1186     /* Run dumpcap in capture child mode */
1187     argv = sync_pipe_add_arg(argv, &argc, "-Z");
1188     argv = sync_pipe_add_arg(argv, &argc, SIGNAL_PIPE_CTRL_ID_NONE);
1189 #endif
1190     return sync_pipe_run_command(argv, data, primary_msg, secondary_msg);
1191 }
1192
1193 /*
1194  * Start getting interface statistics using dumpcap.  On success, read_fd
1195  * contains the file descriptor for the pipe's stdout, *msg is unchanged,
1196  * and zero is returned.  On failure, *msg will point to an error message
1197  * that must be g_free()d, and -1 will be returned.
1198  */
1199 int
1200 sync_interface_stats_open(int *data_read_fd, int *fork_child, gchar **msg)
1201 {
1202     int argc;
1203     const char **argv;
1204     int message_read_fd, ret;
1205     char *wait_msg;
1206     gchar buffer[PIPE_BUF_SIZE+1];
1207     int  nread;
1208     char indicator;
1209     int  primary_msg_len;
1210     char *primary_msg_text;
1211     int  secondary_msg_len;
1212     /*char *secondary_msg_text;*/
1213     char *combined_msg;
1214
1215     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_interface_stats_open");
1216
1217     argv = init_pipe_args(&argc);
1218
1219     if (!argv) {
1220         *msg = g_strdup("We don't know where to find dumpcap.");
1221         return -1;
1222     }
1223
1224     /* Ask for the interface statistics */
1225     argv = sync_pipe_add_arg(argv, &argc, "-S");
1226
1227 #ifndef DEBUG_CHILD
1228     argv = sync_pipe_add_arg(argv, &argc, "-Z");
1229     argv = sync_pipe_add_arg(argv, &argc, SIGNAL_PIPE_CTRL_ID_NONE);
1230 #endif
1231     ret = sync_pipe_open_command(argv, data_read_fd, &message_read_fd,
1232                                  fork_child, msg);
1233     if (ret == -1)
1234         return -1;
1235
1236     /*
1237      * We were able to set up to read dumpcap's output.  Do so.
1238      *
1239      * First, wait for an SP_ERROR_MSG message or SP_SUCCESS message.
1240      */
1241     nread = pipe_read_block(message_read_fd, &indicator, SP_MAX_MSG_LEN,
1242                             buffer, msg);
1243     if(nread <= 0) {
1244         /* We got a read error from the sync pipe, or we got no data at
1245            all from the sync pipe, so we're not going to be getting any
1246            data or error message from the child process.  Pick up its
1247            exit status, and complain.
1248
1249            We don't have to worry about killing the child, if the sync pipe
1250            returned an error. Usually this error is caused as the child killed
1251            itself while going down. Even in the rare cases that this isn't the
1252            case, the child will get an error when writing to the broken pipe
1253            the next time, cleaning itself up then. */
1254         ret = sync_pipe_wait_for_child(*fork_child, &wait_msg);
1255         if(nread == 0) {
1256             /* We got an EOF from the sync pipe.  That means that it exited
1257                before giving us any data to read.  If ret is -1, we report
1258                that as a bad exit (e.g., exiting due to a signal); otherwise,
1259                we report it as a premature exit. */
1260             if (ret == -1)
1261                 *msg = wait_msg;
1262             else
1263                 *msg = g_strdup("Child dumpcap closed sync pipe prematurely");
1264         } else {
1265             /* We got an error from the sync pipe.  If ret is -1, report
1266                both the sync pipe I/O error and the wait error. */
1267             if (ret == -1) {
1268                 combined_msg = g_strdup_printf("%s\n\n%s", *msg, wait_msg);
1269                 g_free(*msg);
1270                 g_free(wait_msg);
1271                 *msg = combined_msg;
1272             }
1273         }
1274
1275         return -1;
1276     }
1277
1278     /* we got a valid message block from the child, process it */
1279     switch(indicator) {
1280
1281     case SP_ERROR_MSG:
1282         /*
1283          * Error from dumpcap; there will be a primary message and a
1284          * secondary message.
1285          */
1286
1287         /* convert primary message */
1288         pipe_convert_header(buffer, 4, &indicator, &primary_msg_len);
1289         primary_msg_text = buffer+4;
1290         /* convert secondary message */
1291         pipe_convert_header(primary_msg_text + primary_msg_len, 4, &indicator,
1292                             &secondary_msg_len);
1293         /*secondary_msg_text = primary_msg_text + primary_msg_len + 4;*/
1294         /* the capture child will close the sync_pipe, nothing to do */
1295
1296         /*
1297          * Pick up the child status.
1298          */
1299         ret = sync_pipe_close_command(data_read_fd, &message_read_fd,
1300                                       fork_child, msg);
1301         if (ret == -1) {
1302             /*
1303              * Child process failed unexpectedly, or wait failed; msg is the
1304              * error message.
1305              */
1306         } else {
1307             /*
1308              * Child process failed, but returned the expected exit status.
1309              * Return the messages it gave us, and indicate failure.
1310              */
1311             *msg = g_strdup(primary_msg_text);
1312             ret = -1;
1313         }
1314         break;
1315
1316     case SP_SUCCESS:
1317         /* Close the message pipe. */
1318         ws_close(message_read_fd);
1319         break;
1320
1321     default:
1322         /*
1323          * Pick up the child status.
1324          */
1325         ret = sync_pipe_close_command(data_read_fd, &message_read_fd,
1326                                       fork_child, msg);
1327         if (ret == -1) {
1328             /*
1329              * Child process failed unexpectedly, or wait failed; msg is the
1330              * error message.
1331              */
1332         } else {
1333             /*
1334              * Child process returned an unknown status.
1335              */
1336             *msg = g_strdup_printf("dumpcap process gave an unexpected message type: 0x%02x",
1337                                    indicator);
1338             ret = -1;
1339         }
1340         break;
1341     }
1342     return ret;
1343 }
1344
1345 /* Close down the stats process */
1346 int
1347 sync_interface_stats_close(int *read_fd, int *fork_child, gchar **msg)
1348 {
1349     return sync_pipe_close_command(read_fd, NULL, fork_child, msg);
1350 }
1351
1352 /* read a number of bytes from a pipe */
1353 /* (blocks until enough bytes read or an error occurs) */
1354 static int
1355 pipe_read_bytes(int pipe_fd, char *bytes, int required, char **msg)
1356 {
1357     int newly;
1358     int offset = 0;
1359     int error;
1360
1361     while(required) {
1362         newly = read(pipe_fd, &bytes[offset], required);
1363         if (newly == 0) {
1364             /* EOF */
1365             g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
1366                   "read from pipe %d: EOF (capture closed?)", pipe_fd);
1367             *msg = 0;
1368             return offset;
1369         }
1370         if (newly < 0) {
1371             /* error */
1372             error = errno;
1373             g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
1374                   "read from pipe %d: error(%u): %s", pipe_fd, error,
1375                   g_strerror(error));
1376             *msg = g_strdup_printf("Error reading from sync pipe: %s",
1377                                    g_strerror(error));
1378             return newly;
1379         }
1380
1381         required -= newly;
1382         offset += newly;
1383     }
1384
1385     *msg = NULL;
1386     return offset;
1387 }
1388
1389 static gboolean pipe_data_available(int pipe_fd) {
1390 #ifdef _WIN32 /* PeekNamedPipe */
1391     HANDLE hPipe = (HANDLE) _get_osfhandle(pipe_fd);
1392     DWORD bytes_avail;
1393
1394     if (hPipe == INVALID_HANDLE_VALUE)
1395         return FALSE;
1396
1397     if (! PeekNamedPipe(hPipe, NULL, 0, NULL, &bytes_avail, NULL))
1398         return FALSE;
1399
1400     if (bytes_avail > 0)
1401         return TRUE;
1402     return FALSE;
1403 #else /* select */
1404     fd_set rfds;
1405     struct timeval timeout;
1406
1407     FD_ZERO(&rfds);
1408     FD_SET(pipe_fd, &rfds);
1409     timeout.tv_sec = 0;
1410     timeout.tv_usec = 0;
1411
1412     if (select(pipe_fd+1, &rfds, NULL, NULL, &timeout) > 0)
1413         return TRUE;
1414
1415     return FALSE;
1416 #endif
1417 }
1418
1419 /* Read a line from a pipe, similar to fgets */
1420 int
1421 sync_pipe_gets_nonblock(int pipe_fd, char *bytes, int max) {
1422     int newly;
1423     int offset = -1;
1424
1425     while(offset < max - 1) {
1426         offset++;
1427         if (! pipe_data_available(pipe_fd))
1428             break;
1429         newly = read(pipe_fd, &bytes[offset], 1);
1430         if (newly == 0) {
1431             /* EOF - not necessarily an error */
1432             break;
1433         } else if (newly < 0) {
1434             /* error */
1435             g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
1436                   "read from pipe %d: error(%u): %s", pipe_fd, errno, g_strerror(errno));
1437             return newly;
1438         } else if (bytes[offset] == '\n') {
1439             break;
1440         }
1441     }
1442
1443     if (offset >= 0)
1444         bytes[offset] = '\0';
1445
1446     return offset;
1447 }
1448
1449
1450 /* convert header values (indicator and 3-byte length) */
1451 static void
1452 pipe_convert_header(const guchar *header, int header_len, char *indicator, int *block_len) {
1453
1454     g_assert(header_len == 4);
1455
1456     /* convert header values */
1457     *indicator = header[0];
1458     *block_len = header[1]<<16 | header[2]<<8 | header[3];
1459 }
1460
1461 /* read a message from the sending pipe in the standard format
1462    (1-byte message indicator, 3-byte message length (excluding length
1463    and indicator field), and the rest is the message) */
1464 static int
1465 pipe_read_block(int pipe_fd, char *indicator, int len, char *msg,
1466                 char **err_msg)
1467 {
1468     int required;
1469     int newly;
1470     guchar header[4];
1471
1472     /* read header (indicator and 3-byte length) */
1473     newly = pipe_read_bytes(pipe_fd, header, 4, err_msg);
1474     if(newly != 4) {
1475         if (newly == 0) {
1476             /*
1477              * Immediate EOF; if the capture child exits normally, this
1478              * is an "I'm done" indication, so don't report it as an
1479              * error.
1480              */
1481             g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
1482                   "read %d got an EOF", pipe_fd);
1483             return 0;
1484         }
1485         g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
1486               "read %d failed to read header: %u", pipe_fd, newly);
1487         if (newly != -1) {
1488             /*
1489              * Short read, but not an immediate EOF.
1490              */
1491             *err_msg = g_strdup_printf("Premature EOF reading from sync pipe: got only %d bytes",
1492                                        newly);
1493         }
1494         return -1;
1495     }
1496
1497     /* convert header values */
1498     pipe_convert_header(header, 4, indicator, &required);
1499
1500     /* only indicator with no value? */
1501     if(required == 0) {
1502         g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
1503               "read %d indicator: %c empty value", pipe_fd, *indicator);
1504         return 4;
1505     }
1506
1507     /* does the data fit into the given buffer? */
1508     if(required > len) {
1509         g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
1510               "read %d length error, required %d > len %d, indicator: %u",
1511               pipe_fd, required, len, *indicator);
1512
1513         /* we have a problem here, try to read some more bytes from the pipe to debug where the problem really is */
1514         memcpy(msg, header, sizeof(header));
1515         newly = read(pipe_fd, &msg[sizeof(header)], len-sizeof(header));
1516         *err_msg = g_strdup_printf("Unknown message from dumpcap, try to show it as a string: %s",
1517                                    msg);
1518         return -1;
1519     }
1520     len = required;
1521
1522     /* read the actual block data */
1523     newly = pipe_read_bytes(pipe_fd, msg, required, err_msg);
1524     if(newly != required) {
1525         if (newly != -1) {
1526             *err_msg = g_strdup_printf("Unknown message from dumpcap, try to show it as a string: %s",
1527                                        msg);
1528         }
1529         return -1;
1530     }
1531
1532     /* XXX If message is "2part", the msg probably won't be sent to debug log correctly */
1533     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
1534           "read %d ok indicator: %c len: %u msg: %s", pipe_fd, *indicator,
1535           len, msg);
1536     *err_msg = NULL;
1537     return newly + 4;
1538 }
1539
1540
1541 /* There's stuff to read from the sync pipe, meaning the child has sent
1542    us a message, or the sync pipe has closed, meaning the child has
1543    closed it (perhaps because it exited). */
1544 static gboolean
1545 sync_pipe_input_cb(gint source, gpointer user_data)
1546 {
1547     capture_options *capture_opts = (capture_options *)user_data;
1548     int  ret;
1549     char buffer[SP_MAX_MSG_LEN+1];
1550     int  nread;
1551     char indicator;
1552     int  primary_len;
1553     char *primary_msg;
1554     int  secondary_len;
1555     char *secondary_msg;
1556     char *wait_msg, *combined_msg;
1557
1558     nread = pipe_read_block(source, &indicator, SP_MAX_MSG_LEN, buffer,
1559                             &primary_msg);
1560     if(nread <= 0) {
1561         /* We got a read error, or a bad message, or an EOF, from the sync pipe.
1562
1563            If we got a read error or a bad message, nread is -1 and
1564            primary_msg is set to point to an error message.  We don't
1565            have to worry about killing the child; usually this error
1566            is caused as the child killed  itself while going down.
1567            Even in the rare cases that this isn't the case, the child
1568            will get an error when writing to the broken pipe the next time,
1569            cleaning itself up then.
1570
1571            If we got an EOF, nread is 0 and primary_msg isn't set.  This
1572            is an indication that the capture is finished. */
1573         ret = sync_pipe_wait_for_child(capture_opts->fork_child, &wait_msg);
1574         if(nread == 0) {
1575             /* We got an EOF from the sync pipe.  That means that the capture
1576                child exited, and not in the middle of a message; we treat
1577                that as an indication that it's done, and only report an
1578                error if ret is -1, in which case wait_msg is the error
1579                message. */
1580             if (ret == -1)
1581                 primary_msg = wait_msg;
1582         } else {
1583             /* We got an error from the sync pipe.  If ret is -1, report
1584                both the sync pipe I/O error and the wait error. */
1585             if (ret == -1) {
1586                 combined_msg = g_strdup_printf("%s\n\n%s", primary_msg, wait_msg);
1587                 g_free(primary_msg);
1588                 g_free(wait_msg);
1589                 primary_msg = combined_msg;
1590             }
1591         }
1592
1593         /* No more child process. */
1594         capture_opts->fork_child = -1;
1595         capture_opts->fork_child_status = ret;
1596
1597 #ifdef _WIN32
1598         ws_close(capture_opts->signal_pipe_write_fd);
1599 #endif
1600         capture_input_closed(capture_opts, primary_msg);
1601         g_free(primary_msg);
1602         return FALSE;
1603     }
1604
1605     /* we got a valid message block from the child, process it */
1606     switch(indicator) {
1607     case SP_FILE:
1608         if(!capture_input_new_file(capture_opts, buffer)) {
1609             g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_input_cb: file failed, closing capture");
1610
1611             /* We weren't able to open the new capture file; user has been
1612                alerted. Close the sync pipe. */
1613             ws_close(source);
1614
1615             /* The child has sent us a filename which we couldn't open.
1616
1617                This could mean that the child is creating files faster
1618                than we can handle it.  (XXX - why would that result in
1619                a failure to open the file?)
1620
1621                That should only be the case for very fast file switches;
1622                We can't do much more than telling the child to stop.
1623                (This is the "emergency brake" if the user e.g. wants to
1624                switch files every second). */
1625
1626                This can also happen if the user specified "-", meaning
1627                "standard output", as the capture file. */
1628             sync_pipe_stop(capture_opts);
1629             capture_input_closed(capture_opts, NULL);
1630             return FALSE;
1631         }
1632         break;
1633     case SP_PACKET_COUNT:
1634         nread = atoi(buffer);
1635         g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_input_cb: new packets %u", nread);
1636         capture_input_new_packets(capture_opts, nread);
1637         break;
1638     case SP_ERROR_MSG:
1639         /* convert primary message */
1640         pipe_convert_header(buffer, 4, &indicator, &primary_len);
1641         primary_msg = buffer+4;
1642         /* convert secondary message */
1643         pipe_convert_header(primary_msg + primary_len, 4, &indicator, &secondary_len);
1644         secondary_msg = primary_msg + primary_len + 4;
1645         /* message output */
1646         capture_input_error_message(capture_opts, primary_msg, secondary_msg);
1647         /* the capture child will close the sync_pipe, nothing to do for now */
1648         /* (an error message doesn't mean we have to stop capturing) */
1649         break;
1650     case SP_BAD_FILTER: {
1651         char *ch;
1652         int index;
1653
1654         ch = strtok(buffer, ":");
1655         index = (int)strtol(ch, NULL, 10);
1656         ch = strtok(NULL, ":");
1657         capture_input_cfilter_error_message(capture_opts, index, ch);
1658          /* the capture child will close the sync_pipe, nothing to do for now */
1659          break;
1660         }
1661     case SP_DROPS:
1662         capture_input_drops(capture_opts, (guint32)strtoul(buffer, NULL, 10));
1663         break;
1664     default:
1665         g_assert_not_reached();
1666     }
1667
1668     return TRUE;
1669 }
1670
1671
1672
1673 /* the child process is going down, wait until it's completely terminated */
1674 static int
1675 sync_pipe_wait_for_child(int fork_child, gchar **msgp)
1676 {
1677     int fork_child_status;
1678     int ret;
1679
1680     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_wait_for_child: wait till child closed");
1681     g_assert(fork_child != -1);
1682
1683     *msgp = NULL; /* assume no error */
1684     ret = 0;
1685 #ifdef _WIN32
1686     if (_cwait(&fork_child_status, fork_child, _WAIT_CHILD) == -1) {
1687         *msgp = g_strdup_printf("Error from cwait(): %s", g_strerror(errno));
1688         ret = -1;
1689     } else {
1690         /*
1691          * The child exited; return its exit status.  Do not treat this as
1692          * an error.
1693          */
1694         ret = fork_child_status;
1695         if ((fork_child_status & 0xC0000000) == ERROR_SEVERITY_ERROR) {
1696             /* Probably an exception code */
1697             *msgp = g_strdup_printf("Child dumpcap process died: %s",
1698                                     win32strexception(fork_child_status));
1699             ret = -1;
1700         }
1701     }
1702 #else
1703     if (waitpid(fork_child, &fork_child_status, 0) != -1) {
1704         if (WIFEXITED(fork_child_status)) {
1705             /*
1706              * The child exited; return its exit status.  Do not treat this as
1707              * an error.
1708              */
1709             ret = WEXITSTATUS(fork_child_status);
1710         } else if (WIFSTOPPED(fork_child_status)) {
1711             /* It stopped, rather than exiting.  "Should not happen." */
1712             *msgp = g_strdup_printf("Child dumpcap process stopped: %s",
1713                                     sync_pipe_signame(WSTOPSIG(fork_child_status)));
1714             ret = -1;
1715         } else if (WIFSIGNALED(fork_child_status)) {
1716             /* It died with a signal. */
1717             *msgp = g_strdup_printf("Child dumpcap process died: %s%s",
1718                                     sync_pipe_signame(WTERMSIG(fork_child_status)),
1719                                     WCOREDUMP(fork_child_status) ? " - core dumped" : "");
1720             ret = -1;
1721         } else {
1722             /* What?  It had to either have exited, or stopped, or died with
1723                a signal; what happened here? */
1724             *msgp = g_strdup_printf("Bad status from waitpid(): %#o",
1725                                     fork_child_status);
1726             ret = -1;
1727         }
1728     } else {
1729         *msgp = g_strdup_printf("Error from waitpid(): %s", g_strerror(errno));
1730         ret = -1;
1731     }
1732 #endif
1733
1734     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_wait_for_child: capture child closed");
1735     return ret;
1736 }
1737
1738
1739 #ifndef _WIN32
1740 /* convert signal to corresponding name */
1741 static const char *
1742 sync_pipe_signame(int sig)
1743 {
1744     const char *sigmsg;
1745     static char sigmsg_buf[6+1+3+1];
1746
1747     switch (sig) {
1748
1749     case SIGHUP:
1750         sigmsg = "Hangup";
1751         break;
1752
1753     case SIGINT:
1754         sigmsg = "Interrupted";
1755         break;
1756
1757     case SIGQUIT:
1758         sigmsg = "Quit";
1759         break;
1760
1761     case SIGILL:
1762         sigmsg = "Illegal instruction";
1763         break;
1764
1765     case SIGTRAP:
1766         sigmsg = "Trace trap";
1767         break;
1768
1769     case SIGABRT:
1770         sigmsg = "Abort";
1771         break;
1772
1773     case SIGFPE:
1774         sigmsg = "Arithmetic exception";
1775         break;
1776
1777     case SIGKILL:
1778         sigmsg = "Killed";
1779         break;
1780
1781     case SIGBUS:
1782         sigmsg = "Bus error";
1783         break;
1784
1785     case SIGSEGV:
1786         sigmsg = "Segmentation violation";
1787         break;
1788
1789         /* http://metalab.unc.edu/pub/Linux/docs/HOWTO/GCC-HOWTO
1790            Linux is POSIX compliant.  These are not POSIX-defined signals ---
1791            ISO/IEC 9945-1:1990 (IEEE Std 1003.1-1990), paragraph B.3.3.1.1 sez:
1792
1793            ``The signals SIGBUS, SIGEMT, SIGIOT, SIGTRAP, and SIGSYS
1794            were omitted from POSIX.1 because their behavior is
1795            implementation dependent and could not be adequately catego-
1796            rized.  Conforming implementations may deliver these sig-
1797            nals, but must document the circumstances under which they
1798            are delivered and note any restrictions concerning their
1799            delivery.''
1800
1801            So we only check for SIGSYS on those systems that happen to
1802            implement them (a system can be POSIX-compliant and implement
1803            them, it's just that POSIX doesn't *require* a POSIX-compliant
1804            system to implement them).
1805         */
1806
1807 #ifdef SIGSYS
1808     case SIGSYS:
1809         sigmsg = "Bad system call";
1810         break;
1811 #endif
1812
1813     case SIGPIPE:
1814         sigmsg = "Broken pipe";
1815         break;
1816
1817     case SIGALRM:
1818         sigmsg = "Alarm clock";
1819         break;
1820
1821     case SIGTERM:
1822         sigmsg = "Terminated";
1823         break;
1824
1825     default:
1826         /* Returning a static buffer is ok in the context we use it here */
1827         g_snprintf(sigmsg_buf, sizeof sigmsg_buf, "Signal %d", sig);
1828         sigmsg = sigmsg_buf;
1829         break;
1830     }
1831     return sigmsg;
1832 }
1833 #endif
1834
1835
1836 #ifdef _WIN32
1837 /* tell the child through the signal pipe that we want to quit the capture */
1838 static void
1839 signal_pipe_capquit_to_child(capture_options *capture_opts)
1840 {
1841     const char quit_msg[] = "QUIT";
1842     int ret;
1843
1844
1845     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "signal_pipe_capquit_to_child");
1846
1847     /* it doesn't matter *what* we send here, the first byte will stop the capture */
1848     /* simply sending a "QUIT" string */
1849     /*pipe_write_block(capture_opts->signal_pipe_write_fd, SP_QUIT, quit_msg);*/
1850     ret = write(capture_opts->signal_pipe_write_fd, quit_msg, sizeof quit_msg);
1851     if(ret == -1) {
1852         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_WARNING,
1853               "signal_pipe_capquit_to_child: %d header: error %s", capture_opts->signal_pipe_write_fd, g_strerror(errno));
1854     }
1855 }
1856 #endif
1857
1858
1859 /* user wants to stop the capture run */
1860 void
1861 sync_pipe_stop(capture_options *capture_opts)
1862 {
1863 #ifdef _WIN32
1864     int count;
1865     DWORD childstatus;
1866     gboolean terminate = TRUE;
1867 #endif
1868
1869     if (capture_opts->fork_child != -1) {
1870 #ifndef _WIN32
1871         /* send the SIGINT signal to close the capture child gracefully. */
1872         int sts = kill(capture_opts->fork_child, SIGINT);
1873         if (sts != 0) {
1874             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_WARNING,
1875                   "Sending SIGINT to child failed: %s\n", g_strerror(errno));
1876         }
1877 #else
1878 #define STOP_SLEEP_TIME 500 /* ms */
1879 #define STOP_CHECK_TIME 50
1880         /* First, use the special signal pipe to try to close the capture child
1881          * gracefully.
1882          */
1883         signal_pipe_capquit_to_child(capture_opts);
1884
1885         /* Next, wait for the process to exit on its own */
1886         for (count = 0; count < STOP_SLEEP_TIME / STOP_CHECK_TIME; count++) {
1887             if (GetExitCodeProcess((HANDLE) capture_opts->fork_child, &childstatus) &&
1888                 childstatus != STILL_ACTIVE) {
1889                 terminate = FALSE;
1890                 break;
1891             }
1892             Sleep(STOP_CHECK_TIME);
1893         }
1894
1895         /* Force the issue. */
1896         if (terminate) {
1897             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_WARNING,
1898                   "sync_pipe_stop: forcing child to exit");
1899             sync_pipe_kill(capture_opts->fork_child);
1900         }
1901 #endif
1902     }
1903 }
1904
1905
1906 /* Wireshark has to exit, force the capture child to close */
1907 void
1908 sync_pipe_kill(int fork_child)
1909 {
1910     if (fork_child != -1) {
1911 #ifndef _WIN32
1912         int sts = kill(fork_child, SIGTERM);    /* SIGTERM so it can clean up if necessary */
1913         if (sts != 0) {
1914             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_WARNING,
1915                   "Sending SIGTERM to child failed: %s\n", g_strerror(errno));
1916         }
1917 #else
1918         /* Remark: This is not the preferred method of closing a process!
1919          * the clean way would be getting the process id of the child process,
1920          * then getting window handle hWnd of that process (using EnumChildWindows),
1921          * and then do a SendMessage(hWnd, WM_CLOSE, 0, 0)
1922          *
1923          * Unfortunately, I don't know how to get the process id from the
1924          * handle.  OpenProcess will get an handle (not a window handle)
1925          * from the process ID; it will not get a window handle from the
1926          * process ID.  (How could it?  A process can have more than one
1927          * window.  For that matter, a process might have *no* windows,
1928          * as a process running dumpcap, the normal child process program,
1929          * probably does.)
1930          *
1931          * Hint: GenerateConsoleCtrlEvent() will only work if both processes are
1932          * running in the same console; that's not necessarily the case for
1933          * us, as we might not be running in a console.
1934          * And this also will require to have the process id.
1935          */
1936         TerminateProcess((HANDLE) (fork_child), 0);
1937 #endif
1938     }
1939 }
1940
1941 #endif /* HAVE_LIBPCAP */