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