GList *get_interface_list(int *err, char **err_str);
-/* Error values from "get_interface_list()". */
-#define CANT_GET_INTERFACE_LIST 0 /* error getting list */
-#define NO_INTERFACES_FOUND 1 /* list is empty */
+/* Error values from "get_interface_list()/capture_interface_list()". */
+#define CANT_GET_INTERFACE_LIST 1 /* error getting list */
+#define NO_INTERFACES_FOUND 2 /* list is empty */
+#define CANT_RUN_DUMPCAP 3 /* problem running 'dumpcap -I l' */
void free_interface_list(GList *if_list);
#include <fcntl.h>
#endif
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+
#include <signal.h>
#include <errno.h>
#include <epan/packet.h>
#include <epan/dfilter/dfilter.h>
+#include <epan/ws_strsplit.h>
#include "file.h"
#include "capture.h"
#include "capture_sync.h"
-/**
+/**
* Start a capture.
*
* @return TRUE if the capture starts successfully, FALSE otherwise.
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_INFO, "Capture Kill");
/* kill the capture child */
- sync_pipe_kill(capture_opts);
+ sync_pipe_kill(capture_opts->fork_child);
}
break;
case CF_READ_ABORTED:
- /* User wants to quit program. Exit by leaving the main loop,
+ /* User wants to quit program. Exit by leaving the main loop,
so that any quit functions we registered get called. */
main_window_nested_quit();
return FALSE;
/* if we didn't captured even a single packet, close the file again */
if(cf_get_packet_count(capture_opts->cf) == 0 && !capture_opts->restart) {
- simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
+ simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
"%sNo packets captured!%s\n"
"\n"
"As no data was captured, closing the %scapture file!\n"
case CF_OK:
break;
case CF_ERROR:
- /* Don't unlink (delete) the save file - leave it around,
+ /* Don't unlink (delete) the save file - leave it around,
for debugging purposes. */
g_free(capture_opts->save_file);
capture_opts->save_file = NULL;
return TRUE;
}
-
+
/* capture child tells us we have new packets to read */
void
capture_input_new_packets(capture_options *capture_opts, int to_read)
}
} else {
/* increase capture file packet counter by the number or incoming packets */
- cf_set_packet_count(capture_opts->cf,
+ cf_set_packet_count(capture_opts->cf,
cf_get_packet_count(capture_opts->cf) + to_read);
cf_callback_invoke(cf_cb_live_capture_fixed_continue, capture_opts->cf);
/* XXX: If -Q (quit-after-cap) then cf->count clr'd below so save it first */
packet_count_save = cf_get_packet_count(capture_opts->cf);
/* Tell the GUI, we are not doing a capture any more.
- Must be done after the cf_finish_tail(), so file lengths are displayed
+ Must be done after the cf_finish_tail(), so file lengths are displayed
correct. */
cf_callback_invoke(cf_cb_live_capture_update_finished, capture_opts->cf);
case CF_READ_OK:
if ((packet_count_save == 0) && !capture_opts->restart) {
- simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
+ simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
"%sNo packets captured!%s\n"
"\n"
"As no data was captured, closing the %scapture file!\n"
/* this is a normal mode capture and if no error happened, read in the capture file data */
if(capture_opts->save_file != NULL) {
- capture_input_read_all(capture_opts, cf_is_tempfile(capture_opts->cf),
+ capture_input_read_all(capture_opts, cf_is_tempfile(capture_opts->cf),
cf_get_drops_known(capture_opts->cf), cf_get_drops(capture_opts->cf));
}
}
}
}
+/**
+ * Fetch the interface list from a child process (dumpcap).
+ *
+ * @return A GList containing if_info_t structs if successful, NULL otherwise.
+ */
+
+/* XXX - We parse simple text output to get our interface list. Should
+ * we use "real" data serialization instead, e.g. via XML? */
+GList *
+capture_interface_list(int *err, char **err_str)
+{
+ GList *if_list = NULL;
+ int i, j;
+ gchar *msg;
+ gchar **raw_list, **if_parts, **addr_parts;
+ gchar *name;
+ if_info_t *if_info;
+ if_addr_t *if_addr;
+ struct addrinfo *ai;
+ struct sockaddr_in *sa4;
+ struct sockaddr_in6 *sa6;
+
+ g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Interface List ...");
+
+ /* Try to get our interface list */
+ *err = sync_interface_list_open(&msg);
+ if(*err != 0) {
+ g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Interface List failed!");
+ if (*err_str)
+ *err_str = msg;
+ else
+ g_free(msg);
+ return NULL;
+ }
+
+ /* Split our lines */
+ raw_list = g_strsplit(msg, "\n", 0);
+ g_free(msg);
+
+ for (i = 0; raw_list[i] != NULL; i++) {
+ if_parts = g_strsplit(raw_list[i], "\t", 4);
+ if (if_parts[0] == NULL || if_parts[1] == NULL || if_parts[2] == NULL ||
+ if_parts[3] == NULL) {
+ g_strfreev(if_parts);
+ continue;
+ }
+
+ /* Number followed by the name, e.g "1. eth0" */
+ name = strchr(if_parts[0], ' ');
+ if (name) {
+ name++;
+ } else {
+ g_strfreev(if_parts);
+ continue;
+ }
+
+ if_info = g_malloc0(sizeof(if_info_t));
+ if_info->name = g_strdup(name);
+ if (strlen(if_parts[1]) > 0)
+ if_info->description = g_strdup(if_parts[1]);
+ addr_parts = g_strsplit(if_parts[2], ",", 0);
+ for (j = 0; addr_parts[j] != NULL; j++) {
+ /* XXX - We're failing to convert IPv6 addresses (on Ubuntu, at least) */
+ if (getaddrinfo(addr_parts[j], NULL, NULL, &ai) == 0) {
+ if_addr = NULL;
+ switch (ai->ai_family) {
+ case AF_INET:
+ if_addr = g_malloc0(sizeof(if_addr_t));
+ if_addr->type = AT_IPv4;
+ sa4 = (struct sockaddr_in *) ai->ai_addr;
+ if_addr->ip_addr.ip4_addr = sa4->sin_addr.s_addr;
+ break;
+ case AF_INET6:
+ if_addr = g_malloc0(sizeof(if_addr_t));
+ if_addr->type = AT_IPv6;
+ sa6 = (struct sockaddr_in6 *) ai->ai_addr;
+ memcpy(&if_addr->ip_addr.ip6_addr, sa6->sin6_addr.s6_addr, 16);
+ break;
+ }
+ if (if_addr) {
+ if_info->ip_addr = g_slist_append(if_info->ip_addr, if_addr);
+ }
+ freeaddrinfo(ai);
+ }
+ }
+ if (strcmp(if_parts[3], "loopback") == 0)
+ if_info->loopback = TRUE;
+ g_strfreev(if_parts);
+ g_strfreev(addr_parts);
+ if_list = g_list_append(if_list, if_info);
+ }
+ g_strfreev(raw_list);
+
+ /* Check to see if we built a list */
+ if (if_list == NULL) {
+ if (*err_str)
+ *err_str = g_strdup("No interfaces found");
+ *err = NO_INTERFACES_FOUND;
+ }
+ return if_list;
+}
+
#endif /* HAVE_LIBPCAP */
#include "capture_opts.h"
-/**
+/**
* Start a capture session.
*
* @param capture_opts the numerous capture options
*/
extern void capture_input_closed(capture_options *capture_opts);
+/**
+ * Fetch the interface list from a child process.
+ */
+extern GList *capture_interface_list(int *err, char **err_str);
+
#endif /* capture.h */
#include <string.h>
#include <ctype.h>
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+
#include <glib.h>
#include <epan/packet.h>
void
capture_opts_init(capture_options *capture_opts, void *cfile)
{
- capture_opts->cf = cfile;
+ capture_opts->cf = cfile;
capture_opts->cfilter = g_strdup(""); /* No capture filter string specified */
capture_opts->iface = NULL; /* Default is "pick the first interface" */
#ifdef _WIN32
capture_opts->has_autostop_files = FALSE;
capture_opts->autostop_files = 1;
- capture_opts->has_autostop_packets = FALSE;
+ capture_opts->has_autostop_packets = FALSE;
capture_opts->autostop_packets = 0;
capture_opts->has_autostop_filesize = FALSE;
capture_opts->autostop_filesize = 1024; /* 1 MB */
return 0;
}
-
-int capture_opts_list_interfaces()
+/* Return an ASCII-formatted list of interfaces. */
+int
+capture_opts_list_interfaces(gboolean verbose)
{
GList *if_list;
GList *if_entry;
int err;
gchar *err_str;
int i;
-#if 0
GSList *ip_addr;
if_addr_t *if_addr;
- guint8 ipv4[4];
-#endif
-
+ char addr_str[NI_MAXHOST];
+ struct sockaddr_in sa4;
+ struct sockaddr_in6 sa6;
if_list = get_interface_list(&err, &err_str);
if (if_list == NULL) {
cmdarg_err("There are no interfaces on which a capture can be done");
break;
}
- return 2;
+ return err;
}
i = 1; /* Interface id number */
if_entry = g_list_next(if_entry)) {
if_info = if_entry->data;
printf("%d. %s", i++, if_info->name);
- if (if_info->description != NULL)
- printf(" (%s)", if_info->description);
-#if 0
- for(ip_addr = g_slist_nth(if_info->ip_addr, 0); ip_addr != NULL;
- ip_addr = g_slist_next(ip_addr)) {
- if_addr = ip_addr->data;
- switch(if_addr->type) {
- case AT_IPv4:
- memcpy(ipv4, (void *) &if_addr->ip_addr.ip4_addr, 4);
- printf(" %u.%u.%u.%u", ipv4[0], ipv4[1], ipv4[2], ipv4[3]);
- break;
- case AT_IPv6:
- /* XXX - display the IPv6 address without using stuff from epan */
- printf(" XXX-IPv6");
- break;
- default:
- printf(" unknown address type %u", if_addr->type);
+
+ if (!verbose) {
+ /* Add the description if it exists */
+ if (if_info->description != NULL)
+ printf(" (%s)", if_info->description);
+ } else {
+ /*
+ * Add the contents of the if_entry struct in a parseable format.
+ * Each if_entry element is tab-separated. Addresses are comma-
+ * separated.
+ */
+ /* XXX - Make sure our description doesn't contain a tab */
+ if (if_info->description != NULL)
+ printf("\t%s\t", if_info->description);
+ else
+ printf("\t\t");
+
+ for(ip_addr = g_slist_nth(if_info->ip_addr, 0); ip_addr != NULL;
+ ip_addr = g_slist_next(ip_addr)) {
+ if (ip_addr != g_slist_nth(if_info->ip_addr, 0))
+ printf(",");
+
+ if_addr = ip_addr->data;
+ switch(if_addr->type) {
+ case AT_IPv4:
+ sa4.sin_family = AF_INET;
+ sa4.sin_addr.s_addr = if_addr->ip_addr.ip4_addr;
+ if (getnameinfo((struct sockaddr *) &sa4, sizeof(sa4),
+ addr_str, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) {
+ printf(addr_str);
+ } else {
+ printf("<unknown IPv4>");
+ }
+ break;
+ case AT_IPv6:
+ sa6.sin6_family = AF_INET6;
+ memcpy(&sa6.sin6_addr.s6_addr, &if_addr->ip_addr.ip6_addr, 16);
+ if (getnameinfo((struct sockaddr *) &sa6, sizeof(sa6),
+ addr_str, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) == 0) {
+ printf(addr_str);
+ } else {
+ printf("<unknown IPv6>");
+ }
+ break;
+ default:
+ printf("<type unknown %u>", if_addr->type);
+ }
}
- }
-#endif
- printf("\n");
+ if (if_info->loopback)
+ printf("\tloopback");
+ else
+ printf("\tnetwork");
+
+ }
+ printf("\n");
}
free_interface_list(if_list);
/** @file
- *
+ *
* Capture options (all parameters needed to do the actual capture)
*
*/
/* list interfaces */
extern int
-capture_opts_list_interfaces(void);
+capture_opts_list_interfaces(gboolean verbose);
/* trim the snaplen entry */
-extern void
+extern void
capture_opts_trim_snaplen(capture_options *capture_opts, int snaplen_min);
/* trim the ring_num_files entry */
-extern void
+extern void
capture_opts_trim_ring_num_files(capture_options *capture_opts);
/* trim the interface entry */
return TRUE;
}
+/*
+ * Get an interface list using dumpcap. On success, msg points to
+ * a buffer containing the dumpcap output and returns 0. On failure, msg
+ * points to the error message returned by dumpcap, and returns dumpcap's
+ * exit value. In either case, msg must be freed with g_free().
+ */
+/* XXX - This duplicates a lot of code in sync_pipe_start() and sync_interface_list_open() */
+#define PIPE_BUF_SIZE 5120
+int
+sync_interface_list_open(gchar **msg) {
+#ifdef _WIN32
+ HANDLE sync_pipe_read; /* pipe used to send messages from child to parent */
+ HANDLE sync_pipe_write; /* pipe used to send messages from parent to child */
+ GString *args = g_string_sized_new(200);
+ gchar *quoted_arg;
+ SECURITY_ATTRIBUTES sa;
+ STARTUPINFO si;
+ PROCESS_INFORMATION pi;
+ int i;
+#else
+ 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 fork_child = -1, fork_child_status;
+ int sync_pipe_read_fd = -1;
+ const char *progfile_dir;
+ char *exename;
+ int argc;
+ const char **argv;
+ GString *msg_buf = NULL;
+ gchar buf[PIPE_BUF_SIZE+1];
+ int count;
+
+ g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_interface_list_open");
+
+ if (!msg) {
+ /* We can't return anything */
+#ifdef _WIN32
+ g_string_free(args, TRUE);
+#endif
+ return -1;
+ }
+
+ progfile_dir = get_progfile_dir();
+ if (progfile_dir == NULL) {
+ /* We don't know where to find dumpcap. */
+ *msg = g_strdup("We don't know where to find dumpcap.");
+ return CANT_RUN_DUMPCAP;
+ }
+
+ /* Allocate the string pointer array with enough space for the
+ terminating NULL pointer. */
+ argc = 0;
+ argv = g_malloc(sizeof (char *));
+ *argv = NULL;
+
+ /* take Wireshark's absolute program path and replace "Wireshark" with "dumpcap" */
+ exename = g_strdup_printf("%s" G_DIR_SEPARATOR_S "dumpcap", progfile_dir);
+
+ /* Make that the first argument in the argument list (argv[0]). */
+ argv = sync_pipe_add_arg(argv, &argc, exename);
+
+ /* Ask for the interface list */
+ argv = sync_pipe_add_arg(argv, &argc, "-I");
+ argv = sync_pipe_add_arg(argv, &argc, "l");
+
+
+ /* dumpcap should be running in capture child mode (hidden feature) */
+#ifndef DEBUG_CHILD
+ argv = sync_pipe_add_arg(argv, &argc, "-Z");
+#endif
+
+
+#ifdef _WIN32
+ /* init SECURITY_ATTRIBUTES */
+ sa.nLength = sizeof(SECURITY_ATTRIBUTES);
+ sa.bInheritHandle = TRUE;
+ sa.lpSecurityDescriptor = NULL;
+
+ /* 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. */
+ *msg = g_strdup_printf("Couldn't create sync pipe: %s", strerror(errno));
+ g_free( (gpointer) argv);
+ return CANT_RUN_DUMPCAP;
+ }
+
+ /* 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 = NULL;
+ si.hStdOutput = sync_pipe_write;
+ si.hStdError = sync_pipe_write;
+ /*si.hStdError = (HANDLE) _get_osfhandle(2);*/
+#endif
+
+ /* 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++) {
+ if(i != 0) g_string_append_c(args, ' '); /* don't prepend a space before the path!!! */
+ quoted_arg = protect_arg(argv[i]);
+ g_string_append(args, quoted_arg);
+ g_free(quoted_arg);
+ }
+
+ /* call dumpcap */
+ if(!CreateProcess(NULL, utf_8to16(args->str), NULL, NULL, TRUE,
+ CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi)) {
+ *msg = g_strdup_printf("Couldn't run %s in child process: error %u",
+ args->str, GetLastError());
+ CloseHandle(sync_pipe_read);
+ CloseHandle(sync_pipe_write);
+ g_free( (gpointer) argv);
+ return CANT_RUN_DUMPCAP;
+ }
+ fork_child = (int) pi.hProcess;
+ g_string_free(args, TRUE);
+
+ /* associate the operating system filehandle to a C run-time file handle */
+ /* (good file handle infos at: http://www.flounder.com/handles.htm) */
+ sync_pipe_read_fd = _open_osfhandle( (long) sync_pipe_read, _O_BINARY);
+
+#else /* _WIN32 */
+ if (pipe(sync_pipe) < 0) {
+ /* Couldn't create the pipe between parent and child. */
+ *msg = g_strdup_printf("Couldn't create sync pipe: %s", strerror(errno));
+ g_free(argv);
+ return CANT_RUN_DUMPCAP;
+ }
+
+ if ((fork_child = fork()) == 0) {
+ /*
+ * Child process - run dumpcap with the right arguments to make
+ * it just capture with the specified capture parameters
+ */
+ eth_close(1);
+ dup(sync_pipe[PIPE_WRITE]);
+ eth_close(sync_pipe[PIPE_READ]);
+ execv(exename, (gpointer)argv);
+ *msg = g_strdup_printf("Couldn't run %s in child process: %s",
+ exename, strerror(errno));
+ return CANT_RUN_DUMPCAP;
+ }
+
+ 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 */
+
+ /* Close the write side of the pipe, so that only the child has it
+ 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 (fork_child == -1) {
+ /* We couldn't even create the child process. */
+ *msg = g_strdup_printf("Couldn't create child process: %s", strerror(errno));
+ eth_close(sync_pipe_read_fd);
+ return CANT_RUN_DUMPCAP;
+ }
+
+ /* we might wait for a moment till child is ready, so update screen now */
+ main_window_update();
+
+ /* We were able to set up to read dumpcap's output. Do so and
+ return its exit value. */
+ msg_buf = g_string_new("");
+ while ((count = eth_read(sync_pipe_read_fd, buf, PIPE_BUF_SIZE)) > 0) {
+ buf[count] = '\0';
+ g_string_append(msg_buf, buf);
+ }
+
+ eth_close(sync_pipe_read_fd);
+
+ g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_interface_list_open: wait till child closed");
+
+#ifdef _WIN32
+ if (_cwait(&fork_child_status, fork_child, _WAIT_CHILD) == -1) {
+ g_string_free(msg_buf, TRUE);
+ *msg = g_strdup_printf("Child capture process stopped unexpectedly "
+ "(errno:%u)", errno);
+ return CANT_RUN_DUMPCAP;
+ }
+#else
+ if (wait(&fork_child_status) != -1) {
+ if (WIFEXITED(fork_child_status)) {
+ /* The child exited. */
+ fork_child_status = WEXITSTATUS(fork_child_status);
+ } else {
+ g_string_free(msg_buf, TRUE);
+ if (WIFSTOPPED(fork_child_status)) {
+ /* It stopped, rather than exiting. "Should not happen." */
+ *msg = g_strdup_printf("Child capture process stopped: %s",
+ sync_pipe_signame(WSTOPSIG(fork_child_status)));
+ } else if (WIFSIGNALED(fork_child_status)) {
+ /* It died with a signal. */
+ *msg = g_strdup_printf("Child capture process died: %s%s",
+ sync_pipe_signame(WTERMSIG(fork_child_status)),
+ WCOREDUMP(fork_child_status) ? " - core dumped" : "");
+ } else {
+ /* What? It had to either have exited, or stopped, or died with
+ a signal; what happened here? */
+ *msg = g_strdup_printf("Child capture process died: wait status %#o",
+ fork_child_status);
+ }
+ return CANT_RUN_DUMPCAP;
+ }
+ } else {
+ g_string_free(msg_buf, TRUE);
+ *msg = g_strdup_printf("Child capture process stopped unexpectedly "
+ "(errno:%u)", errno);
+ return CANT_RUN_DUMPCAP;
+ }
+#endif
+
+ *msg = msg_buf->str;
+ g_string_free(msg_buf, FALSE);
+ return fork_child_status;
+}
/* read a number of bytes from a pipe */
/* convert header values (indicator and 4-byte length) */
static void
-pipe_convert_header(const guchar *header, int header_len, char *indicator, int *block_len) {
+pipe_convert_header(const guchar *header, int header_len, char *indicator, int *block_len) {
g_assert(header_len == 4);
capturing any more packets. Pick up its exit status, and
complain if it did anything other than exit with status 0.
- We don't have to worry about killing the child, if the sync pipe
- returned an error. Usually this error is caused as the child killed itself
- while going down. Even in the rare cases that this isn't the case,
- the child will get an error when writing to the broken pipe the next time,
+ We don't have to worry about killing the child, if the sync pipe
+ returned an error. Usually this error is caused as the child killed itself
+ while going down. Even in the rare cases that this isn't the case,
+ the child will get an error when writing to the broken pipe the next time,
cleaning itself up then. */
sync_pipe_wait_for_child(capture_opts);
/* Wireshark has to exit, force the capture child to close */
void
-sync_pipe_kill(capture_options *capture_opts)
+sync_pipe_kill(int fork_child)
{
- if (capture_opts->fork_child != -1) {
+ if (fork_child != -1) {
#ifndef _WIN32
- kill(capture_opts->fork_child, SIGTERM); /* SIGTERM so it can clean up if necessary */
+ kill(fork_child, SIGTERM); /* SIGTERM so it can clean up if necessary */
#else
/* Remark: This is not the preferred method of closing a process!
* the clean way would be getting the process id of the child process,
* us, as we might not be running in a console.
* And this also will require to have the process id.
*/
- TerminateProcess((HANDLE) (capture_opts->fork_child), 0);
+ TerminateProcess((HANDLE) (fork_child), 0);
#endif
}
}
/** @file
- *
+ *
* Sync mode capture (internal interface).
*
- * Will start a new Wireshark child instance which will do the actual capture
+ * Will start a new Wireshark child instance which will do the actual capture
* work.
*/
#define __CAPTURE_SYNC_H__
-/**
+/**
* Start a new capture session.
* Create a capture child which is doing the real capture work.
- * The various capture_input_... functions will be called, if something had
+ * The various capture_input_... functions will be called, if something had
* happened.
*
* Most of the parameters are passed through the global capture_opts.
* @param capture_opts the options
* @return TRUE if a capture could be started, FALSE if not
*/
-extern gboolean
+extern gboolean
sync_pipe_start(capture_options *capture_opts);
/** User wants to stop capturing, gracefully close the capture child */
/** User wants to stop the program, just kill the child as soon as possible */
extern void
-sync_pipe_kill(capture_options *capture_opts);
+sync_pipe_kill(int fork_child);
-/** does the parent signalled the child to stop */
+/** Has the parent signalled the child to stop? */
#ifdef _WIN32
extern gboolean
signal_pipe_check_running(void);
#endif
+/** Get an interface list using dumpcap */
+extern int
+sync_interface_list_open(gchar **msg);
+
+
#endif /* capture_sync.h */
S<[ B<-f> E<lt>capture filterE<gt> ]>
S<[ B<-h> ]>
S<[ B<-i> E<lt>capture interfaceE<gt>|- ]>
+S<[ B<-I> E<lt>l|sE<gt> ]>
S<[ B<-L> ]>
S<[ B<-p> ]>
S<[ B<-s> E<lt>capture snaplenE<gt> ]>
Note: the Win32 version of B<Dumpcap> doesn't support capturing from
pipes or stdin!
+=item -I
+
+If run with the B<l> argument, print a verbose, machine-readable interface
+list, similar to the B<-D> flag.
+
+If run with the B<s> argument, print statistics for each interface every
+second until the program terminates.
+
=item -L
List the data link types supported by the interface and exit. The reported
fprintf(output, " -y <link type> link layer type (def: first appropriate)\n");
fprintf(output, " -D print list of interfaces and exit\n");
fprintf(output, " -L print list of link-layer types of iface and exit\n");
+ fprintf(output, " -I [l|s] print a detailed interface list (l) or interface statistics (s).\n");
fprintf(output, "\n");
fprintf(output, "Stop conditions:\n");
fprintf(output, " -c <packet count> stop after n packets (def: infinite)\n");
va_list ap;
if(capture_child) {
- /* XXX - convert to g_log */
+ /* Print a bare error */
+ va_start(ap, fmt);
+ vfprintf(stderr, fmt, ap);
+ va_end(ap);
} else {
va_start(ap, fmt);
fprintf(stderr, "dumpcap: ");
gboolean list_link_layer_types = FALSE;
int status;
-#define OPTSTRING_INIT "a:b:c:Df:hi:Lps:vw:y:Z"
+#define OPTSTRING_INIT "a:b:c:Df:hI:i:Lps:vw:y:Z"
#ifdef _WIN32
#define OPTSTRING_WIN32 "B:"
/* the default_log_handler will use stdout, which makes trouble in */
/* capture child mode, as it uses stdout for it's sync_pipe */
/* so do the filtering in the console_log_handler and not here */
- log_flags =
+ log_flags =
G_LOG_LEVEL_ERROR|
G_LOG_LEVEL_CRITICAL|
G_LOG_LEVEL_WARNING|
log_flags,
console_log_handler, NULL /* user_data */);
- /* Set the initial values in the capture_opts. This might be overwritten
+ /* Set the initial values in the capture_opts. This might be overwritten
by the command line parameters. */
capture_opts_init(capture_opts, NULL);
/* Assemble the run-time version information string */
runtime_info_str = g_string_new("Running ");
- get_runtime_version_info(runtime_info_str, NULL);
+ get_runtime_version_info(runtime_info_str, NULL);
show_version(comp_info_str, runtime_info_str);
g_string_free(comp_info_str, TRUE);
g_string_free(runtime_info_str, TRUE);
/*** all non capture option specific ***/
case 'D': /* Print a list of capture devices and exit */
- status = capture_opts_list_interfaces();
+ status = capture_opts_list_interfaces(FALSE);
exit_main(status);
break;
+ /* XXX - We might want to use 'D' for this. Do we use GNU
+ * getopt on every platform (which supports optional arguments)? */
+ /* XXX - Implement interface stats */
+ case 'I':
+ status = capture_opts_list_interfaces(TRUE);
+ exit_main(status);
case 'L': /* Print list of link-layer types and exit */
list_link_layer_types = TRUE;
break;
/* create a "timestamp" */
time(&curr);
- today = localtime(&curr);
+ today = localtime(&curr);
switch(log_level & G_LOG_LEVEL_MASK) {
case G_LOG_LEVEL_ERROR:
g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "Capture filter error: %s", errmsg);
pipe_write_block(1, SP_BAD_FILTER, errmsg);
} else {
- fprintf(stderr,
+ fprintf(stderr,
"Invalid capture filter: \"%s\"!\n"
"\n"
"That string isn't a valid capture filter (%s).\n"
report_capture_error(const char *error_msg, const char *secondary_error_msg)
{
if(capture_child) {
- g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
+ g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
"Primary Error: %s", error_msg);
- g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
+ g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
"Secondary Error: %s", secondary_error_msg);
sync_pipe_errmsg_to_parent(error_msg, secondary_error_msg);
} else {
/*
* Try to get the list of known interfaces.
*/
- if_list = get_interface_list(&err, NULL);
+ if_list = capture_interface_list(&err, NULL);
if (if_list != NULL) {
/*
* We have the list - check it.
}
#endif
- if_list = get_interface_list(&err, &err_str);
+ if_list = capture_interface_list(&err, &err_str);
if (if_list == NULL && err == CANT_GET_INTERFACE_LIST) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
g_free(err_str);
gint if_list_comparator_alph (const void *first_arg, const void *second_arg){
const if_info_t *first = first_arg, *second = second_arg;
- if (first != NULL && first->description != NULL &&
+ if (first != NULL && first->description != NULL &&
second != NULL && second->description != NULL) {
return g_strcasecmp(first->description, second->description);
} else {
#endif
/* LOAD THE INTERFACES */
- if_list = get_interface_list(&err, &err_str);
+ if_list = capture_interface_list(&err, &err_str);
if_list = g_list_sort (if_list, if_list_comparator_alph);
if (if_list == NULL && err == CANT_GET_INTERFACE_LIST) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
#include "capture_ui_utils.h"
#include "main.h"
#include "compat_macros.h"
+#include "capture.h"
#define DEVICE_KEY "device"
#define PROM_MODE_KEY "prom_mode"
/*
* XXX - what if we can't get the list?
*/
- if_list = get_interface_list(&err, NULL);
+ if_list = capture_interface_list(&err, NULL);
combo_list = build_capture_combo_list(if_list, FALSE);
free_interface_list(if_list);
if (combo_list != NULL) {
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(if_cb)->entry),
prefs.capture_device);
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_cb, 1, 2, row, row+1);
- gtk_tooltips_set_tip(tooltips, GTK_COMBO(if_cb)->entry,
+ gtk_tooltips_set_tip(tooltips, GTK_COMBO(if_cb)->entry,
"The default interface to be captured from.", NULL);
gtk_widget_show(if_cb);
OBJECT_SET_DATA(main_vb, DEVICE_KEY, if_cb);
gtk_widget_show(ifopts_lb);
ifopts_bt = BUTTON_NEW_FROM_STOCK(WIRESHARK_STOCK_EDIT);
- gtk_tooltips_set_tip(tooltips, ifopts_bt,
+ gtk_tooltips_set_tip(tooltips, ifopts_bt,
"Open a dialog box to set various interface options.", NULL);
SIGNAL_CONNECT(ifopts_bt, "clicked", ifopts_edit_cb, NULL);
gtk_table_attach_defaults(GTK_TABLE(main_tb), ifopts_bt, 1, 2, row, row+1);
promisc_cb = create_preference_check_button(main_tb, row++,
"Capture packets in promiscuous mode:", NULL,
prefs.capture_prom_mode);
- gtk_tooltips_set_tip(tooltips, promisc_cb,
+ gtk_tooltips_set_tip(tooltips, promisc_cb,
"Usually a network card will only capture the traffic sent to its own network address. "
"If you want to capture all traffic that the network card can \"see\", mark this option. "
"See the FAQ for some more details of capturing packets from a switched network.", NULL);
int row = 0;
GtkWidget *caller = gtk_widget_get_toplevel(w);
-
+
/* Has an edit dialog box already been opened for that top-level
widget? */
ifopts_edit_dlg = OBJECT_GET_DATA(caller, IFOPTS_DIALOG_PTR_KEY);
reactivate_window(ifopts_edit_dlg);
return;
}
-
+
/* create a new dialog */
ifopts_edit_dlg = dlg_window_new("Wireshark: Preferences: Interface Options");
gtk_window_set_default_size(GTK_WINDOW(ifopts_edit_dlg), DEF_WIDTH, 300);
gtk_container_border_width(GTK_CONTAINER(main_vb), 5);
gtk_container_add(GTK_CONTAINER(ifopts_edit_dlg), main_vb);
gtk_widget_show(main_vb);
-
+
/* create current options frame */
cur_opts_fr = gtk_frame_new("Interfaces");
gtk_container_add(GTK_CONTAINER(main_vb), cur_opts_fr);
gtk_widget_show(cur_opts_fr);
-
+
/* create a scrolled window to pack the current options CList widget into */
cur_scr_win = scrolled_window_new(NULL, NULL);
gtk_container_border_width(GTK_CONTAINER(cur_scr_win), 3);
gtk_container_add(GTK_CONTAINER(cur_opts_fr), cur_scr_win);
gtk_widget_show(cur_scr_win);
-
+
/*
* Create current options CList.
*/
gtk_container_add(GTK_CONTAINER(cur_scr_win), cur_clist);
SIGNAL_CONNECT(cur_clist, "select_row", ifopts_edit_ifsel_cb, NULL);
gtk_widget_show(cur_clist);
-
+
/* add interface names to cell */
ifopts_if_clist_add();
gtk_clist_columns_autosize(GTK_CLIST(cur_clist));
-
+
/* initialize variable that saves currently selected row in "if_clist" */
ifrow = IFOPTS_IF_NOSEL;
-
+
/* create edit options frame */
ed_opts_fr = gtk_frame_new("Properties");
gtk_box_pack_start(GTK_BOX(main_vb), ed_opts_fr, FALSE, FALSE, 0);
gtk_widget_show(ed_opts_fr);
-
+
main_hb = gtk_hbox_new(TRUE, 5);
gtk_container_border_width(GTK_CONTAINER(main_hb), 3);
gtk_container_add(GTK_CONTAINER(ed_opts_fr), main_hb);
gtk_widget_show(main_hb);
-
+
/* table to hold description text entry and hide button */
main_tb = gtk_table_new(IFOPTS_TABLE_ROWS, 4, FALSE);
gtk_box_pack_start(GTK_BOX(main_hb), main_tb, TRUE, FALSE, 10);
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_dev_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_dev_lb), 1.0, 0.5);
gtk_widget_show(if_dev_lb);
-
+
if_dev_lb = gtk_label_new("");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_dev_lb, 1, 2, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_dev_lb), 0.0, 0.5);
gtk_widget_show(if_dev_lb);
row++;
-
+
if_name_lb = gtk_label_new("Description:");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_name_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_name_lb), 1.0, 0.5);
gtk_widget_show(if_name_lb);
-
+
if_name_lb = gtk_label_new("");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_name_lb, 1, 2, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_name_lb), 0.0, 0.5);
gtk_widget_show(if_name_lb);
row++;
-
+
/* create interface description label and text entry */
if_descr_lb = gtk_label_new("Comment:");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_descr_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_descr_lb), 1.0, 0.5);
gtk_widget_show(if_descr_lb);
-
+
if_descr_te = gtk_entry_new();
- SIGNAL_CONNECT(if_descr_te, "changed", ifopts_edit_descr_changed_cb,
+ SIGNAL_CONNECT(if_descr_te, "changed", ifopts_edit_descr_changed_cb,
cur_clist);
gtk_entry_set_max_length(GTK_ENTRY(if_descr_te), IFOPTS_MAX_DESCR_LEN);
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_descr_te, 1, 2, row, row+1);
gtk_widget_show(if_descr_te);
row++;
-
+
/* create hide interface label and button */
if_hide_lb = gtk_label_new("Hide interface?:");
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_hide_lb, 0, 1, row, row+1);
gtk_misc_set_alignment(GTK_MISC(if_hide_lb), 1.0, 0.5);
gtk_widget_show(if_hide_lb);
-
+
if_hide_cb = gtk_check_button_new();
- SIGNAL_CONNECT(if_hide_cb, "toggled", ifopts_edit_hide_changed_cb,
+ SIGNAL_CONNECT(if_hide_cb, "toggled", ifopts_edit_hide_changed_cb,
cur_clist);
gtk_table_attach_defaults(GTK_TABLE(main_tb), if_hide_cb, 1, 2, row, row+1);
gtk_widget_show(if_hide_cb);
row++;
-
+
/* button row: OK and Cancel buttons */
bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, NULL);
gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 0);
/* select the first row in if list, all option fields must exist for this */
gtk_clist_select_row(GTK_CLIST(cur_clist), 0, -1);
-
+
gtk_widget_show(ifopts_edit_dlg);
window_present(ifopts_edit_dlg);
}
if (ifrow != IFOPTS_IF_NOSEL) {
/* create/write new interfaces description string */
ifopts_write_new_descr();
-
+
/* create/write new "hidden" interfaces string */
ifopts_write_new_hide();
}
-
+
/* Now nuke this window. */
gtk_grab_remove(GTK_WIDGET(parent_w));
window_destroy(GTK_WIDGET(parent_w));
gpointer data _U_)
{
gchar *text;
-
+
/* save currently selected row */
ifrow = row;
-
+
/* get/display the interface device from current CList */
gtk_clist_get_text(GTK_CLIST(cur_clist), row, 0, &text);
/* is needed, as gtk_entry_set_text() will change text again (bug in GTK?) */
text = strdup(text);
gtk_label_set_text(GTK_LABEL(if_dev_lb), text);
g_free(text);
-
+
/* get/display the interface name from current CList */
gtk_clist_get_text(GTK_CLIST(cur_clist), row, 1, &text);
/* is needed, as gtk_entry_set_text() will change text again (bug in GTK?) */
text = strdup(text);
gtk_label_set_text(GTK_LABEL(if_name_lb), text);
g_free(text);
-
+
/* get/display the interface description from current CList */
gtk_clist_get_text(GTK_CLIST(cur_clist), row, 2, &text);
/* is needed, as gtk_entry_set_text() will change text again (bug in GTK?) */
text = strdup(text);
gtk_entry_set_text(GTK_ENTRY(if_descr_te), text);
g_free(text);
-
+
/* get/display the "hidden" button state from current CList */
gtk_clist_get_text(GTK_CLIST(cur_clist), row, 3, &text);
if (strcmp("Yes", text) == 0)
ifopts_edit_descr_changed_cb(GtkEditable *ed, gpointer udata)
{
gchar *text;
-
+
if (ifrow == IFOPTS_IF_NOSEL)
return;
-
+
/* get current description text and set value in current CList */
text = gtk_editable_get_chars(GTK_EDITABLE(ed), 0, -1);
/* replace any reserved formatting characters "()," with spaces */
{
if (ifrow == IFOPTS_IF_NOSEL)
return;
-
+
/* get "hidden" button state and set text in current CList */
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tbt)) == TRUE)
gtk_clist_set_text(GTK_CLIST(udata), ifrow, 3, "Yes");
* Add any saved options that apply to cells in current CList.
*
* NOTE:
- * Interfaces that have been removed from the machine or disabled and
- * no longer apply are ignored. Therefore, if the user subsequently
- * selects "OK", the options for these interfaces are lost (they're
+ * Interfaces that have been removed from the machine or disabled and
+ * no longer apply are ignored. Therefore, if the user subsequently
+ * selects "OK", the options for these interfaces are lost (they're
* lost permanently if "Save" is selected).
*/
static void
gchar *desc;
gchar *pr_descr;
gchar *text[] = { NULL, NULL, NULL, NULL };
-
+
/* add interface descriptions and "hidden" flag */
if (prefs.capture_devices_descr != NULL) {
/* create working copy of device descriptions */
pr_descr = g_strdup(prefs.capture_devices_descr);
-
+
/* if we find a description for this interface */
if ((ifnm = strstr(pr_descr, if_info->name)) != NULL) {
p = ifnm;
text[2] = g_strdup(desc);
/* add row to CList */
row = gtk_clist_append(GTK_CLIST(clist), text);
- gtk_clist_set_selectable(GTK_CLIST(clist), row,
+ gtk_clist_set_selectable(GTK_CLIST(clist), row,
FALSE);
ifopts_options_free(text);
break;
}
else
text[3] = g_strdup("No");
-
+
/* add row to CList */
row = gtk_clist_append(GTK_CLIST(clist), text);
gtk_clist_set_selectable(GTK_CLIST(clist), row, FALSE);
ifopts_options_free(text);
}
-
+
g_free(pr_descr);
}
/*
text[3] = g_strdup("Yes");
else
text[3] = g_strdup("No");
-
+
/* add row to CList */
row = gtk_clist_append(GTK_CLIST(clist), text);
gtk_clist_set_selectable(GTK_CLIST(clist), row, FALSE);
text[2] = g_strdup("");
/* interface is not "hidden" */
text[3] = g_strdup("No");
-
+
/* add row to CList */
row = gtk_clist_append(GTK_CLIST(clist), text);
gtk_clist_set_selectable(GTK_CLIST(clist), row, FALSE);
ifopts_options_free(gchar *text[])
{
gint i;
-
+
for (i=0; i < IFOPTS_CLIST_COLS; i++) {
if (text[i] != NULL) {
g_free(text[i]);
if_info_t *if_info;
guint i;
guint nitems;
-
- if_list = get_interface_list(&err, &err_str);
+
+ if_list = capture_interface_list(&err, &err_str);
if (if_list == NULL && err == CANT_GET_INTERFACE_LIST) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
g_free(err_str);
return;
}
-
+
/* Seems we need to be at list head for g_list_length()? */
if_list = g_list_first(if_list);
nitems = g_list_length(if_list);
-
+
/* add OS description + interface name text to CList */
for (i=0; i < nitems; i++) {
if_info = g_list_nth_data(if_list, i);
/* fill current options CList with current preference values */
ifopts_options_add(GTK_CLIST(cur_clist), if_info);
}
-
+
free_interface_list(if_list);
}
gchar *desc;
gchar *tmp_descr;
gchar *new_descr;
-
+
/* new preferences interfaces description string */
new_descr = g_malloc0(MAX_VAL_LEN);
-
+
/* get description for each row (interface) */
for (i = 0; ;i++) {
/* get description */
/* if no description, skip this interface */
if (strlen(desc) == 0)
continue;
-
+
/* get interface name */
gtk_clist_get_text(GTK_CLIST(cur_clist), i, 0, &ifnm);
/* set first-in-list flag to false */
first_if = FALSE;
}
-
+
/* write new description string to preferences */
if (strlen(new_descr) > 0) {
g_free(prefs.capture_devices_descr);
gchar *hide;
gchar *tmp_hide;
gchar *new_hide;
-
+
/* new preferences "hidden" interfaces string */
new_hide = g_malloc0(MAX_VAL_LEN);
-
+
/* get "hidden" flag text for each row (interface) */
for (i = 0; ;i++) {
/* get flag */
/* get interface name */
gtk_clist_get_text(GTK_CLIST(cur_clist), i, 0, &ifnm);
-
+
/*
* create/cat interface to new string
*/
/* set first-in-list flag to false */
first_if = FALSE;
}
-
+
/* write new "hidden" string to preferences */
if (strlen(new_hide) > 0) {
g_free(prefs.capture_devices_hide);
/*** all non capture option specific ***/
case 'D': /* Print a list of capture devices and exit */
#ifdef HAVE_LIBPCAP
- capture_opts_list_interfaces();
+ capture_opts_list_interfaces(FALSE);
exit(0);
#else
capture_option_specified = TRUE;
*/
opterr = 0;
optind_initial = optind;
-
+
while ((opt = getopt(argc, argv, optstring)) != -1) {
switch (opt) {
case 'X':
break;
}
}
-
+
optind = optind_initial;
opterr = 1;
break;
case 'D': /* Print a list of capture devices and exit */
#ifdef HAVE_LIBPCAP
- status = capture_opts_list_interfaces();
+ status = capture_opts_list_interfaces(FALSE);
exit(status);
#else
capture_option_specified = TRUE;
"specified with \"-e\".");
exit(1);
- }
+ }
/* If no capture filter or read filter has been specified, and there are
still command-line arguments, treat them as the tokens of a capture
"a capture isn't being done.");
exit(1);
}
-
+
/* Note: TShark now allows the restriction of a _read_ file by packet count
* and byte count as well as a write file. Other autostop options remain valid
* only for a write file.
/* Process the packets in the file */
#ifdef HAVE_LIBPCAP
- err = load_cap_file(&cfile, capture_opts.save_file, out_file_type,
+ err = load_cap_file(&cfile, capture_opts.save_file, out_file_type,
capture_opts.has_autostop_packets ? capture_opts.autostop_packets : 0,
capture_opts.has_autostop_filesize ? capture_opts.autostop_filesize : 0);
#else
#endif /* HAVE_LIBPCAP */
static int
-load_cap_file(capture_file *cf, char *save_file, int out_file_type,
+load_cap_file(capture_file *cf, char *save_file, int out_file_type,
int max_packet_count, gint64 max_byte_count)
{
gint linktype;
}
if (passed) {
- /* Keep the time of the current packet if the packet passed
+ /* Keep the time of the current packet if the packet passed
the read filter so that the delta time since last displayed
packet can be calculated */
prev_dis_ts = fdata.abs_ts;
case WRITE_FIELDS:
proto_tree_write_fields(output_fields, edt, stdout);
printf("\n");
- return !ferror(stdout);
+ return !ferror(stdout);
}
} else {
/* Just fill in the columns. */
git.samba.org / jelmer / wireshark.git / commitdiff