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