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