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