alert_box.c \
capture.c \
capture_info.c \
- capture_loop.c \
capture_opts.c \
capture_sync.c \
color_filters.c \
static gboolean
signal_pipe_stopped(void)
{
- /* some news from our parent (signal pipe)? -> just stop the capture */
+ /* any news from our parent (stdin)? -> just stop the capture */
HANDLE handle;
DWORD avail = 0;
gboolean result;
- handle = (HANDLE) _get_osfhandle (0);
+ handle = (HANDLE) GetStdHandle(STD_INPUT_HANDLE);
result = PeekNamedPipe(handle, NULL, 0, NULL, &avail, NULL);
- /*g_warning("check pipe: handle: %x result: %u avail: %u", handle, result, avail);*/
-
if(!result || avail > 0) {
/* peek failed or some bytes really available */
+
+ /* XXX - if not piping from stdin this fails */
+ /*g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
+ "Signal pipe: handle: %x result: %u avail: %u", handle, result, avail);
+ return FALSE;*/
return TRUE;
} else {
/* pipe ok and no bytes available */
inpkts = capture_loop_dispatch(capture_opts, &ld, errmsg, sizeof(errmsg));
#ifdef _WIN32
- /*fprintf(stderr, "fd: %u ret: %u\n", capture_opts->signal_pipe_fd, signal_pipe_stopped());*/
+ /*fprintf(stderr, "signal pipe ret: %u\n", signal_pipe_stopped());*/
/* any news from our parent (signal pipe)? -> just stop the capture */
- if (capture_opts->signal_pipe_fd != -1 && signal_pipe_stopped()) {
+ if (signal_pipe_stopped()) {
ld.go = FALSE;
}
#endif
capture_opts->fork_child = -1; /* invalid process handle */
#ifdef _WIN32
- capture_opts->signal_pipe_fd = -1;
+ capture_opts->signal_pipe_write_fd = -1;
#endif
capture_opts->state = CAPTURE_STOPPED;
capture_opts->output_to_pipe = FALSE;
g_log(log_domain, log_level, "ForkChild : %d", capture_opts->fork_child);
#ifdef _WIN32
- g_log(log_domain, log_level, "SignalPipeFd : %d", capture_opts->signal_pipe_fd);
+ g_log(log_domain, log_level, "SignalPipeWrite : %d", capture_opts->signal_pipe_write_fd);
#endif
}
}
-#ifdef _WIN32
-/*
- * Given a string of the form "<pipe name>:<file descriptor>", as might appear
- * as an argument to a "-Z" option, parse it and set the arguments in
- * question. Return an indication of whether it succeeded or failed
- * in some fashion.
- */
-static gboolean
-get_pipe_arguments(capture_options *capture_opts, const char *arg)
-{
- gchar *p = NULL, *colonp;
- int pipe_fd;
-
-
- colonp = strchr(arg, ':');
- if (colonp == NULL)
- return TRUE;
-
- p = colonp;
- *p++ = '\0';
-
- /*
- * Skip over any white space (there probably won't be any, but
- * as we allow it in the preferences file, we might as well
- * allow it here).
- */
- while (isspace((guchar)*p))
- p++;
- if (*p == '\0') {
- /*
- * Put the colon back, so if our caller uses, in an
- * error message, the string they passed us, the message
- * looks correct.
- */
- *colonp = ':';
- return FALSE;
- }
-
- if (strcmp(arg,"sync") == 0) {
- /* associate stdout with sync pipe */
- pipe_fd = get_natural_int(p, "sync pipe file descriptor");
- if (dup2(pipe_fd, 1) < 0) {
- cmdarg_err("Unable to dup sync pipe handle");
- return FALSE;
- }
- } else if (strcmp(arg,"signal") == 0) {
- /* associate stdin with signal pipe */
- pipe_fd = get_natural_int(p, "signal pipe file descriptor");
- if (dup2(pipe_fd, 0) < 0) {
- cmdarg_err("Unable to dup signal pipe handle");
- return FALSE;
- }
- capture_opts->signal_pipe_fd = pipe_fd;
- }
-
- *colonp = ':'; /* put the colon back */
- return TRUE;
-}
-#endif
-
-
static int
capture_opts_add_iface_opt(capture_options *capture_opts, const char *optarg)
{
capture_opts->linktype = get_natural_int(optarg, "data link type");
#endif /* HAVE_PCAP_DATALINK_NAME_TO_VAL */
break;
-#ifdef _WIN32
- /* Hidden option supporting Sync mode */
- case 'Z': /* Write to pipe FD XXX */
- if (get_pipe_arguments(capture_opts, optarg) == FALSE) {
- cmdarg_err("Invalid or unknown -Z flag \"%s\"", optarg);
- return 1;
- }
- break;
-#endif /* _WIN32 */
default:
/* the caller is responsible to send us only the right opt's */
g_assert_not_reached();
/* internally used (don't touch from outside) */
int fork_child; /**< If not -1, in parent, process ID of child */
#ifdef _WIN32
- int signal_pipe_fd; /**< the pipe to signal the child */
+ int signal_pipe_write_fd; /**< the pipe to signal the child */
#endif
capture_state state; /**< current state of the capture engine */
gboolean output_to_pipe; /**< save_file is a pipe (named or stdout) */
/*g_warning("write %d leave", pipe);*/
}
+#ifdef _WIN32
+static void
+signal_pipe_capquit_to_child(capture_options *capture_opts)
+{
+
+ g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "signal_pipe_capquit_to_child");
+
+ pipe_write_block(capture_opts->signal_pipe_write_fd, SP_QUIT, 0, NULL);
+}
+#endif
+
+
/* read a message from the sending pipe in the standard format
(1-byte message indicator, 3-byte message length (excluding length
return 4;
}
- g_assert(required <= len);
+ if(required > len) {
+ return -1;
+ }
len = required;
/* read value */
return len + 4;
}
-void
-sync_pipe_packet_count_to_parent(int packet_count)
-{
- char tmp[SP_DECISIZE+1+1];
-
- g_snprintf(tmp, sizeof(tmp), "%d", packet_count);
-
- g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "sync_pipe_packet_count_to_parent: %s", tmp);
-
- pipe_write_block(1, SP_PACKET_COUNT, strlen(tmp)+1, tmp);
-}
-
-void
-sync_pipe_filename_to_parent(const char *filename)
-{
- g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "sync_pipe_filename_to_parent: %s", filename);
-
- pipe_write_block(1, SP_FILE, strlen(filename)+1, filename);
-}
-
-void
-sync_pipe_errmsg_to_parent(const char *errmsg)
-{
- g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "sync_pipe_errmsg_to_parent: %s", errmsg);
-
- pipe_write_block(1, SP_ERROR_MSG, strlen(errmsg)+1, errmsg);
-}
-
-void
-sync_pipe_drops_to_parent(int drops)
-{
- char tmp[SP_DECISIZE+1+1];
-
-
- g_snprintf(tmp, sizeof(tmp), "%d", drops);
-
- g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "sync_pipe_drops_to_parent: %s", tmp);
-
- pipe_write_block(1, SP_DROPS, strlen(tmp)+1, tmp);
-}
-
-
-#ifdef _WIN32
-
-static void
-signal_pipe_capquit_to_child(capture_options *capture_opts)
-{
-
- g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "signal_pipe_capquit_to_child");
-
- pipe_write_block(capture_opts->signal_pipe_fd, SP_QUIT, 0, NULL);
-}
-#endif
/* Add a string pointer to a NULL-terminated array of string pointers. */
char sautostop_duration[ARGV_NUMBER_LEN];
#ifdef _WIN32
char buffer_size[ARGV_NUMBER_LEN];
- char sync_pipe_fd[ARGV_NUMBER_LEN];
- char signal_pipe_fd[ARGV_NUMBER_LEN];
char *filterstring;
char *savefilestring;
- int signal_pipe[2]; /* pipe used to send messages from parent to child (currently only stop) */
+ HANDLE sync_pipe_read; /* pipe used to send messages from child to parent */
+ HANDLE sync_pipe_write; /* pipe used to send messages from child to parent */
+ HANDLE signal_pipe_read; /* pipe used to send messages from parent to child (currently only stop) */
+ HANDLE signal_pipe_write; /* pipe used to send messages from parent to child (currently only stop) */
+ GString *args = g_string_sized_new(200);
+ SECURITY_ATTRIBUTES sa;
+ STARTUPINFO si;
+ PROCESS_INFORMATION pi;
+ int i;
#else
char errmsg[1024+1];
+ int sync_pipe[2]; /* pipe used to send messages from child to parent */
+ enum PIPES { PIPE_READ, PIPE_WRITE }; /* Constants 0 and 1 for PIPE_READ and PIPE_WRITE */
#endif
+ int sync_pipe_read_fd;
+ char *dirname;
+ char *exename;
int argc;
const char **argv;
- enum PIPES { PIPE_READ, PIPE_WRITE }; /* Constants 0 and 1 for PIPE_READ and PIPE_WRITE */
- int sync_pipe[2]; /* pipe used to send messages from child to parent */
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_start");
argv = g_malloc(sizeof (char *));
*argv = NULL;
- /* Now add those arguments used on all platforms. */
- argv = sync_pipe_add_arg(argv, &argc, CHILD_NAME);
-
argv = sync_pipe_add_arg(argv, &argc, "-i");
argv = sync_pipe_add_arg(argv, &argc, capture_opts->iface);
if (!capture_opts->promisc_mode)
argv = sync_pipe_add_arg(argv, &argc, "-p");
-#ifdef _WIN32
- /* Create a pipe for the child process */
- /* (inrease this value if you have trouble while fast capture file switches) */
- if(_pipe(sync_pipe, 5120, O_BINARY) < 0) {
- /* Couldn't create the pipe between parent and child. */
- simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Couldn't create sync pipe: %s",
- strerror(errno));
- g_free( (gpointer) argv);
- return FALSE;
- }
-
- /* Create a pipe for the parent process */
- if(_pipe(signal_pipe, 512, O_BINARY) < 0) {
- /* Couldn't create the signal pipe between parent and child. */
- simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Couldn't create signal pipe: %s",
- strerror(errno));
- eth_close(sync_pipe[PIPE_READ]);
- eth_close(sync_pipe[PIPE_WRITE]);
- g_free( (gpointer) argv);
- return FALSE;
- }
+ /* dumpcap should be running in capture child mode (hidden feature) */
+#ifndef DEBUG_CHILD
+ argv = sync_pipe_add_arg(argv, &argc, "-Z");
+#endif
- capture_opts->signal_pipe_fd = signal_pipe[PIPE_WRITE];
+ /* take ethereal's absolute program path and replace ethereal with dumpcap */
+ dirname = get_dirname(g_strdup(ethereal_path));
+ exename = g_strdup_printf("\"%s" G_DIR_SEPARATOR_S "dumpcap\"", dirname);
+ g_free(dirname);
+#ifdef _WIN32
argv = sync_pipe_add_arg(argv, &argc, "-B");
g_snprintf(buffer_size, ARGV_NUMBER_LEN, "%d",capture_opts->buffer_size);
argv = sync_pipe_add_arg(argv, &argc, buffer_size);
- /* Convert sync pipe write handle to a string and pass to child */
- argv = sync_pipe_add_arg(argv, &argc, "-Z");
- g_snprintf(sync_pipe_fd, ARGV_NUMBER_LEN, "sync:%d",sync_pipe[PIPE_WRITE]);
- argv = sync_pipe_add_arg(argv, &argc, sync_pipe_fd);
-
- /* Convert signal pipe read handle to a string and pass to child */
- argv = sync_pipe_add_arg(argv, &argc, "-Z");
- g_snprintf(signal_pipe_fd, ARGV_NUMBER_LEN, "signal:%d",signal_pipe[PIPE_READ]);
- argv = sync_pipe_add_arg(argv, &argc, signal_pipe_fd);
-
/* Convert filter string to a quote delimited string and pass to child */
filterstring = NULL;
if (capture_opts->cfilter != NULL && strlen(capture_opts->cfilter) != 0) {
argv = sync_pipe_add_arg(argv, &argc, savefilestring);
}
- /* Spawn process */
-#if 0
- {
- /* XXX - very experimental using dumpcap as the capture child */
- /* currently not working, the pipe handles seem to make problems ... */
- char *dirname;
- GString *args = g_string_sized_new(200);
- STARTUPINFO si;
- PROCESS_INFORMATION pi;
- int i;
-
- memset(&si, 0, sizeof(si));
- si.cb = sizeof(si);
- si.dwFlags = STARTF_USESHOWWINDOW;
- si.wShowWindow = SW_SHOW /* SW_HIDE */;
-#if 0
- si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
- si.hStdInput = signal_pipe[PIPE_READ];
- si.hStdOutput = sync_pipe[PIPE_WRITE];
- si.hStdError = stderr;
-#endif
+ /* init SECURITY_ATTRIBUTES */
+ sa.nLength = sizeof(SECURITY_ATTRIBUTES);
+ sa.bInheritHandle = TRUE;
+ sa.lpSecurityDescriptor = NULL;
- /* take the ethereal programs path and replace ethereal with dumpcap */
- dirname = get_dirname(g_strdup(ethereal_path));
- g_string_sprintfa(args, "\"%s" G_DIR_SEPARATOR_S "dumpcap\"", dirname);
- g_free(dirname);
+ /* Create a pipe for the child process */
+ /* (inrease this value if you have trouble while fast capture file switches) */
+ if (! CreatePipe(&sync_pipe_read, &sync_pipe_write, &sa, 5120)) {
+ /* Couldn't create the pipe between parent and child. */
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Couldn't create sync pipe: %s",
+ strerror(errno));
+ g_free( (gpointer) argv);
+ return FALSE;
+ }
- for(i=1; argv[i] != 0; i++) {
- g_string_append_c(args, ' ');
- g_string_append(args, argv[i]);
- }
-
- /* call dumpcap */
- /*capture_opts->fork_child = spawnvp(_P_NOWAIT, exename, argv);*/
- if(!CreateProcess(NULL, args->str, NULL, NULL, TRUE,
- CREATE_NEW_CONSOLE,
- NULL,
- NULL,
- &si,
- &pi)) {
- g_error("couldn't open child!");
- }
- capture_opts->fork_child = (int) pi.hProcess;
- g_string_free(args, TRUE);
+ /* Create a pipe for the parent process */
+ if (! CreatePipe(&signal_pipe_read, &signal_pipe_write, &sa, 512)) {
+ /* Couldn't create the signal pipe between parent and child. */
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Couldn't create signal pipe: %s",
+ strerror(errno));
+ CloseHandle(sync_pipe_read);
+ CloseHandle(sync_pipe_write);
+ g_free( (gpointer) argv);
+ return FALSE;
}
+
+ /* init STARTUPINFO */
+ memset(&si, 0, sizeof(si));
+ si.cb = sizeof(si);
+#ifdef DEBUG_CHILD
+ si.dwFlags = STARTF_USESHOWWINDOW;
+ si.wShowWindow = SW_SHOW;
+#else
+ si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
+ si.wShowWindow = SW_HIDE; /* this hides the console window */
+ si.hStdInput = signal_pipe_read;
+ si.hStdOutput = sync_pipe_write;
+ si.hStdError = sync_pipe_write;
#endif
-#if 0
- {
- /* experiment to use dumpcap as the capture child */
- /* Win32 will open a console window for the child, so very ugly ... */
- char *dirname;
- char *exename;
-
- /* take the ethereal programs path and replace ethereal with dumpcap */
- dirname = get_dirname(g_strdup(ethereal_path));
- exename = g_strdup_printf("%s" G_DIR_SEPARATOR_S "dumpcap", dirname);
- g_free(dirname);
-
- /* call dumpcap */
- capture_opts->fork_child = spawnvp(_P_NOWAIT, exename, argv);
- g_free(exename);
+
+ g_string_append(args, exename);
+
+ /* convert args array into a single string */
+ /* XXX - could change sync_pipe_add_arg() instead */
+ /* there is a drawback here: the length is internally limited to 1024 bytes */
+ for(i=0; argv[i] != 0; i++) {
+ g_string_append_c(args, ' ');
+ g_string_append(args, argv[i]);
}
-#endif
-#if 1
- /* use Ethereal itself as the capture child */
- capture_opts->fork_child = spawnvp(_P_NOWAIT, ethereal_path, argv);
-#endif
+
+ /* call dumpcap */
+ if(!CreateProcess(NULL, args->str, NULL, NULL, TRUE,
+ CREATE_NEW_CONSOLE,
+ NULL,
+ NULL,
+ &si,
+ &pi)) {
+ g_error("couldn't open dumpcap.exe!");
+ }
+ capture_opts->fork_child = (int) pi.hProcess;
+ g_string_free(args, TRUE);
+
+ /* associate the operating system filehandle to a C run-time file handle */
+ sync_pipe_read_fd = _open_osfhandle( (long) sync_pipe_read, _O_BINARY);
+
+ /* associate the operating system filehandle to a C run-time file handle */
+ capture_opts->signal_pipe_write_fd = _open_osfhandle( (long) signal_pipe_write, _O_BINARY);
+
if (filterstring) {
g_free(filterstring);
}
}
/* child own's the read side now, close our handle */
- eth_close(signal_pipe[PIPE_READ]);
-#else
+ CloseHandle(signal_pipe_read);
+#else /* _WIN32 */
if (pipe(sync_pipe) < 0) {
/* Couldn't create the pipe between parent and child. */
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Couldn't create sync pipe: %s",
eth_close(1);
dup(sync_pipe[PIPE_WRITE]);
eth_close(sync_pipe[PIPE_READ]);
- execvp(ethereal_path, argv);
+ execvp(exename, argv);
g_snprintf(errmsg, sizeof errmsg, "Couldn't run %s in child process: %s",
- ethereal_path, strerror(errno));
+ exename, strerror(errno));
sync_pipe_errmsg_to_parent(errmsg);
/* Exit with "_exit()", so that we don't close the connection
our parent). */
_exit(2);
}
+
+ sync_pipe_read_fd = sync_pipe[PIPE_READ];
#endif
+ g_free(exename);
+
/* Parent process - read messages from the child process over the
sync pipe. */
g_free( (gpointer) argv); /* free up arg array */
open, and thus it completely closes, and thus returns to us
an EOF indication, if the child closes it (either deliberately
or by exiting abnormally). */
+#ifdef _WIN32
+ CloseHandle(sync_pipe_write);
+#else
eth_close(sync_pipe[PIPE_WRITE]);
+#endif
if (capture_opts->fork_child == -1) {
/* We couldn't even create the child process. */
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"Couldn't create child process: %s", strerror(errno));
- eth_close(sync_pipe[PIPE_READ]);
+ eth_close(sync_pipe_read_fd);
#ifdef _WIN32
- eth_close(signal_pipe[PIPE_WRITE]);
+ eth_close(capture_opts->signal_pipe_write_fd);
#endif
return FALSE;
}
the child process wants to tell us something. */
/* we have a running capture, now wait for the real capture filename */
- pipe_input_set_handler(sync_pipe[PIPE_READ], (gpointer) capture_opts,
+ pipe_input_set_handler(sync_pipe_read_fd, (gpointer) capture_opts,
&capture_opts->fork_child, sync_pipe_input_cb);
return TRUE;
sync_pipe_wait_for_child(capture_opts);
#ifdef _WIN32
- eth_close(capture_opts->signal_pipe_fd);
+ eth_close(capture_opts->signal_pipe_write_fd);
#endif
capture_input_closed(capture_opts);
return FALSE;
#ifndef __CAPTURE_SYNC_H__
#define __CAPTURE_SYNC_H__
-/** Name we give to the child process when doing a "-S" capture. */
-#define CHILD_NAME "ethereal-capture"
-
/* Size of buffer to hold decimal representation of
signed/unsigned 64-bit int */
#include <netdb.h>
#endif
-#ifdef _WIN32 /* Needed for console I/O */
-#include <conio.h>
-#endif
-
#include "ringbuffer.h"
#include "clopts_common.h"
#include "cmdarg_err.h"
-gboolean capture_child; /* True if this is an Ethereal capture child */
+gboolean capture_child = FALSE; /* FALSE: standalone call, TRUE: this is an Ethereal capture child */
-/* Win32 console handling */
-#ifdef _WIN32
-static gboolean has_console = FALSE; /* TRUE if app has console */
-static void create_console(void);
-static void destroy_console(void);
-#endif
static void
console_log_handler(const char *log_domain, GLogLevelFlags log_level,
const char *message, gpointer user_data _U_);
FILE *output;
-#ifdef _WIN32
- create_console();
-#endif
if (print_ver) {
output = stdout;
static void
show_version(GString *comp_info_str, GString *runtime_info_str)
{
-#ifdef _WIN32
- create_console();
-#endif
printf(
"Dumpcap " VERSION "%s\n"
{
va_list ap;
-#ifdef _WIN32
- create_console();
-#endif
va_start(ap, fmt);
fprintf(stderr, "dumpcap: ");
vfprintf(stderr, fmt, ap);
{
va_list ap;
-#ifdef _WIN32
- create_console();
-#endif
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
fprintf(stderr, "\n");
}
#endif
-void exit_main(int err)
+void exit_main(int status)
{
#ifdef _WIN32
/* Shutdown windows sockets */
WSACleanup();
-
- destroy_console();
#endif
/* can be helpful for debugging */
- /* _getch(); */
- exit(err);
+#ifdef DEBUG_DUMPCAP
+ printf("Press any key\n");
+ _getch();
+#endif
+
+ exit(status);
}
gboolean list_link_layer_types = FALSE;
int status;
-#define OPTSTRING_INIT "a:b:c:Df:hi:Lps:vw:y:"
+#define OPTSTRING_INIT "a:b:c:Df:hi:Lps:vw:y:Z"
#ifdef _WIN32
-#define OPTSTRING_WIN32 "B:Z:"
+#define OPTSTRING_WIN32 "B:"
#else
#define OPTSTRING_WIN32 ""
#endif /* _WIN32 */
char optstring[sizeof(OPTSTRING_INIT) + sizeof(OPTSTRING_WIN32) - 1] =
OPTSTRING_INIT OPTSTRING_WIN32;
-
- capture_child = (strcmp(get_basename(argv[0]), CHILD_NAME) == 0);
-
#ifdef _WIN32
/* Load wpcap if possible. Do this before collecting the run-time version information */
load_wpcap();
case 'y': /* Set the pcap data link type */
#ifdef _WIN32
case 'B': /* Buffer size */
- /* Hidden option supporting Sync mode */
- case 'Z': /* Write to pipe FD x */
#endif /* _WIN32 */
status = capture_opts_add_opt(capture_opts, opt, optarg, &start_capture);
if(status != 0) {
exit_main(status);
}
break;
+ /*** hidden option: Ethereal child mode (using binary output messages) ***/
+ case 'Z':
+ capture_child = TRUE;
+ break;
/*** all non capture option specific ***/
case 'D': /* Print a list of capture devices and exit */
/* Now start the capture. */
- /* XXX - hand the stats to the parent process */
if(capture_loop_start(capture_opts, &stats_known, &stats) == TRUE) {
/* capture ok */
exit_main(0);
}
}
-#ifdef _WIN32
-
-/* We build this as a GUI subsystem application on Win32, so
- "WinMain()", not "main()", gets called.
-
- Hack shamelessly stolen from the Win32 port of the GIMP. */
-#ifdef __GNUC__
-#define _stdcall __attribute__((stdcall))
-#endif
-
-int _stdcall
-WinMain (struct HINSTANCE__ *hInstance,
- struct HINSTANCE__ *hPrevInstance,
- char *lpszCmdLine,
- int nCmdShow)
-{
- has_console = FALSE;
- return main (__argc, __argv);
-}
-
-/*
- * If this application has no console window to which its standard output
- * would go, create one.
- */
-void
-create_console(void)
-{
- if (!has_console) {
- /* We have no console to which to print the version string, so
- create one and make it the standard input, output, and error. */
- if (!AllocConsole())
- return; /* couldn't create console */
- eth_freopen("CONIN$", "r", stdin);
- eth_freopen("CONOUT$", "w", stdout);
- eth_freopen("CONOUT$", "w", stderr);
-
- /* Well, we have a console now. */
- has_console = TRUE;
-
- /* Now register "destroy_console()" as a routine to be called just
- before the application exits, so that we can destroy the console
- after the user has typed a key (so that the console doesn't just
- disappear out from under them, giving the user no chance to see
- the message(s) we put in there). */
- atexit(destroy_console);
-
- SetConsoleTitle("Dumpcap Console");
- }
-}
-
-static void
-destroy_console(void)
-{
- if (has_console) {
-/* XXX - doesn't make sense while we're linked as a console application */
-/* printf("\n\nPress any key to exit\n");
- _getch();*/
- FreeConsole();
- }
-}
-#endif /* _WIN32 */
-
/* This routine should not be necessary, at least as I read the GLib
source code, as it looks as if GLib is, on Win32, *supposed* to
/* ignore log message, if log_level isn't interesting */
if( !(log_level & G_LOG_LEVEL_MASK & ~(G_LOG_LEVEL_DEBUG|G_LOG_LEVEL_INFO))) {
+#ifndef DEBUG_DUMPCAP
return;
+#endif
}
/* create a "timestamp" */
time(&curr);
today = localtime(&curr);
-#ifdef _WIN32
- if(!capture_child) {
- create_console();
- }
- if (has_console) {
- /* For some unknown reason, the above doesn't appear to actually cause
- anything to be sent to the standard output, so we'll just splat the
- message out directly, just to make sure it gets out. */
-#endif
switch(log_level & G_LOG_LEVEL_MASK) {
case G_LOG_LEVEL_ERROR:
level = "Err ";
today->tm_hour, today->tm_min, today->tm_sec,
log_domain != NULL ? log_domain : "",
level, message);
-#ifdef _WIN32
- } else {
- g_log_default_handler(log_domain, log_level, message, user_data);
- }
-#endif
}
/****************************************************************************************************************/
}
-/****************************************************************************************************************/
-/* functions copied from epan */
-
-/*
- * Given a pathname, return a pointer to the last pathname separator
- * character in the pathname, or NULL if the pathname contains no
- * separators.
- */
-static char *
-find_last_pathname_separator(const char *path)
-{
- char *separator;
-
-#ifdef _WIN32
- char c;
-
- /*
- * We have to scan for '\' or '/'.
- * Get to the end of the string.
- */
- separator = strchr(path, '\0'); /* points to ending '\0' */
- while (separator > path) {
- c = *--separator;
- if (c == '\\' || c == '/')
- return separator; /* found it */
- }
-
- /*
- * OK, we didn't find any, so no directories - but there might
- * be a drive letter....
- */
- return strchr(path, ':');
-#else
- separator = strrchr(path, '/');
-#endif
- return separator;
-}
-
-/*
- * Given a pathname, return the last component.
- */
-const char *
-get_basename(const char *path)
-{
- const char *filename;
-
- g_assert(path != NULL);
- filename = find_last_pathname_separator(path);
- if (filename == NULL) {
- /*
- * There're no directories, drive letters, etc. in the
- * name; the pathname *is* the file name.
- */
- filename = path;
- } else {
- /*
- * Skip past the pathname or drive letter separator.
- */
- filename++;
- }
- return filename;
-}
-
gchar *ethereal_path = NULL;
gboolean have_capture_file = FALSE; /* XXX - is there an aquivalent in cfile? */
-gboolean capture_child; /* True if this is the child for "-S" */
#ifdef _WIN32
static gboolean has_console; /* TRUE if app has console */
static void destroy_console(void);
int
main(int argc, char *argv[])
{
-#ifdef HAVE_LIBPCAP
- const char *command_name;
-#endif
char *s;
int i;
int opt;
int err;
#ifdef HAVE_LIBPCAP
gboolean start_capture = FALSE;
- gboolean stats_known;
- struct pcap_stat stats;
#else
gboolean capture_option_specified = FALSE;
#endif
g_log_set_handler(LOG_DOMAIN_CAPTURE,
log_flags,
console_log_handler, NULL /* user_data */);
- g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
- log_flags,
- console_log_handler, NULL /* user_data */);
/* Set the initial values in the capture_opts. This might be overwritten
by preference settings and then again by the command line parameters. */
capture_opts->snaplen = MIN_PACKET_SIZE;
capture_opts->has_ring_num_files = TRUE;
-
- command_name = get_basename(ethereal_path);
- /* Set "capture_child" to indicate whether this is going to be a child
- process for a "-S" capture. */
- capture_child = (strcmp(command_name, CHILD_NAME) == 0);
- if (capture_child) {
- strcat(optstring, OPTSTRING_CHILD);
- }
#endif
- /* We want a splash screen only if we're not a child process.
- We won't come till here, if we had a "console only" command line parameter. */
-#ifdef HAVE_LIBPCAP
- if (!capture_child)
-#endif
- splash_win = splash_new("Loading Ethereal ...");
+ /* We won't come till here, if we had a "console only" command line parameter. */
+ splash_win = splash_new("Loading Ethereal ...");
splash_update(splash_win, "Init dissectors ...");
#endif
#ifdef HAVE_LIBPCAP
- /* If this is a capture child process, it should pay no attention
- to the "prefs.capture_prom_mode" setting in the preferences file;
- it should do what the parent process tells it to do, and if
- the parent process wants it not to run in promiscuous mode, it'll
- tell it so with a "-p" flag.
-
- Otherwise, set promiscuous mode from the preferences setting. */
+ /* Set promiscuous mode from the preferences setting. */
/* the same applies to other preferences settings as well. */
- if (capture_child) {
- auto_scroll_live = FALSE;
- } else {
capture_opts->promisc_mode = prefs->capture_prom_mode;
capture_opts->show_info = prefs->capture_show_info;
capture_opts->real_time_mode = prefs->capture_real_time;
auto_scroll_live = prefs->capture_auto_scroll;
- }
-
#endif /* HAVE_LIBPCAP */
/* Set the name resolution code's flags from the preferences. */
rc_file = get_persconffile_path(RC_FILE, FALSE);
gtk_rc_parse(rc_file);
-#ifdef HAVE_LIBPCAP
- font_init(capture_child);
-#else
font_init(FALSE);
-#endif
/* close the splash screen, as we are going to open the main window now */
splash_destroy(splash_win);
-
-#ifdef HAVE_LIBPCAP
- /* Is this a "child" ethereal, which is only supposed to pop up a
- capture box to let us stop the capture, and run a capture
- to a file that our parent will read? */
- if (capture_child) {
- /* This is the child process of a capture session,
- so just do the low-level work of a capture - don't create
- a temporary file and fork off *another* child process (so don't
- call "capture_start()"). */
-
- /* Pop up any queued-up alert boxes. */
- display_queued_messages();
-
- /* Now start the capture.
- After the capture is done; there's nothing more for us to do. */
-
- /* XXX - hand these stats to the parent process */
- if(capture_loop_start(capture_opts, &stats_known, &stats) == TRUE) {
- /* capture ok */
- gtk_exit(0);
- } else {
- /* capture failed */
- gtk_exit(1);
- }
- }
-#endif
-
/***********************************************************************/
/* Everything is prepared now, preferences and command line was read in,
we are NOT a child window for a synced capture. */
the message(s) we put in there). */
atexit(destroy_console);
- if(capture_child) {
- SetConsoleTitle("Ethereal Capture Child Debug Console");
- } else {
- SetConsoleTitle("Ethereal Debug Console");
- }
+ SetConsoleTitle("Ethereal Debug Console");
}
}
static void
destroy_console(void)
{
- if (has_console && !capture_child) {
+ if (has_console) {
printf("\n\nPress any key to exit\n");
_getch();
FreeConsole();
git.samba.org / metze / wireshark / wip.git / commitdiff