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