osmocom
/
wireshark
14
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity

Pull the capture-session state information out of capture_opts and put 

it into a separate capture_session structure.  capture_opts should
contain only user-specified option information (and stuff directly
derived from it, such as the "capturing from a pipe" flag).

svn path=/trunk/; revision=49493
This commit is contained in:
Guy Harris 2013-05-22 07:44:28 +00:00
parent 54ca6dae29
commit 8596d17d7f
23 changed files with 278 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile.common
View File

@ -97,6 +97,7 @@ SHARK_COMMON_CAPTURE_SRC = \
# corresponding headers # corresponding headers
SHARK_COMMON_CAPTURE_INCLUDES = \ SHARK_COMMON_CAPTURE_INCLUDES = \
capture_ifinfo.h \ capture_ifinfo.h \
capture_session.h \
capture_sync.h \ capture_sync.h \
capture_ui_utils.h capture_ui_utils.h

163
capture.c
View File

@ -77,7 +77,7 @@ typedef struct {
static GList *capture_callbacks = NULL; static GList *capture_callbacks = NULL;
static void static void
capture_callback_invoke(int event, capture_options *capture_opts) capture_callback_invoke(int event, capture_session *cap_session)
{ {
capture_callback_data_t *cb; capture_callback_data_t *cb;
GList *cb_item = capture_callbacks; GList *cb_item = capture_callbacks;
@ -87,7 +87,7 @@ capture_callback_invoke(int event, capture_options *capture_opts)
while(cb_item != NULL) { while(cb_item != NULL) {
cb = (capture_callback_data_t *)cb_item->data; cb = (capture_callback_data_t *)cb_item->data;
cb->cb_fct(event, capture_opts, cb->user_data); cb->cb_fct(event, cap_session, cb->user_data);
cb_item = g_list_next(cb_item); cb_item = g_list_next(cb_item);
} }
} }
@ -130,13 +130,13 @@ capture_callback_remove(capture_callback_t func)
* @return TRUE if the capture starts successfully, FALSE otherwise. * @return TRUE if the capture starts successfully, FALSE otherwise.
*/ */
gboolean gboolean
capture_start(capture_options *capture_opts) capture_start(capture_options *capture_opts, capture_session *cap_session)
{ {
gboolean ret; gboolean ret;
guint i; guint i;
GString *source = g_string_new(""); GString *source = g_string_new("");
capture_opts->state = CAPTURE_PREPARING; cap_session->state = CAPTURE_PREPARING;
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Start ..."); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Start ...");
#ifdef _WIN32 #ifdef _WIN32
if (capture_opts->ifaces->len < 2) { if (capture_opts->ifaces->len < 2) {
@ -165,10 +165,10 @@ capture_start(capture_options *capture_opts)
} else { } else {
g_string_append_printf(source, "%u interfaces", capture_opts->ifaces->len); g_string_append_printf(source, "%u interfaces", capture_opts->ifaces->len);
} }
cf_set_tempfile_source((capture_file *)capture_opts->cf, source->str); cf_set_tempfile_source((capture_file *)cap_session->cf, source->str);
g_string_free(source, TRUE); g_string_free(source, TRUE);
/* try to start the capture child process */ /* try to start the capture child process */
ret = sync_pipe_start(capture_opts); ret = sync_pipe_start(capture_opts, cap_session);
if(!ret) { if(!ret) {
if(capture_opts->save_file != NULL) { if(capture_opts->save_file != NULL) {
g_free(capture_opts->save_file); g_free(capture_opts->save_file);
@ -176,17 +176,17 @@ capture_start(capture_options *capture_opts)
} }
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Start failed!"); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Start failed!");
capture_opts->state = CAPTURE_STOPPED; cap_session->state = CAPTURE_STOPPED;
} else { } else {
/* the capture child might not respond shortly after bringing it up */ /* the capture child might not respond shortly after bringing it up */
/* (for example: it will block if no input arrives from an input capture pipe (e.g. mkfifo)) */ /* (for example: it will block if no input arrives from an input capture pipe (e.g. mkfifo)) */
/* to prevent problems, bring the main GUI into "capture mode" right after a successful */ /* to prevent problems, bring the main GUI into "capture mode" right after a successful */
/* spawn/exec of the capture child, without waiting for any response from it */ /* spawn/exec of the capture child, without waiting for any response from it */
capture_callback_invoke(capture_cb_capture_prepared, capture_opts); capture_callback_invoke(capture_cb_capture_prepared, cap_session);
if(capture_opts->show_info) if(capture_opts->show_info)
capture_info_open(capture_opts); capture_info_open(cap_session);
} }
return ret; return ret;
@ -194,54 +194,55 @@ capture_start(capture_options *capture_opts)
void void
capture_stop(capture_options *capture_opts) capture_stop(capture_session *cap_session)
{ {
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Stop ..."); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Stop ...");
capture_callback_invoke(capture_cb_capture_stopping, capture_opts); capture_callback_invoke(capture_cb_capture_stopping, cap_session);
/* stop the capture child gracefully */ /* stop the capture child gracefully */
sync_pipe_stop(capture_opts); sync_pipe_stop(cap_session);
} }
void void
capture_restart(capture_options *capture_opts) capture_restart(capture_session *cap_session)
{ {
capture_options *capture_opts = cap_session->capture_opts;
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Restart"); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Restart");
capture_opts->restart = TRUE; capture_opts->restart = TRUE;
capture_stop(capture_opts); capture_stop(cap_session);
} }
void void
capture_kill_child(capture_options *capture_opts) capture_kill_child(capture_session *cap_session)
{ {
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_INFO, "Capture Kill"); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_INFO, "Capture Kill");
/* kill the capture child */ /* kill the capture child */
sync_pipe_kill(capture_opts->fork_child); sync_pipe_kill(cap_session->fork_child);
} }
/* We've succeeded in doing a (non real-time) capture; try to read it into a new capture file */ /* We've succeeded in doing a (non real-time) capture; try to read it into a new capture file */
static gboolean static gboolean
capture_input_read_all(capture_options *capture_opts, gboolean is_tempfile, gboolean drops_known, capture_input_read_all(capture_session *cap_session, gboolean is_tempfile,
guint32 drops) gboolean drops_known, guint32 drops)
{ {
capture_options *capture_opts = cap_session->capture_opts;
int err; int err;
/* Capture succeeded; attempt to open the capture file. */ /* Capture succeeded; attempt to open the capture file. */
if (cf_open((capture_file *)capture_opts->cf, capture_opts->save_file, is_tempfile, &err) != CF_OK) { if (cf_open((capture_file *)cap_session->cf, capture_opts->save_file, is_tempfile, &err) != CF_OK) {
/* We're not doing a capture any more, so we don't have a save file. */ /* We're not doing a capture any more, so we don't have a save file. */
return FALSE; return FALSE;
} }
/* Set the read filter to NULL. */ /* Set the read filter to NULL. */
/* XXX - this is odd here; try to put it somewhere where it fits better */ /* XXX - this is odd here; try to put it somewhere where it fits better */
cf_set_rfcode((capture_file *)capture_opts->cf, NULL); cf_set_rfcode((capture_file *)cap_session->cf, NULL);
/* Get the packet-drop statistics. /* Get the packet-drop statistics.
@ -262,7 +263,7 @@ guint32 drops)
thus not have to set them here - "cf_read()" will get them from thus not have to set them here - "cf_read()" will get them from
the file and use them. */ the file and use them. */
if (drops_known) { if (drops_known) {
cf_set_drops_known((capture_file *)capture_opts->cf, TRUE); cf_set_drops_known((capture_file *)cap_session->cf, TRUE);
/* XXX - on some systems, libpcap doesn't bother filling in /* XXX - on some systems, libpcap doesn't bother filling in
"ps_ifdrop" - it doesn't even set it to zero - so we don't "ps_ifdrop" - it doesn't even set it to zero - so we don't
@ -272,11 +273,11 @@ guint32 drops)
several statistics - perhaps including various interface several statistics - perhaps including various interface
error statistics - and would tell us which of them it error statistics - and would tell us which of them it
supplies, allowing us to display only the ones it does. */ supplies, allowing us to display only the ones it does. */
cf_set_drops((capture_file *)capture_opts->cf, drops); cf_set_drops((capture_file *)cap_session->cf, drops);
} }
/* read in the packet data */ /* read in the packet data */
switch (cf_read((capture_file *)capture_opts->cf, FALSE)) { switch (cf_read((capture_file *)cap_session->cf, FALSE)) {
case CF_READ_OK: case CF_READ_OK:
case CF_READ_ERROR: case CF_READ_ERROR:
@ -293,7 +294,7 @@ guint32 drops)
} }
/* if we didn't capture even a single packet, close the file again */ /* if we didn't capture even a single packet, close the file again */
if(cf_get_packet_count((capture_file *)capture_opts->cf) == 0 && !capture_opts->restart) { if(cf_get_packet_count((capture_file *)cap_session->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" "%sNo packets captured!%s\n"
"\n" "\n"
@ -310,8 +311,8 @@ guint32 drops)
#endif #endif
"", "",
simple_dialog_primary_start(), simple_dialog_primary_end(), simple_dialog_primary_start(), simple_dialog_primary_end(),
(cf_is_tempfile((capture_file *)capture_opts->cf)) ? "temporary " : ""); (cf_is_tempfile((capture_file *)cap_session->cf)) ? "temporary " : "");
cf_close((capture_file *)capture_opts->cf); cf_close((capture_file *)cap_session->cf);
} }
return TRUE; return TRUE;
} }
@ -319,38 +320,39 @@ guint32 drops)
/* capture child tells us we have a new (or the first) capture file */ /* capture child tells us we have a new (or the first) capture file */
gboolean gboolean
capture_input_new_file(capture_options *capture_opts, gchar *new_file) capture_input_new_file(capture_session *cap_session, gchar *new_file)
{ {
capture_options *capture_opts = cap_session->capture_opts;
gboolean is_tempfile; gboolean is_tempfile;
int err; int err;
if(capture_opts->state == CAPTURE_PREPARING) { if(cap_session->state == CAPTURE_PREPARING) {
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started!"); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started!");
} }
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
g_assert(capture_opts->state == CAPTURE_PREPARING || capture_opts->state == CAPTURE_RUNNING); g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
/* free the old filename */ /* free the old filename */
if(capture_opts->save_file != NULL) { if(capture_opts->save_file != NULL) {
/* we start a new capture file, close the old one (if we had one before). */ /* we start a new capture file, close the old one (if we had one before). */
/* (we can only have an open capture file in real_time_mode!) */ /* (we can only have an open capture file in real_time_mode!) */
if( ((capture_file *) capture_opts->cf)->state != FILE_CLOSED) { if( ((capture_file *) cap_session->cf)->state != FILE_CLOSED) {
if(capture_opts->real_time_mode) { if(capture_opts->real_time_mode) {
capture_callback_invoke(capture_cb_capture_update_finished, capture_opts); capture_callback_invoke(capture_cb_capture_update_finished, cap_session);
cf_finish_tail((capture_file *)capture_opts->cf, &err); cf_finish_tail((capture_file *)cap_session->cf, &err);
cf_close((capture_file *)capture_opts->cf); cf_close((capture_file *)cap_session->cf);
} else { } else {
capture_callback_invoke(capture_cb_capture_fixed_finished, capture_opts); capture_callback_invoke(capture_cb_capture_fixed_finished, cap_session);
} }
} }
g_free(capture_opts->save_file); g_free(capture_opts->save_file);
is_tempfile = FALSE; is_tempfile = FALSE;
cf_set_tempfile((capture_file *)capture_opts->cf, FALSE); cf_set_tempfile((capture_file *)cap_session->cf, FALSE);
} else { } else {
/* we didn't have a save_file before; must be a tempfile */ /* we didn't have a save_file before; must be a tempfile */
is_tempfile = TRUE; is_tempfile = TRUE;
cf_set_tempfile((capture_file *)capture_opts->cf, TRUE); cf_set_tempfile((capture_file *)cap_session->cf, TRUE);
} }
/* save the new filename */ /* save the new filename */
@ -359,7 +361,7 @@ capture_input_new_file(capture_options *capture_opts, gchar *new_file)
/* if we are in real-time mode, open the new file now */ /* if we are in real-time mode, open the new file now */
if(capture_opts->real_time_mode) { if(capture_opts->real_time_mode) {
/* Attempt to open the capture file and set up to read from it. */ /* Attempt to open the capture file and set up to read from it. */
switch(cf_start_tail((capture_file *)capture_opts->cf, capture_opts->save_file, is_tempfile, &err)) { switch(cf_start_tail((capture_file *)cap_session->cf, capture_opts->save_file, is_tempfile, &err)) {
case CF_OK: case CF_OK:
break; break;
case CF_ERROR: case CF_ERROR:
@ -370,7 +372,7 @@ capture_input_new_file(capture_options *capture_opts, gchar *new_file)
return FALSE; return FALSE;
} }
} else { } else {
capture_callback_invoke(capture_cb_capture_prepared, capture_opts); capture_callback_invoke(capture_cb_capture_prepared, cap_session);
} }
if(capture_opts->show_info) { if(capture_opts->show_info) {
@ -379,11 +381,11 @@ capture_input_new_file(capture_options *capture_opts, gchar *new_file)
} }
if(capture_opts->real_time_mode) { if(capture_opts->real_time_mode) {
capture_callback_invoke(capture_cb_capture_update_started, capture_opts); capture_callback_invoke(capture_cb_capture_update_started, cap_session);
} else { } else {
capture_callback_invoke(capture_cb_capture_fixed_started, capture_opts); capture_callback_invoke(capture_cb_capture_fixed_started, cap_session);
} }
capture_opts->state = CAPTURE_RUNNING; cap_session->state = CAPTURE_RUNNING;
return TRUE; return TRUE;
} }
@ -391,16 +393,16 @@ capture_input_new_file(capture_options *capture_opts, gchar *new_file)
/* capture child tells us we have new packets to read */ /* capture child tells us we have new packets to read */
void void
capture_input_new_packets(capture_options *capture_opts, int to_read) capture_input_new_packets(capture_session *cap_session, int to_read)
{ {
capture_options *capture_opts = cap_session->capture_opts;
int err; int err;
g_assert(capture_opts->save_file); g_assert(capture_opts->save_file);
if(capture_opts->real_time_mode) { if(capture_opts->real_time_mode) {
/* Read from the capture file the number of records the child told us it added. */ /* Read from the capture file the number of records the child told us it added. */
switch (cf_continue_tail((capture_file *)capture_opts->cf, to_read, &err)) { switch (cf_continue_tail((capture_file *)cap_session->cf, to_read, &err)) {
case CF_READ_OK: case CF_READ_OK:
case CF_READ_ERROR: case CF_READ_ERROR:
@ -409,22 +411,22 @@ capture_input_new_packets(capture_options *capture_opts, int to_read)
file. file.
XXX - abort on a read error? */ XXX - abort on a read error? */
capture_callback_invoke(capture_cb_capture_update_continue, capture_opts); capture_callback_invoke(capture_cb_capture_update_continue, cap_session);
break; break;
case CF_READ_ABORTED: case CF_READ_ABORTED:
/* Kill the child capture process; the user wants to exit, and we /* Kill the child capture process; the user wants to exit, and we
shouldn't just leave it running. */ shouldn't just leave it running. */
capture_kill_child(capture_opts); capture_kill_child(cap_session);
break; break;
} }
} else { } else {
/* increase the capture file packet counter by the number of incoming packets */ /* increase the capture file packet counter by the number of incoming packets */
cf_set_packet_count((capture_file *)capture_opts->cf, cf_set_packet_count((capture_file *)cap_session->cf,
cf_get_packet_count((capture_file *)capture_opts->cf) + to_read); cf_get_packet_count((capture_file *)cap_session->cf) + to_read);
cf_fake_continue_tail((capture_file *)capture_opts->cf); cf_fake_continue_tail((capture_file *)cap_session->cf);
capture_callback_invoke(capture_cb_capture_fixed_continue, capture_opts); capture_callback_invoke(capture_cb_capture_fixed_continue, cap_session);
} }
/* update the main window so we get events (e.g. from the stop toolbar button) */ /* update the main window so we get events (e.g. from the stop toolbar button) */
@ -441,14 +443,14 @@ capture_input_new_packets(capture_options *capture_opts, int to_read)
/* Capture child told us how many dropped packets it counted. /* Capture child told us how many dropped packets it counted.
*/ */
void void
capture_input_drops(capture_options *capture_opts, guint32 dropped) capture_input_drops(capture_session *cap_session, guint32 dropped)
{ {
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_INFO, "%u packet%s dropped", dropped, plurality(dropped, "", "s")); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_INFO, "%u packet%s dropped", dropped, plurality(dropped, "", "s"));
g_assert(capture_opts->state == CAPTURE_RUNNING); g_assert(cap_session->state == CAPTURE_RUNNING);
cf_set_drops_known((capture_file *)capture_opts->cf, TRUE); cf_set_drops_known((capture_file *)cap_session->cf, TRUE);
cf_set_drops((capture_file *)capture_opts->cf, dropped); cf_set_drops((capture_file *)cap_session->cf, dropped);
} }
@ -459,7 +461,8 @@ capture_input_drops(capture_options *capture_opts, guint32 dropped)
The secondary message might be a null string. The secondary message might be a null string.
*/ */
void void
capture_input_error_message(capture_options *capture_opts, char *error_msg, char *secondary_error_msg) capture_input_error_message(capture_session *cap_session, char *error_msg,
char *secondary_error_msg)
{ {
gchar *safe_error_msg; gchar *safe_error_msg;
gchar *safe_secondary_error_msg; gchar *safe_secondary_error_msg;
@ -467,7 +470,7 @@ capture_input_error_message(capture_options *capture_opts, char *error_msg, char
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Error message from child: \"%s\", \"%s\"", g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Error message from child: \"%s\", \"%s\"",
error_msg, secondary_error_msg); error_msg, secondary_error_msg);
g_assert(capture_opts->state == CAPTURE_PREPARING || capture_opts->state == CAPTURE_RUNNING); g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
safe_error_msg = simple_dialog_format_message(error_msg); safe_error_msg = simple_dialog_format_message(error_msg);
if (*secondary_error_msg != '\0') { if (*secondary_error_msg != '\0') {
@ -488,14 +491,14 @@ capture_input_error_message(capture_options *capture_opts, char *error_msg, char
/* the capture child will close the sync_pipe if required, nothing to do for now */ /* the capture child will close the sync_pipe if required, nothing to do for now */
} }
/* Capture child told us that an error has occurred while parsing a /* Capture child told us that an error has occurred while parsing a
capture filter when starting/running the capture. capture filter when starting/running the capture.
*/ */
void void
capture_input_cfilter_error_message(capture_options *capture_opts, guint i, char *error_message) capture_input_cfilter_error_message(capture_session *cap_session, guint i,
char *error_message)
{ {
capture_options *capture_opts = cap_session->capture_opts;
dfilter_t *rfcode = NULL; dfilter_t *rfcode = NULL;
gchar *safe_cfilter; gchar *safe_cfilter;
gchar *safe_descr; gchar *safe_descr;
@ -504,7 +507,7 @@ capture_input_cfilter_error_message(capture_options *capture_opts, guint i, char
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture filter error message from child: \"%s\"", error_message); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture filter error message from child: \"%s\"", error_message);
g_assert(capture_opts->state == CAPTURE_PREPARING || capture_opts->state == CAPTURE_RUNNING); g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
g_assert(i < capture_opts->ifaces->len); g_assert(i < capture_opts->ifaces->len);
interface_opts = g_array_index(capture_opts->ifaces, interface_options, i); interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
@ -542,24 +545,24 @@ capture_input_cfilter_error_message(capture_options *capture_opts, guint i, char
/* the capture child will close the sync_pipe if required, nothing to do for now */ /* the capture child will close the sync_pipe if required, nothing to do for now */
} }
/* capture child closed its side of the pipe, do the required cleanup */ /* capture child closed its side of the pipe, do the required cleanup */
void void
capture_input_closed(capture_options *capture_opts, gchar *msg) capture_input_closed(capture_session *cap_session, gchar *msg)
{ {
capture_options *capture_opts = cap_session->capture_opts;
int err; int err;
int packet_count_save; int packet_count_save;
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture stopped!"); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture stopped!");
g_assert(capture_opts->state == CAPTURE_PREPARING || capture_opts->state == CAPTURE_RUNNING); g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
if (msg != NULL) if (msg != NULL)
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", msg); simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", msg);
if(capture_opts->state == CAPTURE_PREPARING) { if(cap_session->state == CAPTURE_PREPARING) {
/* We didn't start a capture; note that the attempt to start it /* We didn't start a capture; note that the attempt to start it
failed. */ failed. */
capture_callback_invoke(capture_cb_capture_failed, capture_opts); capture_callback_invoke(capture_cb_capture_failed, cap_session);
} else { } else {
/* We started a capture; process what's left of the capture file if /* We started a capture; process what's left of the capture file if
we were in "update list of packets in real time" mode, or process we were in "update list of packets in real time" mode, or process
@ -568,14 +571,14 @@ capture_input_closed(capture_options *capture_opts, gchar *msg)
cf_read_status_t status; cf_read_status_t status;
/* Read what remains of the capture file. */ /* Read what remains of the capture file. */
status = cf_finish_tail((capture_file *)capture_opts->cf, &err); status = cf_finish_tail((capture_file *)cap_session->cf, &err);
/* XXX: If -Q (quit-after-cap) then cf->count clr'd below so save it first */ /* XXX: If -Q (quit-after-cap) then cf->count clr'd below so save it first */
packet_count_save = cf_get_packet_count((capture_file *)capture_opts->cf); packet_count_save = cf_get_packet_count((capture_file *)cap_session->cf);
/* Tell the GUI we are not doing a capture any more. /* Tell the GUI we are not doing a capture any more.
Must be done after the cf_finish_tail(), so file lengths are Must be done after the cf_finish_tail(), so file lengths are
correctly displayed */ correctly displayed */
capture_callback_invoke(capture_cb_capture_update_finished, capture_opts); capture_callback_invoke(capture_cb_capture_update_finished, cap_session);
/* Finish the capture. */ /* Finish the capture. */
switch (status) { switch (status) {
@ -598,8 +601,8 @@ capture_input_closed(capture_options *capture_opts, gchar *msg)
#endif #endif
"", "",
simple_dialog_primary_start(), simple_dialog_primary_end(), simple_dialog_primary_start(), simple_dialog_primary_end(),
cf_is_tempfile((capture_file *)capture_opts->cf) ? "temporary " : ""); cf_is_tempfile((capture_file *)cap_session->cf) ? "temporary " : "");
cf_close((capture_file *)capture_opts->cf); cf_close((capture_file *)cap_session->cf);
} }
break; break;
case CF_READ_ERROR: case CF_READ_ERROR:
@ -616,12 +619,12 @@ capture_input_closed(capture_options *capture_opts, gchar *msg)
} }
} else { } else {
/* first of all, we are not doing a capture any more */ /* first of all, we are not doing a capture any more */
capture_callback_invoke(capture_cb_capture_fixed_finished, capture_opts); capture_callback_invoke(capture_cb_capture_fixed_finished, cap_session);
/* this is a normal mode capture and if no error happened, read in the capture file data */ /* this is a normal mode capture and if no error happened, read in the capture file data */
if(capture_opts->save_file != NULL) { if(capture_opts->save_file != NULL) {
capture_input_read_all(capture_opts, cf_is_tempfile((capture_file *)capture_opts->cf), capture_input_read_all(cap_session, cf_is_tempfile((capture_file *)cap_session->cf),
cf_get_drops_known((capture_file *)capture_opts->cf), cf_get_drops((capture_file *)capture_opts->cf)); cf_get_drops_known((capture_file *)cap_session->cf), cf_get_drops((capture_file *)cap_session->cf));
} }
} }
} }
@ -629,11 +632,11 @@ capture_input_closed(capture_options *capture_opts, gchar *msg)
if(capture_opts->show_info) if(capture_opts->show_info)
capture_info_close(); capture_info_close();
capture_opts->state = CAPTURE_STOPPED; cap_session->state = CAPTURE_STOPPED;
/* if we couldn't open a capture file, there's nothing more for us to do */ /* if we couldn't open a capture file, there's nothing more for us to do */
if(capture_opts->save_file == NULL) { if(capture_opts->save_file == NULL) {
cf_close((capture_file *)capture_opts->cf); cf_close((capture_file *)cap_session->cf);
return; return;
} }
@ -644,7 +647,7 @@ capture_input_closed(capture_options *capture_opts, gchar *msg)
ws_unlink(capture_opts->save_file); ws_unlink(capture_opts->save_file);
/* if it was a tempfile, throw away the old filename (so it will become a tempfile again) */ /* if it was a tempfile, throw away the old filename (so it will become a tempfile again) */
if(cf_is_tempfile((capture_file *)capture_opts->cf)) { if(cf_is_tempfile((capture_file *)cap_session->cf)) {
g_free(capture_opts->save_file); g_free(capture_opts->save_file);
capture_opts->save_file = NULL; capture_opts->save_file = NULL;
} }
@ -655,9 +658,9 @@ capture_input_closed(capture_options *capture_opts, gchar *msg)
} }
/* close the currently loaded capture file */ /* close the currently loaded capture file */
cf_close((capture_file *)capture_opts->cf); cf_close((capture_file *)cap_session->cf);
capture_start(capture_opts); capture_start(capture_opts, cap_session);
} else { } else {
/* We're not doing a capture any more, so we don't have a save file. */ /* We're not doing a capture any more, so we don't have a save file. */
g_free(capture_opts->save_file); g_free(capture_opts->save_file);

35
capture.h
View File

@ -32,6 +32,7 @@
*/ */
#include "capture_opts.h" #include "capture_opts.h"
#include "capture_session.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
@ -49,7 +50,7 @@ typedef enum {
capture_cb_capture_failed capture_cb_capture_failed
} capture_cbs; } capture_cbs;
typedef void (*capture_callback_t) (gint event, capture_options *capture_opts, typedef void (*capture_callback_t) (gint event, capture_session *cap_session,
gpointer user_data); gpointer user_data);
extern void extern void
@ -64,48 +65,60 @@ capture_callback_remove(capture_callback_t func);
* @param capture_opts the numerous capture options * @param capture_opts the numerous capture options
* @return TRUE if the capture starts successfully, FALSE otherwise. * @return TRUE if the capture starts successfully, FALSE otherwise.
*/ */
extern gboolean capture_start(capture_options *capture_opts); extern gboolean
capture_start(capture_options *capture_opts, capture_session *cap_session);
/** Stop a capture session (usually from a menu item). */ /** Stop a capture session (usually from a menu item). */
extern void capture_stop(capture_options *capture_opts); extern void
capture_stop(capture_session *cap_session);
/** Restart the current captured packets and start again. */ /** Restart the current captured packets and start again. */
extern void capture_restart(capture_options *capture_opts); extern void
capture_restart(capture_session *cap_session);
/** Terminate the capture child cleanly when exiting. */ /** Terminate the capture child cleanly when exiting. */
extern void capture_kill_child(capture_options *capture_opts); extern void
capture_kill_child(capture_session *cap_session);
/** /**
* Capture child told us we have a new (or the first) capture file. * Capture child told us we have a new (or the first) capture file.
*/ */
extern gboolean capture_input_new_file(capture_options *capture_opts, gchar *new_file); extern gboolean
capture_input_new_file(capture_session *cap_session, gchar *new_file);
/** /**
* Capture child told us we have new packets to read. * Capture child told us we have new packets to read.
*/ */
extern void capture_input_new_packets(capture_options *capture_opts, int to_read); extern void
capture_input_new_packets(capture_session *cap_session, int to_read);
/** /**
* Capture child told us how many dropped packets it counted. * Capture child told us how many dropped packets it counted.
*/ */
extern void capture_input_drops(capture_options *capture_opts, guint32 dropped); extern void
capture_input_drops(capture_session *cap_session, guint32 dropped);
/** /**
* Capture child told us that an error has occurred while starting the capture. * Capture child told us that an error has occurred while starting the capture.
*/ */
extern void capture_input_error_message(capture_options *capture_opts, char *error_message, char *secondary_error_msg); extern void
capture_input_error_message(capture_session *cap_session, char *error_message,
char *secondary_error_msg);
/** /**
* Capture child told us that an error has occurred while parsing a * Capture child told us that an error has occurred while parsing a
* capture filter when starting/running the capture. * capture filter when starting/running the capture.
*/ */
extern void capture_input_cfilter_error_message(capture_options *capture_opts, guint i, char *error_message); extern void
capture_input_cfilter_error_message(capture_session *cap_session, guint i,
char *error_message);
/** /**
* Capture child closed its side of the pipe, report any error and * Capture child closed its side of the pipe, report any error and
* do the required cleanup. * do the required cleanup.
*/ */
extern void capture_input_closed(capture_options *capture_opts, gchar *msg); extern void
capture_input_closed(capture_session *cap_session, gchar *msg);
struct if_stat_cache_s; struct if_stat_cache_s;
typedef struct if_stat_cache_s if_stat_cache_t; typedef struct if_stat_cache_s if_stat_cache_t;

