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