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