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