1
capture_ifinfo.c
View File

@ -49,6 +49,7 @@
#include <glib.h> #include <glib.h>
#include "capture_opts.h" #include "capture_opts.h"
#include "capture_session.h"
#include "capture_sync.h" #include "capture_sync.h"
#include "log.h" #include "log.h"

4
capture_info.c
View File

@ -75,7 +75,7 @@ static info_data_t info_data;
/* open the info */ /* open the info */
void capture_info_open(capture_options *capture_opts) void capture_info_open(capture_session *cap_session)
{ {
info_data.counts.total = 0; info_data.counts.total = 0;
info_data.counts.sctp = 0; info_data.counts.sctp = 0;
@ -95,7 +95,7 @@ void capture_info_open(capture_options *capture_opts)
info_data.wtap = NULL; info_data.wtap = NULL;
info_data.ui.counts = &info_data.counts; info_data.ui.counts = &info_data.counts;
capture_info_ui_create(&info_data.ui, capture_opts); capture_info_ui_create(&info_data.ui, cap_session);
} }

8
capture_info.h
View File

@ -33,13 +33,14 @@
#define __CAPTURE_INFO_H__ #define __CAPTURE_INFO_H__
#include "capture_opts.h" #include "capture_opts.h"
#include "capture_session.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
/* open the info - init values (wtap, counts), create dialog */ /* open the info - init values (wtap, counts), create dialog */
extern void capture_info_open(capture_options *capture_opts); extern void capture_info_open(capture_session *cap_session);
/* new file arrived - (eventually close old wtap), open wtap */ /* new file arrived - (eventually close old wtap), open wtap */
extern gboolean capture_info_new_file(const char *new_filename); extern gboolean capture_info_new_file(const char *new_filename);
@ -65,9 +66,8 @@ typedef struct {
/** Create the capture info dialog */ /** Create the capture info dialog */
extern void capture_info_ui_create( extern void
capture_info *cinfo, capture_info_ui_create(capture_info *cinfo, capture_session *cap_session);
capture_options *capture_opts);
/** Update the capture info counters in the dialog */ /** Update the capture info counters in the dialog */
extern void capture_info_ui_update( extern void capture_info_ui_update(

20
capture_opts.c
View File

@ -54,9 +54,8 @@ static gboolean capture_opts_output_to_pipe(const char *save_file, gboolean *is_
void void
capture_opts_init(capture_options *capture_opts, void *cf) capture_opts_init(capture_options *capture_opts)
{ {
capture_opts->cf = cf;
capture_opts->ifaces = g_array_new(FALSE, FALSE, sizeof(interface_options)); capture_opts->ifaces = g_array_new(FALSE, FALSE, sizeof(interface_options));
capture_opts->all_ifaces = g_array_new(FALSE, FALSE, sizeof(interface_t)); capture_opts->all_ifaces = g_array_new(FALSE, FALSE, sizeof(interface_t));
capture_opts->num_selected = 0; capture_opts->num_selected = 0;
@ -114,18 +113,7 @@ capture_opts_init(capture_options *capture_opts, void *cf)
capture_opts->has_autostop_duration = FALSE; capture_opts->has_autostop_duration = FALSE;
capture_opts->autostop_duration = 60; /* 1 min */ capture_opts->autostop_duration = 60; /* 1 min */
capture_opts->fork_child = -1; /* invalid process handle */
#ifdef _WIN32
capture_opts->signal_pipe_write_fd = -1;
#endif
capture_opts->state = CAPTURE_STOPPED;
capture_opts->output_to_pipe = FALSE; capture_opts->output_to_pipe = FALSE;
#ifndef _WIN32
capture_opts->owner = getuid();
capture_opts->group = getgid();
#endif
capture_opts->session_started = FALSE;
} }
@ -135,7 +123,6 @@ capture_opts_log(const char *log_domain, GLogLevelFlags log_level, capture_optio
guint i; guint i;
g_log(log_domain, log_level, "CAPTURE OPTIONS :"); g_log(log_domain, log_level, "CAPTURE OPTIONS :");
g_log(log_domain, log_level, "CFile : %p", capture_opts->cf);
for (i = 0; i < capture_opts->ifaces->len; i++) { for (i = 0; i < capture_opts->ifaces->len; i++) {
interface_options interface_opts; interface_options interface_opts;
@ -229,11 +216,6 @@ capture_opts_log(const char *log_domain, GLogLevelFlags log_level, capture_optio
g_log(log_domain, log_level, "AutostopPackets (%u) : %u", capture_opts->has_autostop_packets, capture_opts->autostop_packets); g_log(log_domain, log_level, "AutostopPackets (%u) : %u", capture_opts->has_autostop_packets, capture_opts->autostop_packets);
g_log(log_domain, log_level, "AutostopFilesize(%u) : %u (KB)", capture_opts->has_autostop_filesize, capture_opts->autostop_filesize); g_log(log_domain, log_level, "AutostopFilesize(%u) : %u (KB)", capture_opts->has_autostop_filesize, capture_opts->autostop_filesize);
g_log(log_domain, log_level, "AutostopDuration(%u) : %u", capture_opts->has_autostop_duration, capture_opts->autostop_duration); g_log(log_domain, log_level, "AutostopDuration(%u) : %u", capture_opts->has_autostop_duration, capture_opts->autostop_duration);
g_log(log_domain, log_level, "ForkChild : %d", capture_opts->fork_child);
#ifdef _WIN32
g_log(log_domain, log_level, "SignalPipeWrite : %d", capture_opts->signal_pipe_write_fd);
#endif
} }
/* /*

21
capture_opts.h
View File

@ -42,13 +42,6 @@
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
/* Current state of capture engine. XXX - differentiate states */
typedef enum {
CAPTURE_STOPPED, /**< stopped */
CAPTURE_PREPARING, /**< preparing, but still no response from capture child */
CAPTURE_RUNNING /**< capture child signalled ok, capture is running now */
} capture_state;
#ifdef HAVE_PCAP_REMOTE #ifdef HAVE_PCAP_REMOTE
/* Type of capture source */ /* Type of capture source */
typedef enum { typedef enum {
@ -168,7 +161,6 @@ typedef struct interface_options_tag {
/** Capture options coming from user interface */ /** Capture options coming from user interface */
typedef struct capture_options_tag { typedef struct capture_options_tag {
/* general */ /* general */
void *cf; /**< handle to cfile (note: untyped handle) */
GArray *ifaces; /**< array of interfaces. GArray *ifaces; /**< array of interfaces.
Currently only used by dumpcap. */ Currently only used by dumpcap. */
GArray *all_ifaces; GArray *all_ifaces;
@ -209,23 +201,12 @@ typedef struct capture_options_tag {
gint32 autostop_duration; /**< Maximum capture duration */ gint32 autostop_duration; /**< Maximum capture duration */
/* internally used (don't touch from outside) */ /* internally used (don't touch from outside) */
int fork_child; /**< If not -1, in parent, process ID of child */
int fork_child_status; /**< Child exit status */
#ifdef _WIN32
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) */ gboolean output_to_pipe; /**< save_file is a pipe (named or stdout) */
#ifndef _WIN32
uid_t owner; /**< owner of the cfile */
gid_t group; /**< group of the cfile */
#endif
gboolean session_started;
} capture_options; } capture_options;
/* initialize the capture_options with some reasonable values */ /* initialize the capture_options with some reasonable values */
extern void extern void
capture_opts_init(capture_options *capture_opts, void *cf); capture_opts_init(capture_options *capture_opts);
/* set a command line option value */ /* set a command line option value */
extern int extern int

79
capture_sync.c
View File

@ -118,7 +118,21 @@ static void pipe_convert_header(const guchar *header, int header_len, char *indi
static ssize_t pipe_read_block(int pipe_fd, char *indicator, int len, char *msg, static ssize_t pipe_read_block(int pipe_fd, char *indicator, int len, char *msg,
char **err_msg); char **err_msg);
void
capture_session_init(capture_session *cap_session, void *cf)
{
cap_session->cf = cf;
cap_session->fork_child = -1; /* invalid process handle */
#ifdef _WIN32
cap_session->signal_pipe_write_fd = -1;
#endif
cap_session->state = CAPTURE_STOPPED;
#ifndef _WIN32
cap_session->owner = getuid();
cap_session->group = getgid();
#endif
cap_session->session_started = FALSE;
}
/* Append an arg (realloc) to an argc/argv array */ /* Append an arg (realloc) to an argc/argv array */
/* (add a string pointer to a NULL-terminated array of string pointers) */ /* (add a string pointer to a NULL-terminated array of string pointers) */
@ -320,7 +334,8 @@ init_pipe_args(int *argc) {
#define ARGV_NUMBER_LEN 24 #define ARGV_NUMBER_LEN 24
/* a new capture run: start a new dumpcap task and hand over parameters through command line */ /* a new capture run: start a new dumpcap task and hand over parameters through command line */
gboolean gboolean
sync_pipe_start(capture_options *capture_opts) { sync_pipe_start(capture_options *capture_opts, capture_session *cap_session)
{
char ssnap[ARGV_NUMBER_LEN]; char ssnap[ARGV_NUMBER_LEN];
char scount[ARGV_NUMBER_LEN]; char scount[ARGV_NUMBER_LEN];
char sfilesize[ARGV_NUMBER_LEN]; char sfilesize[ARGV_NUMBER_LEN];
@ -368,7 +383,7 @@ sync_pipe_start(capture_options *capture_opts) {
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_start"); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_start");
capture_opts_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, capture_opts); capture_opts_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, capture_opts);
capture_opts->fork_child = -1; cap_session->fork_child = -1;
argv = init_pipe_args(&argc); argv = init_pipe_args(&argc);
if (!argv) { if (!argv) {
@ -594,7 +609,7 @@ sync_pipe_start(capture_options *capture_opts) {
g_free( (gpointer) argv); g_free( (gpointer) argv);
return FALSE; return FALSE;
} }
capture_opts->fork_child = (int) pi.hProcess; cap_session->fork_child = (int) pi.hProcess;
g_string_free(args, TRUE); g_string_free(args, TRUE);
/* associate the operating system filehandle to a C run-time file handle */ /* associate the operating system filehandle to a C run-time file handle */
@ -615,7 +630,7 @@ sync_pipe_start(capture_options *capture_opts) {
return FALSE; return FALSE;
} }
if ((capture_opts->fork_child = fork()) == 0) { if ((cap_session->fork_child = fork()) == 0) {
/* /*
* Child process - run dumpcap with the right arguments to make * Child process - run dumpcap with the right arguments to make
* it just capture with the specified capture parameters * it just capture with the specified capture parameters
@ -658,7 +673,7 @@ sync_pipe_start(capture_options *capture_opts) {
ws_close(sync_pipe[PIPE_WRITE]); ws_close(sync_pipe[PIPE_WRITE]);
#endif #endif
if (capture_opts->fork_child == -1) { if (cap_session->fork_child == -1) {
/* We couldn't even create the child process. */ /* We couldn't even create the child process. */
report_failure("Couldn't create child process: %s", g_strerror(errno)); report_failure("Couldn't create child process: %s", g_strerror(errno));
ws_close(sync_pipe_read_fd); ws_close(sync_pipe_read_fd);
@ -668,7 +683,8 @@ sync_pipe_start(capture_options *capture_opts) {
return FALSE; return FALSE;
} }
capture_opts->fork_child_status = 0; cap_session->fork_child_status = 0;
cap_session->capture_opts = capture_opts;
/* we might wait for a moment till child is ready, so update screen now */ /* we might wait for a moment till child is ready, so update screen now */
main_window_update(); main_window_update();
@ -679,8 +695,8 @@ sync_pipe_start(capture_options *capture_opts) {
the child process wants to tell us something. */ the child process wants to tell us something. */
/* we have a running capture, now wait for the real capture filename */ /* we have a running capture, now wait for the real capture filename */
pipe_input_set_handler(sync_pipe_read_fd, (gpointer) capture_opts, pipe_input_set_handler(sync_pipe_read_fd, (gpointer) cap_session,
&capture_opts->fork_child, sync_pipe_input_cb); &cap_session->fork_child, sync_pipe_input_cb);
return TRUE; return TRUE;
} }
@ -1612,7 +1628,7 @@ pipe_read_block(int pipe_fd, char *indicator, int len, char *msg,
static gboolean static gboolean
sync_pipe_input_cb(gint source, gpointer user_data) sync_pipe_input_cb(gint source, gpointer user_data)
{ {
capture_options *capture_opts = (capture_options *)user_data; capture_session *cap_session = (capture_session *)user_data;
int ret; int ret;
char buffer[SP_MAX_MSG_LEN+1]; char buffer[SP_MAX_MSG_LEN+1];
ssize_t nread; ssize_t nread;
@ -1639,7 +1655,7 @@ sync_pipe_input_cb(gint source, gpointer user_data)
If we got an EOF, nread is 0 and primary_msg isn't set. This If we got an EOF, nread is 0 and primary_msg isn't set. This
is an indication that the capture is finished. */ is an indication that the capture is finished. */
ret = sync_pipe_wait_for_child(capture_opts->fork_child, &wait_msg); ret = sync_pipe_wait_for_child(cap_session->fork_child, &wait_msg);
if(nread == 0) { if(nread == 0) {
/* We got an EOF from the sync pipe. That means that the capture /* We got an EOF from the sync pipe. That means that the capture
child exited, and not in the middle of a message; we treat child exited, and not in the middle of a message; we treat
@ -1660,13 +1676,13 @@ sync_pipe_input_cb(gint source, gpointer user_data)
} }
/* No more child process. */ /* No more child process. */
capture_opts->fork_child = -1; cap_session->fork_child = -1;
capture_opts->fork_child_status = ret; cap_session->fork_child_status = ret;
#ifdef _WIN32 #ifdef _WIN32
ws_close(capture_opts->signal_pipe_write_fd); ws_close(capture_opts->signal_pipe_write_fd);
#endif #endif
capture_input_closed(capture_opts, primary_msg); capture_input_closed(cap_session, primary_msg);
g_free(primary_msg); g_free(primary_msg);
return FALSE; return FALSE;
} }
@ -1674,7 +1690,7 @@ sync_pipe_input_cb(gint source, gpointer user_data)
/* we got a valid message block from the child, process it */ /* we got a valid message block from the child, process it */
switch(indicator) { switch(indicator) {
case SP_FILE: case SP_FILE:
if(!capture_input_new_file(capture_opts, buffer)) { if(!capture_input_new_file(cap_session, buffer)) {
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_input_cb: file failed, closing capture"); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_input_cb: file failed, closing capture");
/* We weren't able to open the new capture file; user has been /* We weren't able to open the new capture file; user has been
@ -1694,15 +1710,15 @@ sync_pipe_input_cb(gint source, gpointer user_data)
This can also happen if the user specified "-", meaning This can also happen if the user specified "-", meaning
"standard output", as the capture file. */ "standard output", as the capture file. */
sync_pipe_stop(capture_opts); sync_pipe_stop(cap_session);
capture_input_closed(capture_opts, NULL); capture_input_closed(cap_session, NULL);
return FALSE; return FALSE;
} }
break; break;
case SP_PACKET_COUNT: case SP_PACKET_COUNT:
npackets = atoi(buffer); npackets = atoi(buffer);
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_input_cb: new packets %u", npackets); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_input_cb: new packets %u", npackets);
capture_input_new_packets(capture_opts, npackets); capture_input_new_packets(cap_session, npackets);
break; break;
case SP_ERROR_MSG: case SP_ERROR_MSG:
/* convert primary message */ /* convert primary message */
@ -1712,7 +1728,7 @@ sync_pipe_input_cb(gint source, gpointer user_data)
pipe_convert_header((guchar*)primary_msg + primary_len, 4, &indicator, &secondary_len); pipe_convert_header((guchar*)primary_msg + primary_len, 4, &indicator, &secondary_len);
secondary_msg = primary_msg + primary_len + 4; secondary_msg = primary_msg + primary_len + 4;
/* message output */ /* message output */
capture_input_error_message(capture_opts, primary_msg, secondary_msg); capture_input_error_message(cap_session, primary_msg, secondary_msg);
/* the capture child will close the sync_pipe, nothing to do for now */ /* the capture child will close the sync_pipe, nothing to do for now */
/* (an error message doesn't mean we have to stop capturing) */ /* (an error message doesn't mean we have to stop capturing) */
break; break;
@ -1723,12 +1739,12 @@ sync_pipe_input_cb(gint source, gpointer user_data)
ch = strtok(buffer, ":"); ch = strtok(buffer, ":");
indx = (int)strtol(ch, NULL, 10); indx = (int)strtol(ch, NULL, 10);
ch = strtok(NULL, ":"); ch = strtok(NULL, ":");
capture_input_cfilter_error_message(capture_opts, indx, ch); capture_input_cfilter_error_message(cap_session, indx, ch);
/* the capture child will close the sync_pipe, nothing to do for now */ /* the capture child will close the sync_pipe, nothing to do for now */
break; break;
} }
case SP_DROPS: case SP_DROPS:
capture_input_drops(capture_opts, (guint32)strtoul(buffer, NULL, 10)); capture_input_drops(cap_session, (guint32)strtoul(buffer, NULL, 10));
break; break;
default: default:
g_assert_not_reached(); g_assert_not_reached();
@ -1923,21 +1939,20 @@ sync_pipe_signame(int sig)
#ifdef _WIN32 #ifdef _WIN32
/* tell the child through the signal pipe that we want to quit the capture */ /* tell the child through the signal pipe that we want to quit the capture */
static void static void
signal_pipe_capquit_to_child(capture_options *capture_opts) signal_pipe_capquit_to_child(capture_session *cap_session)
{ {
const char quit_msg[] = "QUIT"; const char quit_msg[] = "QUIT";
int ret; int ret;
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "signal_pipe_capquit_to_child"); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "signal_pipe_capquit_to_child");
/* it doesn't matter *what* we send here, the first byte will stop the capture */ /* it doesn't matter *what* we send here, the first byte will stop the capture */
/* simply sending a "QUIT" string */ /* simply sending a "QUIT" string */
/*pipe_write_block(capture_opts->signal_pipe_write_fd, SP_QUIT, quit_msg);*/ /*pipe_write_block(cap_session->signal_pipe_write_fd, SP_QUIT, quit_msg);*/
ret = write(capture_opts->signal_pipe_write_fd, quit_msg, sizeof quit_msg); ret = write(cap_session->signal_pipe_write_fd, quit_msg, sizeof quit_msg);
if(ret == -1) { if(ret == -1) {
g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_WARNING, g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_WARNING,
"signal_pipe_capquit_to_child: %d header: error %s", capture_opts->signal_pipe_write_fd, g_strerror(errno)); "signal_pipe_capquit_to_child: %d header: error %s", cap_session->signal_pipe_write_fd, g_strerror(errno));
} }
} }
#endif #endif
@ -1945,7 +1960,7 @@ signal_pipe_capquit_to_child(capture_options *capture_opts)
/* user wants to stop the capture run */ /* user wants to stop the capture run */
void void
sync_pipe_stop(capture_options *capture_opts) sync_pipe_stop(capture_session *cap_session)
{ {
#ifdef _WIN32 #ifdef _WIN32
int count; int count;
@ -1953,10 +1968,10 @@ sync_pipe_stop(capture_options *capture_opts)
gboolean terminate = TRUE; gboolean terminate = TRUE;
#endif #endif
if (capture_opts->fork_child != -1) { if (cap_session->fork_child != -1) {
#ifndef _WIN32 #ifndef _WIN32
/* send the SIGINT signal to close the capture child gracefully. */ /* send the SIGINT signal to close the capture child gracefully. */
int sts = kill(capture_opts->fork_child, SIGINT); int sts = kill(cap_session->fork_child, SIGINT);
if (sts != 0) { if (sts != 0) {
g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_WARNING, g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_WARNING,
"Sending SIGINT to child failed: %s\n", g_strerror(errno)); "Sending SIGINT to child failed: %s\n", g_strerror(errno));
@ -1967,11 +1982,11 @@ sync_pipe_stop(capture_options *capture_opts)
/* First, use the special signal pipe to try to close the capture child /* First, use the special signal pipe to try to close the capture child
* gracefully. * gracefully.
*/ */
signal_pipe_capquit_to_child(capture_opts); signal_pipe_capquit_to_child(cap_session);
/* Next, wait for the process to exit on its own */ /* Next, wait for the process to exit on its own */
for (count = 0; count < STOP_SLEEP_TIME / STOP_CHECK_TIME; count++) { for (count = 0; count < STOP_SLEEP_TIME / STOP_CHECK_TIME; count++) {
if (GetExitCodeProcess((HANDLE) capture_opts->fork_child, &childstatus) && if (GetExitCodeProcess((HANDLE) cap_session->fork_child, &childstatus) &&
childstatus != STILL_ACTIVE) { childstatus != STILL_ACTIVE) {
terminate = FALSE; terminate = FALSE;
break; break;
@ -1983,7 +1998,7 @@ sync_pipe_stop(capture_options *capture_opts)
if (terminate) { if (terminate) {
g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_WARNING, g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_WARNING,
"sync_pipe_stop: forcing child to exit"); "sync_pipe_stop: forcing child to exit");
sync_pipe_kill(capture_opts->fork_child); sync_pipe_kill(cap_session->fork_child);
} }
#endif #endif
} }

6
capture_sync.h
View File

@ -34,7 +34,6 @@
#ifndef __CAPTURE_SYNC_H__ #ifndef __CAPTURE_SYNC_H__
#define __CAPTURE_SYNC_H__ #define __CAPTURE_SYNC_H__
/** /**
* Start a new capture session. * Start a new capture session.
* Create a capture child which is doing the real capture work. * Create a capture child which is doing the real capture work.
@ -44,14 +43,15 @@
* Most of the parameters are passed through the global capture_opts. * Most of the parameters are passed through the global capture_opts.
* *
* @param capture_opts the options * @param capture_opts the options
* @param cap_session a handle for the capture session
* @return TRUE if a capture could be started, FALSE if not * @return TRUE if a capture could be started, FALSE if not
*/ */
extern gboolean extern gboolean
sync_pipe_start(capture_options *capture_opts); sync_pipe_start(capture_options *capture_opts, capture_session *cap_session);
/** User wants to stop capturing, gracefully close the capture child */ /** User wants to stop capturing, gracefully close the capture child */
extern void extern void
sync_pipe_stop(capture_options *capture_opts); sync_pipe_stop(capture_session *cap_session);
/** User wants to stop the program, just kill the child as soon as possible */ /** User wants to stop the program, just kill the child as soon as possible */
extern void extern void

3
dumpcap.c
View File

@ -110,6 +110,7 @@
#include "sync_pipe.h" #include "sync_pipe.h"
#include "capture_opts.h" #include "capture_opts.h"
#include "capture_session.h"
#include "capture_ifinfo.h" #include "capture_ifinfo.h"
#include "capture_sync.h" #include "capture_sync.h"
@ -4451,7 +4452,7 @@ main(int argc, char *argv[])
/* Set the initial values in the capture options. This might be overwritten /* Set the initial values in the capture options. This might be overwritten
by the command line parameters. */ by the command line parameters. */
capture_opts_init(&global_capture_opts, NULL); capture_opts_init(&global_capture_opts);
/* We always save to a file - if no file was specified, we save to a /* We always save to a file - if no file was specified, we save to a
temporary file. */ temporary file. */

42
tshark.c
View File

@ -89,6 +89,7 @@
#include "capture-wpcap.h" #include "capture-wpcap.h"
#include <wsutil/unicode-utils.h> #include <wsutil/unicode-utils.h>
#endif /* _WIN32 */ #endif /* _WIN32 */
#include "capture_session.h"
#include "capture_sync.h" #include "capture_sync.h"
#endif /* HAVE_LIBPCAP */ #endif /* HAVE_LIBPCAP */
#include "log.h" #include "log.h"
@ -146,6 +147,7 @@ static const char *separator = "";
static gboolean print_packet_counts = TRUE; static gboolean print_packet_counts = TRUE;
static capture_options global_capture_opts; static capture_options global_capture_opts;
static capture_session global_capture_session;
#ifdef SIGINFO #ifdef SIGINFO
static gboolean infodelay; /* if TRUE, don't print capture info in SIGINFO handler */ static gboolean infodelay; /* if TRUE, don't print capture info in SIGINFO handler */
@ -1056,7 +1058,8 @@ main(int argc, char *argv[])
initialize_funnel_ops(); initialize_funnel_ops();
#ifdef HAVE_LIBPCAP #ifdef HAVE_LIBPCAP
capture_opts_init(&global_capture_opts, &cfile); capture_opts_init(&global_capture_opts);
capture_session_init(&global_capture_session, (void *)&cfile);
#endif #endif
timestamp_set_type(TS_RELATIVE); timestamp_set_type(TS_RELATIVE);
@ -2005,7 +2008,7 @@ main(int argc, char *argv[])
* Instead, pass on the exit status from the capture child. * Instead, pass on the exit status from the capture child.
*/ */
capture(); capture();
exit_status = global_capture_opts.fork_child_status; exit_status = global_capture_session.fork_child_status;
if (print_packet_info) { if (print_packet_info) {
if (!write_finale()) { if (!write_finale()) {
@ -2232,7 +2235,7 @@ capture(void)
#endif /* SIGINFO */ #endif /* SIGINFO */
#endif /* _WIN32 */ #endif /* _WIN32 */
global_capture_opts.state = CAPTURE_PREPARING; global_capture_session.state = CAPTURE_PREPARING;
/* Let the user know which interfaces were chosen. */ /* Let the user know which interfaces were chosen. */
for (i = 0; i < global_capture_opts.ifaces->len; i++) { for (i = 0; i < global_capture_opts.ifaces->len; i++) {
@ -2271,7 +2274,7 @@ capture(void)
fflush(stderr); fflush(stderr);
g_string_free(str, TRUE); g_string_free(str, TRUE);
ret = sync_pipe_start(&global_capture_opts); ret = sync_pipe_start(&global_capture_opts, &global_capture_session);
if (!ret) if (!ret)
return FALSE; return FALSE;
@ -2390,27 +2393,28 @@ capture_input_cfilter_error_message(capture_options *capture_opts, guint i, char
/* capture child tells us we have a new (or the first) capture file */ /* capture child tells us we have a new (or the first) capture file */
gboolean gboolean
capture_input_new_file(capture_options *capture_opts, gchar *new_file) capture_input_new_file(capture_session *cap_session, gchar *new_file)
{ {
capture_options *capture_opts = cap_session->capture_opts;
gboolean is_tempfile; gboolean is_tempfile;
int err; int err;
if (capture_opts->state == CAPTURE_PREPARING) { if (cap_session->state == CAPTURE_PREPARING) {
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started!"); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started!");
} }
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file); g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
g_assert(capture_opts->state == CAPTURE_PREPARING || capture_opts->state == CAPTURE_RUNNING); g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
/* free the old filename */ /* free the old filename */
if (capture_opts->save_file != NULL) { if (capture_opts->save_file != NULL) {
/* we start a new capture file, close the old one (if we had one before) */ /* we start a new capture file, close the old one (if we had one before) */
if ( ((capture_file *) capture_opts->cf)->state != FILE_CLOSED) { if ( ((capture_file *) cap_session->cf)->state != FILE_CLOSED) {
if ( ((capture_file *) capture_opts->cf)->wth != NULL) { if ( ((capture_file *) cap_session->cf)->wth != NULL) {
wtap_close(((capture_file *) capture_opts->cf)->wth); wtap_close(((capture_file *) cap_session->cf)->wth);
} }
((capture_file *) capture_opts->cf)->state = FILE_CLOSED; ((capture_file *) cap_session->cf)->state = FILE_CLOSED;
} }
g_free(capture_opts->save_file); g_free(capture_opts->save_file);
@ -2426,7 +2430,7 @@ capture_input_new_file(capture_options *capture_opts, gchar *new_file)
/* if we are in real-time mode, open the new file now */ /* if we are in real-time mode, open the new file now */
if (do_dissection) { if (do_dissection) {
/* Attempt to open the capture file and set up to read from it. */ /* Attempt to open the capture file and set up to read from it. */
switch(cf_open((capture_file *)capture_opts->cf, capture_opts->save_file, is_tempfile, &err)) { switch(cf_open((capture_file *)cap_session->cf, capture_opts->save_file, is_tempfile, &err)) {
case CF_OK: case CF_OK:
break; break;
case CF_ERROR: case CF_ERROR:
@ -2438,7 +2442,7 @@ capture_input_new_file(capture_options *capture_opts, gchar *new_file)
} }
} }
capture_opts->state = CAPTURE_RUNNING; cap_session->state = CAPTURE_RUNNING;
return TRUE; return TRUE;
} }
@ -2446,13 +2450,13 @@ capture_input_new_file(capture_options *capture_opts, gchar *new_file)
/* capture child tells us we have new packets to read */ /* capture child tells us we have new packets to read */
void void
capture_input_new_packets(capture_options *capture_opts, int to_read) capture_input_new_packets(capture_session *cap_session, int to_read)
{ {
gboolean ret; gboolean ret;
int err; int err;
gchar *err_info; gchar *err_info;
gint64 data_offset; gint64 data_offset;
capture_file *cf = (capture_file *)capture_opts->cf; capture_file *cf = (capture_file *)cap_session->cf;
gboolean filtering_tap_listeners; gboolean filtering_tap_listeners;
guint tap_flags; guint tap_flags;
@ -2477,7 +2481,7 @@ capture_input_new_packets(capture_options *capture_opts, int to_read)
ret = wtap_read(cf->wth, &err, &err_info, &data_offset); ret = wtap_read(cf->wth, &err, &err_info, &data_offset);
if (ret == FALSE) { if (ret == FALSE) {
/* read from file failed, tell the capture child to stop */ /* read from file failed, tell the capture child to stop */
sync_pipe_stop(capture_opts); sync_pipe_stop(cap_session);
wtap_close(cf->wth); wtap_close(cf->wth);
cf->wth = NULL; cf->wth = NULL;
} else { } else {
@ -2575,9 +2579,9 @@ capture_input_drops(capture_options *capture_opts _U_, guint32 dropped)
* do the required cleanup. * do the required cleanup.
*/ */
void void
capture_input_closed(capture_options *capture_opts, gchar *msg) capture_input_closed(capture_session *cap_session, gchar *msg)
{ {
capture_file *cf = (capture_file *) capture_opts->cf; capture_file *cf = (capture_file *) cap_session->cf;
if (msg != NULL) if (msg != NULL)
fprintf(stderr, "tshark: %s\n", msg); fprintf(stderr, "tshark: %s\n", msg);
@ -2640,7 +2644,7 @@ static void
capture_cleanup(int signum _U_) capture_cleanup(int signum _U_)
{ {
/* tell the capture child to stop */ /* tell the capture child to stop */
sync_pipe_stop(&global_capture_opts); sync_pipe_stop(&global_capture_session);
/* don't stop our own loop already here, otherwise status messages and /* don't stop our own loop already here, otherwise status messages and
* cleanup wouldn't be done properly. The child will indicate the stop of * cleanup wouldn't be done properly. The child will indicate the stop of

4
ui/capture_globals.h
View File

@ -25,12 +25,16 @@
#ifndef __CAPTURE_GLOBALS_H__ #ifndef __CAPTURE_GLOBALS_H__
#define __CAPTURE_GLOBALS_H__ #define __CAPTURE_GLOBALS_H__
#include "../capture_session.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif /* __cplusplus */ #endif /* __cplusplus */
extern capture_options global_capture_opts; extern capture_options global_capture_opts;
extern capture_session global_capture_session;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* __cplusplus */ #endif /* __cplusplus */

24
ui/gtk/capture_dlg.c
View File

@ -555,7 +555,7 @@ capture_stop_cb(GtkWidget *w _U_, gpointer d _U_)
airpcap_set_toolbar_stop_capture(airpcap_if_active); airpcap_set_toolbar_stop_capture(airpcap_if_active);
#endif #endif
capture_stop(&global_capture_opts); capture_stop(&global_capture_session);
} }
/* restart (stop - delete old file - start) running capture */ /* restart (stop - delete old file - start) running capture */
@ -567,7 +567,7 @@ capture_restart_cb(GtkWidget *w _U_, gpointer d _U_)
airpcap_set_toolbar_start_capture(airpcap_if_active); airpcap_set_toolbar_start_capture(airpcap_if_active);
#endif #endif
capture_restart(&global_capture_opts); capture_restart(&global_capture_session);
} }
enum cfc_state_t { enum cfc_state_t {
@ -4715,7 +4715,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
gtk_widget_set_sensitive(GTK_WIDGET(all_cb), if_present); gtk_widget_set_sensitive(GTK_WIDGET(all_cb), if_present);
/* Promiscuous mode row */ /* Promiscuous mode row */
promisc_cb = gtk_check_button_new_with_mnemonic("Use _promiscuous mode on all interfaces"); promisc_cb = gtk_check_button_new_with_mnemonic("Use _promiscuous mode on all interfaces");
if (!global_capture_opts.session_started) { if (!global_capture_session.session_started) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(promisc_cb), prefs.capture_prom_mode); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(promisc_cb), prefs.capture_prom_mode);
} else { } else {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(promisc_cb), get_all_prom_mode()); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(promisc_cb), get_all_prom_mode());
@ -5233,7 +5233,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
window_present(cap_open_w); window_present(cap_open_w);
cap_open_complete = TRUE; /* "Capture:Start" is now OK */ cap_open_complete = TRUE; /* "Capture:Start" is now OK */
global_capture_opts.session_started = TRUE; global_capture_session.session_started = TRUE;
} }
/* user pressed the "Start" button (in dialog or toolbar) */ /* user pressed the "Start" button (in dialog or toolbar) */
@ -5283,17 +5283,17 @@ capture_start_cb(GtkWidget *w _U_, gpointer d _U_)
main_auto_scroll_live_changed(auto_scroll_live); main_auto_scroll_live_changed(auto_scroll_live);
/* XXX - can this ever happen? */ /* XXX - can this ever happen? */
if (global_capture_opts.state != CAPTURE_STOPPED) if (global_capture_session.state != CAPTURE_STOPPED)
return; return;
/* close the currently loaded capture file */ /* close the currently loaded capture file */
cf_close((capture_file *)global_capture_opts.cf); cf_close((capture_file *)global_capture_session.cf);
/* Copy the selected interfaces to the set of interfaces to use for /* Copy the selected interfaces to the set of interfaces to use for
this capture. */ this capture. */
collect_ifaces(&global_capture_opts); collect_ifaces(&global_capture_opts);
if (capture_start(&global_capture_opts)) { if (capture_start(&global_capture_opts, &global_capture_session)) {
/* The capture succeeded, which means the capture filter syntax is /* The capture succeeded, which means the capture filter syntax is
valid; add this capture filter to the recent capture filter list. */ valid; add this capture filter to the recent capture filter list. */
for (i = 0; i < global_capture_opts.ifaces->len; i++) { for (i = 0; i < global_capture_opts.ifaces->len; i++) {
@ -5570,7 +5570,7 @@ create_and_fill_model(GtkTreeView *view)
temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", device.display_name, device.addresses); temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", device.display_name, device.addresses);
} }
linkname = NULL; linkname = NULL;
if(global_capture_opts.session_started == FALSE && capture_dev_user_linktype_find(device.name) != -1) { if(global_capture_session.session_started == FALSE && capture_dev_user_linktype_find(device.name) != -1) {
device.active_dlt = capture_dev_user_linktype_find(device.name); device.active_dlt = capture_dev_user_linktype_find(device.name);
} }
for (list = device.links; list != NULL; list = g_list_next(list)) { for (list = device.links; list != NULL; list = g_list_next(list)) {
@ -5583,10 +5583,10 @@ create_and_fill_model(GtkTreeView *view)
if (!linkname) if (!linkname)
linkname = g_strdup("unknown"); linkname = g_strdup("unknown");
pmode = capture_dev_user_pmode_find(device.name); pmode = capture_dev_user_pmode_find(device.name);
if (global_capture_opts.session_started == FALSE && pmode != -1) { if (global_capture_session.session_started == FALSE && pmode != -1) {
device.pmode = pmode; device.pmode = pmode;
} }
if(global_capture_opts.session_started == FALSE) { if(global_capture_session.session_started == FALSE) {
hassnap = capture_dev_user_hassnap_find(device.name); hassnap = capture_dev_user_hassnap_find(device.name);
snaplen = capture_dev_user_snaplen_find(device.name); snaplen = capture_dev_user_snaplen_find(device.name);
if(snaplen != -1 && hassnap != -1) { if(snaplen != -1 && hassnap != -1) {
@ -5606,10 +5606,10 @@ create_and_fill_model(GtkTreeView *view)
} }
#if defined(_WIN32) || defined(HAVE_PCAP_CREATE) #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
if (global_capture_opts.session_started == FALSE && capture_dev_user_buffersize_find(device.name) != -1) { if (global_capture_session.session_started == FALSE && capture_dev_user_buffersize_find(device.name) != -1) {
buffer = capture_dev_user_buffersize_find(device.name); buffer = capture_dev_user_buffersize_find(device.name);
device.buffer = buffer; device.buffer = buffer;
} else if (global_capture_opts.session_started == FALSE) { } else if (global_capture_session.session_started == FALSE) {
device.buffer = DEFAULT_CAPTURE_BUFFER_SIZE; device.buffer = DEFAULT_CAPTURE_BUFFER_SIZE;
} }
#endif #endif

2
ui/gtk/capture_if_dlg.c
View File

@ -32,6 +32,8 @@
#include <epan/prefs.h> #include <epan/prefs.h>
#include "../capture_opts.h"
#include "../capture_session.h"
#include "../capture_ifinfo.h" #include "../capture_ifinfo.h"
#include "../capture.h" #include "../capture.h"
#include "../capture-pcap-util.h" #include "../capture-pcap-util.h"

18
ui/gtk/capture_info_dlg.c
View File

@ -72,25 +72,25 @@ typedef struct {
/* Workhorse for stopping capture */ /* Workhorse for stopping capture */
static void static void
capture_info_stop(capture_options *capture_opts) capture_info_stop(capture_session *cap_session)
{ {
#ifdef HAVE_AIRPCAP #ifdef HAVE_AIRPCAP
airpcap_set_toolbar_stop_capture(airpcap_if_active); airpcap_set_toolbar_stop_capture(airpcap_if_active);
#endif #endif
capture_stop(capture_opts); capture_stop(cap_session);
} }
/* "delete-event" signal callback. Note different signature than "clicked" signal callback */ /* "delete-event" signal callback. Note different signature than "clicked" signal callback */
static gboolean static gboolean
capture_info_delete_cb(GtkWidget *w _U_, GdkEvent *event _U_, gpointer data) { capture_info_delete_cb(GtkWidget *w _U_, GdkEvent *event _U_, gpointer data) {
capture_info_stop((capture_options *)data); capture_info_stop((capture_session *)data);
return TRUE; return TRUE;
} }
/* "clicked" signal callback */ /* "clicked" signal callback */
static void static void
capture_info_stop_clicked_cb(GtkButton *w _U_, gpointer data) { capture_info_stop_clicked_cb(GtkButton *w _U_, gpointer data) {
capture_info_stop((capture_options *)data); capture_info_stop((capture_session *)data);
} }
static gboolean static gboolean
@ -110,10 +110,10 @@ capture_info_ui_update_cb(gpointer data)
/* create the capture info dialog */ /* create the capture info dialog */
/* will keep pointers to the fields in the counts parameter */ /* will keep pointers to the fields in the counts parameter */
void capture_info_ui_create( void
capture_info *cinfo, capture_info_ui_create(capture_info *cinfo, capture_session *cap_session)
capture_options *capture_opts)
{ {
capture_options *capture_opts = cap_session->capture_opts;
unsigned int i; unsigned int i;
GtkWidget *main_vb, *stop_bt, *counts_grid; GtkWidget *main_vb, *stop_bt, *counts_grid;
GtkWidget *counts_fr, *running_grid, *running_label, *lb, *bbox, *ci_help; GtkWidget *counts_fr, *running_grid, *running_label, *lb, *bbox, *ci_help;
@ -297,8 +297,8 @@ capture_options *capture_opts)
stop_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_CAPTURE_STOP); stop_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_CAPTURE_STOP);
window_set_cancel_button(info->cap_w, stop_bt, NULL); window_set_cancel_button(info->cap_w, stop_bt, NULL);
g_signal_connect(stop_bt, "clicked", G_CALLBACK(capture_info_stop_clicked_cb), capture_opts); g_signal_connect(stop_bt, "clicked", G_CALLBACK(capture_info_stop_clicked_cb), cap_session);
g_signal_connect(info->cap_w, "delete_event", G_CALLBACK(capture_info_delete_cb), capture_opts); g_signal_connect(info->cap_w, "delete_event", G_CALLBACK(capture_info_delete_cb), cap_session);
ci_help = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP); ci_help = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);
gtk_widget_set_tooltip_text(ci_help, "Get help about this dialog"); gtk_widget_set_tooltip_text(ci_help, "Get help about this dialog");

2
ui/gtk/drag_and_drop.c
View File

@ -254,7 +254,7 @@ dnd_data_received(GtkWidget *widget _U_, GdkDragContext *dc _U_, gint x _U_, gin
#ifdef HAVE_LIBPCAP #ifdef HAVE_LIBPCAP
/* if a capture is running, do nothing but warn the user */ /* if a capture is running, do nothing but warn the user */
if((global_capture_opts.state != CAPTURE_STOPPED)) { if((global_capture_session.state != CAPTURE_STOPPED)) {
simple_dialog(ESD_TYPE_CONFIRMATION, simple_dialog(ESD_TYPE_CONFIRMATION,
ESD_BTN_OK, ESD_BTN_OK,
"%sDrag and Drop currently not possible!%s\n\n" "%sDrag and Drop currently not possible!%s\n\n"

49
ui/gtk/main.c
View File

@ -209,6 +209,9 @@
*/ */
#define RC_FILE "gtkrc" #define RC_FILE "gtkrc"
capture_options global_capture_opts;
capture_session global_capture_session;
capture_file cfile; capture_file cfile;
static gboolean capture_stopping; static gboolean capture_stopping;
@ -980,7 +983,7 @@ main_do_quit(void)
#ifdef HAVE_LIBPCAP #ifdef HAVE_LIBPCAP
/* Nuke any child capture in progress. */ /* Nuke any child capture in progress. */
capture_kill_child(&global_capture_opts); capture_kill_child(&global_capture_session);
#endif #endif
/* Are we in the middle of reading a capture? */ /* Are we in the middle of reading a capture? */
@ -1514,11 +1517,11 @@ static GList *icon_list_create(
} }
static void static void
main_capture_cb_capture_prepared(capture_options *capture_opts) main_capture_cb_capture_prepared(capture_session *cap_session)
{ {
static GList *icon_list = NULL; static GList *icon_list = NULL;
set_titlebar_for_capture_in_progress((capture_file *)capture_opts->cf); set_titlebar_for_capture_in_progress((capture_file *)cap_session->cf);
if(icon_list == NULL) { if(icon_list == NULL) {
icon_list = icon_list_create(wsiconcap_16_pb_data, wsiconcap_32_pb_data, wsiconcap_48_pb_data, wsiconcap_64_pb_data); icon_list = icon_list_create(wsiconcap_16_pb_data, wsiconcap_32_pb_data, wsiconcap_48_pb_data, wsiconcap_64_pb_data);
@ -1535,11 +1538,11 @@ main_capture_cb_capture_prepared(capture_options *capture_opts)
} }
static void static void
main_capture_cb_capture_update_started(capture_options *capture_opts) main_capture_cb_capture_update_started(capture_session *cap_session)
{ {
/* We've done this in "prepared" above, but it will be cleared while /* We've done this in "prepared" above, but it will be cleared while
switching to the next multiple file. */ switching to the next multiple file. */
set_titlebar_for_capture_in_progress((capture_file *)capture_opts->cf); set_titlebar_for_capture_in_progress((capture_file *)cap_session->cf);
main_set_for_capture_in_progress(TRUE); main_set_for_capture_in_progress(TRUE);
set_capture_if_dialog_for_capture_in_progress(TRUE); set_capture_if_dialog_for_capture_in_progress(TRUE);
@ -1553,9 +1556,9 @@ main_capture_cb_capture_update_started(capture_options *capture_opts)
} }
static void static void
main_capture_cb_capture_update_finished(capture_options *capture_opts) main_capture_cb_capture_update_finished(capture_session *cap_session)
{ {
capture_file *cf = (capture_file *)capture_opts->cf; capture_file *cf = (capture_file *)cap_session->cf;
static GList *icon_list = NULL; static GList *icon_list = NULL;
/* The capture isn't stopping any more - it's stopped. */ /* The capture isn't stopping any more - it's stopped. */
@ -1593,17 +1596,17 @@ main_capture_cb_capture_update_finished(capture_options *capture_opts)
} }
static void static void
main_capture_cb_capture_fixed_started(capture_options *capture_opts _U_) main_capture_cb_capture_fixed_started(capture_session *cap_session _U_)
{ {
/* Don't set up main window for a capture file. */ /* Don't set up main window for a capture file. */
main_set_for_capture_file(FALSE); main_set_for_capture_file(FALSE);
} }
static void static void
main_capture_cb_capture_fixed_finished(capture_options *capture_opts _U_) main_capture_cb_capture_fixed_finished(capture_session *cap_session _U_)
{ {
#if 0 #if 0
capture_file *cf = capture_opts->cf; capture_file *cf = (capture_file *)cap_session->cf;
#endif #endif
static GList *icon_list = NULL; static GList *icon_list = NULL;
@ -1637,7 +1640,7 @@ main_capture_cb_capture_fixed_finished(capture_options *capture_opts _U_)
} }
static void static void
main_capture_cb_capture_stopping(capture_options *capture_opts _U_) main_capture_cb_capture_stopping(capture_session *cap_session _U_)
{ {
capture_stopping = TRUE; capture_stopping = TRUE;
set_menus_for_capture_stopping(); set_menus_for_capture_stopping();
@ -1649,7 +1652,7 @@ main_capture_cb_capture_stopping(capture_options *capture_opts _U_)
} }
static void static void
main_capture_cb_capture_failed(capture_options *capture_opts _U_) main_capture_cb_capture_failed(capture_session *cap_session _U_)
{ {
static GList *icon_list = NULL; static GList *icon_list = NULL;
@ -1813,7 +1816,7 @@ main_cf_callback(gint event, gpointer data, gpointer user_data _U_)
#ifdef HAVE_LIBPCAP #ifdef HAVE_LIBPCAP
static void static void
main_capture_callback(gint event, capture_options *capture_opts, gpointer user_data _U_) main_capture_callback(gint event, capture_session *cap_session, gpointer user_data _U_)
{ {
#ifdef HAVE_GTKOSXAPPLICATION #ifdef HAVE_GTKOSXAPPLICATION
GtkosxApplication *theApp; GtkosxApplication *theApp;
@ -1821,11 +1824,11 @@ main_capture_callback(gint event, capture_options *capture_opts, gpointer user_d
switch(event) { switch(event) {
case(capture_cb_capture_prepared): case(capture_cb_capture_prepared):
g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture prepared"); g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture prepared");
main_capture_cb_capture_prepared(capture_opts); main_capture_cb_capture_prepared(cap_session);
break; break;
case(capture_cb_capture_update_started): case(capture_cb_capture_update_started):
g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture update started"); g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture update started");
main_capture_cb_capture_update_started(capture_opts); main_capture_cb_capture_update_started(cap_session);
#ifdef HAVE_GTKOSXAPPLICATION #ifdef HAVE_GTKOSXAPPLICATION
theApp = (GtkosxApplication *)g_object_new(GTKOSX_TYPE_APPLICATION, NULL); theApp = (GtkosxApplication *)g_object_new(GTKOSX_TYPE_APPLICATION, NULL);
gtkosx_application_set_dock_icon_pixbuf(theApp, gdk_pixbuf_new_from_inline(-1, wsiconcap_48_pb_data, FALSE, NULL)); gtkosx_application_set_dock_icon_pixbuf(theApp, gdk_pixbuf_new_from_inline(-1, wsiconcap_48_pb_data, FALSE, NULL));
@ -1836,18 +1839,18 @@ main_capture_callback(gint event, capture_options *capture_opts, gpointer user_d
break; break;
case(capture_cb_capture_update_finished): case(capture_cb_capture_update_finished):
g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture update finished"); g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture update finished");
main_capture_cb_capture_update_finished(capture_opts); main_capture_cb_capture_update_finished(cap_session);
break; break;
case(capture_cb_capture_fixed_started): case(capture_cb_capture_fixed_started):
g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture fixed started"); g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture fixed started");
main_capture_cb_capture_fixed_started(capture_opts); main_capture_cb_capture_fixed_started(cap_session);
break; break;
case(capture_cb_capture_fixed_continue): case(capture_cb_capture_fixed_continue):
g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture fixed continue"); g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture fixed continue");
break; break;
case(capture_cb_capture_fixed_finished): case(capture_cb_capture_fixed_finished):
g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture fixed finished"); g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture fixed finished");
main_capture_cb_capture_fixed_finished(capture_opts); main_capture_cb_capture_fixed_finished(cap_session);
break; break;
case(capture_cb_capture_stopping): case(capture_cb_capture_stopping):
g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture stopping"); g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture stopping");
@ -1857,11 +1860,11 @@ main_capture_callback(gint event, capture_options *capture_opts, gpointer user_d
theApp = (GtkosxApplication *)g_object_new(GTKOSX_TYPE_APPLICATION, NULL); theApp = (GtkosxApplication *)g_object_new(GTKOSX_TYPE_APPLICATION, NULL);
gtkosx_application_set_dock_icon_pixbuf(theApp, gdk_pixbuf_new_from_inline(-1, wsicon_64_pb_data, FALSE, NULL)); gtkosx_application_set_dock_icon_pixbuf(theApp, gdk_pixbuf_new_from_inline(-1, wsicon_64_pb_data, FALSE, NULL));
#endif #endif
main_capture_cb_capture_stopping(capture_opts); main_capture_cb_capture_stopping(cap_session);
break; break;
case(capture_cb_capture_failed): case(capture_cb_capture_failed):
g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture failed"); g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Callback: capture failed");
main_capture_cb_capture_failed(capture_opts); main_capture_cb_capture_failed(cap_session);
break; break;
default: default:
g_warning("main_capture_callback: event %u unknown", event); g_warning("main_capture_callback: event %u unknown", event);
@ -2476,7 +2479,9 @@ main(int argc, char *argv[])
/* Set the initial values in the capture options. This might be overwritten /* Set the initial values in the capture options. This might be overwritten
by preference settings and then again by the command line parameters. */ by preference settings and then again by the command line parameters. */
capture_opts_init(&global_capture_opts, &cfile); capture_opts_init(&global_capture_opts);
capture_session_init(&global_capture_session, (void *)&cfile);
#endif #endif
/* Initialize whatever we need to allocate colors for GTK+ */ /* Initialize whatever we need to allocate colors for GTK+ */
@ -3131,7 +3136,7 @@ main(int argc, char *argv[])
to use for this capture. */ to use for this capture. */
if (global_capture_opts.ifaces->len == 0) if (global_capture_opts.ifaces->len == 0)
collect_ifaces(&global_capture_opts); collect_ifaces(&global_capture_opts);
if (capture_start(&global_capture_opts)) { if (capture_start(&global_capture_opts, &global_capture_session)) {
/* The capture started. Open stat windows; we do so after creating /* The capture started. Open stat windows; we do so after creating
the main window, to avoid GTK warnings, and after successfully the main window, to avoid GTK warnings, and after successfully
opening the capture file, so we know we have something to compute opening the capture file, so we know we have something to compute

1
ui/gtk/main_80211_toolbar.c
View File

@ -45,6 +45,7 @@
#include "ui/gtk/old-gtk-compat.h" #include "ui/gtk/old-gtk-compat.h"
#include <ws80211_utils.h> #include <ws80211_utils.h>
#include "capture_session.h"
#include "capture_sync.h" #include "capture_sync.h"
static GtkWidget *tb80211_tb, *tb80211_iface_list_box, *tb80211_freq_list_box, *tb80211_chan_type_box, *tb80211_info_label; static GtkWidget *tb80211_tb, *tb80211_iface_list_box, *tb80211_freq_list_box, *tb80211_chan_type_box, *tb80211_info_label;

48
ui/gtk/main_statusbar.c
View File

@ -40,6 +40,7 @@
#include "../file.h" #include "../file.h"
#ifdef HAVE_LIBPCAP #ifdef HAVE_LIBPCAP
#include "../capture_opts.h" #include "../capture_opts.h"
#include "../capture_session.h"
#include "../capture_ui_utils.h" #include "../capture_ui_utils.h"
#include "../capture.h" #include "../capture.h"
#endif #endif
@ -771,7 +772,7 @@ statusbar_cf_file_read_finished_cb(capture_file *cf)
#ifdef HAVE_LIBPCAP #ifdef HAVE_LIBPCAP
static void static void
statusbar_capture_prepared_cb(capture_options *capture_opts _U_) statusbar_capture_prepared_cb(capture_session *cap_session _U_)
{ {
static const gchar msg[] = " Waiting for capture input data ..."; static const gchar msg[] = " Waiting for capture input data ...";
statusbar_push_file_msg(msg); statusbar_push_file_msg(msg);
@ -808,8 +809,9 @@ statusbar_get_interface_names(capture_options *capture_opts)
} }
static void static void
statusbar_capture_update_started_cb(capture_options *capture_opts) statusbar_capture_update_started_cb(capture_session *cap_session)
{ {
capture_options *capture_opts = cap_session->capture_opts;
GString *interface_names; GString *interface_names;
statusbar_pop_file_msg(); statusbar_pop_file_msg();
@ -825,10 +827,11 @@ statusbar_capture_update_started_cb(capture_options *capture_opts)
} }
static void static void
statusbar_capture_update_continue_cb(capture_options *capture_opts) statusbar_capture_update_continue_cb(capture_session *cap_session)
{ {
GString *interface_names; GString *interface_names;
capture_file *cf = (capture_file *)capture_opts->cf; capture_options *capture_opts = cap_session->capture_opts;
capture_file *cf = (capture_file *)cap_session->cf;
status_expert_update(); status_expert_update();
@ -855,9 +858,9 @@ statusbar_capture_update_continue_cb(capture_options *capture_opts)
} }
static void static void
statusbar_capture_update_finished_cb(capture_options *capture_opts) statusbar_capture_update_finished_cb(capture_session *cap_session)
{ {
capture_file *cf = (capture_file *)capture_opts->cf; capture_file *cf = (capture_file *)cap_session->cf;
/* Pop the "<live capture in progress>" message off the status bar. */ /* Pop the "<live capture in progress>" message off the status bar. */
statusbar_pop_file_msg(); statusbar_pop_file_msg();
@ -866,8 +869,9 @@ statusbar_capture_update_finished_cb(capture_options *capture_opts)
} }
static void static void
statusbar_capture_fixed_started_cb(capture_options *capture_opts) statusbar_capture_fixed_started_cb(capture_session *cap_session)
{ {
capture_options *capture_opts = cap_session->capture_opts;
GString *interface_names; GString *interface_names;
statusbar_pop_file_msg(); statusbar_pop_file_msg();
@ -882,9 +886,9 @@ statusbar_capture_fixed_started_cb(capture_options *capture_opts)
} }
static void static void
statusbar_capture_fixed_continue_cb(capture_options *capture_opts) statusbar_capture_fixed_continue_cb(capture_session *cap_session)
{ {
capture_file *cf = (capture_file *)capture_opts->cf; capture_file *cf = (capture_file *)cap_session->cf;
gchar *capture_msg; gchar *capture_msg;
@ -896,10 +900,10 @@ statusbar_capture_fixed_continue_cb(capture_options *capture_opts)
static void static void
statusbar_capture_fixed_finished_cb(capture_options *capture_opts _U_) statusbar_capture_fixed_finished_cb(capture_session *cap_session _U_)
{ {
#if 0 #if 0
capture_file *cf = capture_opts->cf; capture_file *cf = (capture_file *)cap_session->cf;
#endif #endif
/* Pop the "<live capture in progress>" message off the status bar. */ /* Pop the "<live capture in progress>" message off the status bar. */
@ -911,10 +915,10 @@ statusbar_capture_fixed_finished_cb(capture_options *capture_opts _U_)
} }
static void static void
statusbar_capture_failed_cb(capture_options *capture_opts _U_) statusbar_capture_failed_cb(capture_session *cap_session _U_)
{ {
#if 0 #if 0
capture_file *cf = capture_opts->cf; capture_file *cf = (capture_file *)cap_session->cf;
#endif #endif
/* Pop the "<live capture in progress>" message off the status bar. */ /* Pop the "<live capture in progress>" message off the status bar. */
@ -1062,37 +1066,37 @@ statusbar_cf_callback(gint event, gpointer data, gpointer user_data _U_)
#ifdef HAVE_LIBPCAP #ifdef HAVE_LIBPCAP
void void
statusbar_capture_callback(gint event, capture_options *capture_opts, statusbar_capture_callback(gint event, capture_session *cap_session,
gpointer user_data _U_) gpointer user_data _U_)
{ {
switch(event) { switch(event) {
case(capture_cb_capture_prepared): case(capture_cb_capture_prepared):
statusbar_capture_prepared_cb(capture_opts); statusbar_capture_prepared_cb(cap_session);
break; break;
case(capture_cb_capture_update_started): case(capture_cb_capture_update_started):
statusbar_capture_update_started_cb(capture_opts); statusbar_capture_update_started_cb(cap_session);
break; break;
case(capture_cb_capture_update_continue): case(capture_cb_capture_update_continue):
statusbar_capture_update_continue_cb(capture_opts); statusbar_capture_update_continue_cb(cap_session);
break; break;
case(capture_cb_capture_update_finished): case(capture_cb_capture_update_finished):
statusbar_capture_update_finished_cb(capture_opts); statusbar_capture_update_finished_cb(cap_session);
break; break;
case(capture_cb_capture_fixed_started): case(capture_cb_capture_fixed_started):
statusbar_capture_fixed_started_cb(capture_opts); statusbar_capture_fixed_started_cb(cap_session);
break; break;
case(capture_cb_capture_fixed_continue): case(capture_cb_capture_fixed_continue):
statusbar_capture_fixed_continue_cb(capture_opts); statusbar_capture_fixed_continue_cb(cap_session);
break; break;
case(capture_cb_capture_fixed_finished): case(capture_cb_capture_fixed_finished):
statusbar_capture_fixed_finished_cb(capture_opts); statusbar_capture_fixed_finished_cb(cap_session);
break; break;
case(capture_cb_capture_stopping): case(capture_cb_capture_stopping):
/* Beware: this state won't be called, if the capture child /* Beware: this state won't be called, if the capture child
* closes the capturing on its own! */ * closes the capturing on its own! */
break; break;
case(capture_cb_capture_failed): case(capture_cb_capture_failed):
statusbar_capture_failed_cb(capture_opts); statusbar_capture_failed_cb(cap_session);
break; break;
default: default:
g_warning("statusbar_capture_callback: event %u unknown", event); g_warning("statusbar_capture_callback: event %u unknown", event);

2
ui/gtk/main_statusbar_private.h
View File

@ -34,7 +34,7 @@ void statusbar_widgets_pack(GtkWidget *statusbar);
void statusbar_widgets_show_or_hide(GtkWidget *statusbar); void statusbar_widgets_show_or_hide(GtkWidget *statusbar);
void statusbar_cf_callback(gint event, gpointer data, gpointer user_data); void statusbar_cf_callback(gint event, gpointer data, gpointer user_data);
#ifdef HAVE_LIBPCAP #ifdef HAVE_LIBPCAP
void statusbar_capture_callback(gint event, capture_options *capture_opts, void statusbar_capture_callback(gint event, capture_session *cap_session,
gpointer user_data); gpointer user_data);
#endif #endif

2
ui/iface_lists.c
View File

@ -39,8 +39,6 @@
#include "ui/capture_globals.h" #include "ui/capture_globals.h"
#include "ui/iface_lists.h" #include "ui/iface_lists.h"
capture_options global_capture_opts;
/* /*
* Used when sorting an interface list into alphabetical order by * Used when sorting an interface list into alphabetical order by
* their friendly names. * their friendly names.

4
ui/qt/main.cpp
View File

@ -811,7 +811,9 @@ int main(int argc, char *argv[])
/* Set the initial values in the capture options. This might be overwritten /* Set the initial values in the capture options. This might be overwritten
by preference settings and then again by the command line parameters. */ by preference settings and then again by the command line parameters. */
capture_opts_init(&global_capture_opts, &cfile); capture_opts_init(&global_capture_opts);
capture_session_init(&global_capture_session, (void *)&cfile);
#endif #endif
/* Register all dissectors; we must do this before checking for the /* Register all dissectors; we must do this before checking for the