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