1998-09-16 02:39:15 +00:00
|
|
|
/* capture.c
|
2005-03-28 18:04:09 +00:00
|
|
|
* Routines for packet capture
|
1998-09-16 02:39:15 +00:00
|
|
|
*
|
2006-05-21 05:12:17 +00:00
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
1998-09-16 02:39:15 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2018-02-07 11:26:45 +00:00
|
|
|
* SPDX-License-Identifier: GPL-2.0-or-later
|
1998-09-16 02:39:15 +00:00
|
|
|
*/
|
|
|
|
|
2012-09-20 01:29:52 +00:00
|
|
|
#include "config.h"
|
2021-06-08 01:46:52 +00:00
|
|
|
#define WS_LOG_DOMAIN LOG_DOMAIN_CAPTURE
|
1998-09-16 02:39:15 +00:00
|
|
|
|
1999-07-09 04:18:36 +00:00
|
|
|
#ifdef HAVE_LIBPCAP
|
|
|
|
|
2009-08-26 19:27:49 +00:00
|
|
|
#include <stdio.h>
|
2013-12-03 22:16:49 +00:00
|
|
|
#include <stdlib.h>
|
1998-09-16 02:39:15 +00:00
|
|
|
#include <string.h>
|
|
|
|
|
2004-10-30 23:26:47 +00:00
|
|
|
#include <glib.h>
|
|
|
|
|
2024-01-18 09:09:46 +00:00
|
|
|
#include <ws_exit_codes.h>
|
|
|
|
|
2002-01-21 07:37:49 +00:00
|
|
|
#include <epan/packet.h>
|
2003-10-11 21:49:56 +00:00
|
|
|
#include <epan/dfilter/dfilter.h>
|
2022-08-13 03:58:50 +00:00
|
|
|
#include "extcap.h"
|
1998-09-16 02:39:15 +00:00
|
|
|
#include "file.h"
|
2014-06-30 05:38:29 +00:00
|
|
|
#include "ui/capture.h"
|
2021-03-24 22:09:19 +00:00
|
|
|
#include "capture/capture_ifinfo.h"
|
|
|
|
#include <capture/capture_sync.h>
|
2019-09-15 13:15:31 +00:00
|
|
|
#include "ui/capture_info.h"
|
2014-06-30 01:36:22 +00:00
|
|
|
#include "ui/capture_ui_utils.h"
|
2023-12-18 04:30:29 +00:00
|
|
|
#include "ui/iface_lists.h"
|
2012-02-17 12:30:27 +00:00
|
|
|
#include "ui/util.h"
|
2020-10-03 02:17:00 +00:00
|
|
|
#include "ui/urls.h"
|
2021-03-24 22:09:19 +00:00
|
|
|
#include "capture/capture-pcap-util.h"
|
1998-09-16 02:39:15 +00:00
|
|
|
|
2002-12-31 21:12:55 +00:00
|
|
|
#ifdef _WIN32
|
2021-03-24 22:09:19 +00:00
|
|
|
#include "capture/capture-wpcap.h"
|
2001-11-09 07:44:51 +00:00
|
|
|
#endif
|
2012-01-16 01:07:52 +00:00
|
|
|
|
|
|
|
#include "ui/simple_dialog.h"
|
2017-10-14 20:14:14 +00:00
|
|
|
#include "ui/ws_ui_util.h"
|
2012-01-16 01:07:52 +00:00
|
|
|
|
2008-05-22 15:46:27 +00:00
|
|
|
#include "wsutil/file_util.h"
|
2015-11-04 08:45:54 +00:00
|
|
|
#include "wsutil/str_util.h"
|
2017-12-11 12:56:12 +00:00
|
|
|
#include <wsutil/filesystem.h>
|
2021-06-08 01:46:52 +00:00
|
|
|
#include <wsutil/wslog.h>
|
2021-06-18 18:21:42 +00:00
|
|
|
#include <wsutil/ws_assert.h>
|
2001-11-09 07:44:51 +00:00
|
|
|
|
2007-08-02 21:45:27 +00:00
|
|
|
typedef struct if_stat_cache_item_s {
|
|
|
|
char *name;
|
|
|
|
struct pcap_stat ps;
|
|
|
|
} if_stat_cache_item_t;
|
2000-06-15 08:02:43 +00:00
|
|
|
|
2007-08-02 21:45:27 +00:00
|
|
|
struct if_stat_cache_s {
|
|
|
|
int stat_fd;
|
2015-06-10 00:30:15 +00:00
|
|
|
ws_process_id fork_child;
|
2007-08-02 21:45:27 +00:00
|
|
|
GList *cache_list; /* List of if_stat_chache_entry_t */
|
|
|
|
};
|
2004-02-21 14:04:17 +00:00
|
|
|
|
2008-06-24 08:05:45 +00:00
|
|
|
/* this callback mechanism should possibly be replaced by the g_signal_...() stuff (if I only would know how :-) */
|
|
|
|
typedef struct {
|
|
|
|
capture_callback_t cb_fct;
|
|
|
|
gpointer user_data;
|
|
|
|
} capture_callback_data_t;
|
|
|
|
|
|
|
|
static GList *capture_callbacks = NULL;
|
|
|
|
|
|
|
|
static void
|
2013-05-22 07:44:28 +00:00
|
|
|
capture_callback_invoke(int event, capture_session *cap_session)
|
2008-06-24 08:05:45 +00:00
|
|
|
{
|
2017-11-29 00:03:11 +00:00
|
|
|
capture_callback_data_t *cb;
|
|
|
|
GList *cb_item = capture_callbacks;
|
2008-06-24 08:05:45 +00:00
|
|
|
|
2017-11-29 00:03:11 +00:00
|
|
|
/* there should be at least one interested */
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert(cb_item != NULL);
|
2008-06-24 08:05:45 +00:00
|
|
|
|
2017-11-29 00:03:11 +00:00
|
|
|
while(cb_item != NULL) {
|
|
|
|
cb = (capture_callback_data_t *)cb_item->data;
|
|
|
|
cb->cb_fct(event, cap_session, cb->user_data);
|
|
|
|
cb_item = g_list_next(cb_item);
|
|
|
|
}
|
2008-06-24 08:05:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
capture_callback_add(capture_callback_t func, gpointer user_data)
|
|
|
|
{
|
2017-11-29 00:03:11 +00:00
|
|
|
capture_callback_data_t *cb;
|
2008-06-24 08:05:45 +00:00
|
|
|
|
2020-12-21 02:30:28 +00:00
|
|
|
cb = g_new(capture_callback_data_t, 1);
|
2017-11-29 00:03:11 +00:00
|
|
|
cb->cb_fct = func;
|
|
|
|
cb->user_data = user_data;
|
2008-06-24 08:05:45 +00:00
|
|
|
|
2017-12-04 12:20:19 +00:00
|
|
|
capture_callbacks = g_list_prepend(capture_callbacks, cb);
|
2008-06-24 08:05:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2014-09-09 20:42:58 +00:00
|
|
|
capture_callback_remove(capture_callback_t func, gpointer user_data)
|
2008-06-24 08:05:45 +00:00
|
|
|
{
|
2017-11-29 00:03:11 +00:00
|
|
|
capture_callback_data_t *cb;
|
|
|
|
GList *cb_item = capture_callbacks;
|
|
|
|
|
|
|
|
while(cb_item != NULL) {
|
|
|
|
cb = (capture_callback_data_t *)cb_item->data;
|
|
|
|
if(cb->cb_fct == func && cb->user_data == user_data) {
|
|
|
|
capture_callbacks = g_list_remove(capture_callbacks, cb);
|
|
|
|
g_free(cb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
cb_item = g_list_next(cb_item);
|
2008-06-24 08:05:45 +00:00
|
|
|
}
|
|
|
|
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert_not_reached();
|
2008-06-24 08:05:45 +00:00
|
|
|
}
|
|
|
|
|
2007-06-11 03:58:58 +00:00
|
|
|
/**
|
2005-03-28 18:04:09 +00:00
|
|
|
* Start a capture.
|
|
|
|
*
|
|
|
|
* @return TRUE if the capture starts successfully, FALSE otherwise.
|
|
|
|
*/
|
2004-12-29 09:09:35 +00:00
|
|
|
gboolean
|
Clean up handling of --capture-comment.
Don't store the comments in a capture_options structure, because that's
available only if we're being built with capture support, and
--capture-comment can be used in TShark when reading a capture file and
writing another capture file, with no live capture taking place.
This means we don't handle that option in capture_opts_add_opt(); handle
it in the programs that support it.
Support writing multiple comments in dumpcap when capturing.
These changes also fix builds without pcap, and makes --capture-comment
work in Wireshark when a capture is started from the command line with
-k.
Update the help messages to indicate that --capture-comment adds a
capture comment, it doesn't change any comment (much less "the" comment,
as there isn't necessarily a single comment).
Update the man pages:
- not to presume that only pcapng files support file comments (even if
that's true now, it might not be true in the future);
- to note that multiple instances of --capture-comment are supported,
and that multiple comments will be written, whether capturing or reading
one file and writing another;
- clarify that Wireshark doesn't *discard* SHB comments other than the
first one, even though it only displays the first one;
2021-07-15 05:16:30 +00:00
|
|
|
capture_start(capture_options *capture_opts, GPtrArray *capture_comments,
|
|
|
|
capture_session *cap_session, info_data_t* cap_data,
|
|
|
|
void(*update_cb)(void))
|
2004-12-29 09:09:35 +00:00
|
|
|
{
|
2017-11-29 00:03:11 +00:00
|
|
|
GString *source;
|
|
|
|
|
|
|
|
cap_session->state = CAPTURE_PREPARING;
|
|
|
|
cap_session->count = 0;
|
2021-06-08 01:46:52 +00:00
|
|
|
ws_message("Capture Start ...");
|
2017-11-29 00:03:11 +00:00
|
|
|
source = get_iface_list_string(capture_opts, IFLIST_SHOW_FILTER);
|
|
|
|
cf_set_tempfile_source((capture_file *)cap_session->cf, source->str);
|
|
|
|
g_string_free(source, TRUE);
|
|
|
|
/* try to start the capture child process */
|
Clean up handling of --capture-comment.
Don't store the comments in a capture_options structure, because that's
available only if we're being built with capture support, and
--capture-comment can be used in TShark when reading a capture file and
writing another capture file, with no live capture taking place.
This means we don't handle that option in capture_opts_add_opt(); handle
it in the programs that support it.
Support writing multiple comments in dumpcap when capturing.
These changes also fix builds without pcap, and makes --capture-comment
work in Wireshark when a capture is started from the command line with
-k.
Update the help messages to indicate that --capture-comment adds a
capture comment, it doesn't change any comment (much less "the" comment,
as there isn't necessarily a single comment).
Update the man pages:
- not to presume that only pcapng files support file comments (even if
that's true now, it might not be true in the future);
- to note that multiple instances of --capture-comment are supported,
and that multiple comments will be written, whether capturing or reading
one file and writing another;
- clarify that Wireshark doesn't *discard* SHB comments other than the
first one, even though it only displays the first one;
2021-07-15 05:16:30 +00:00
|
|
|
if (!sync_pipe_start(capture_opts, capture_comments, cap_session,
|
|
|
|
cap_data, update_cb)) {
|
2019-04-07 02:42:23 +00:00
|
|
|
/* We failed to start the capture child. */
|
2017-11-29 00:03:11 +00:00
|
|
|
if(capture_opts->save_file != NULL) {
|
|
|
|
g_free(capture_opts->save_file);
|
|
|
|
capture_opts->save_file = NULL;
|
|
|
|
}
|
|
|
|
|
2021-06-08 01:46:52 +00:00
|
|
|
ws_message("Capture Start failed.");
|
2017-11-29 00:03:11 +00:00
|
|
|
cap_session->state = CAPTURE_STOPPED;
|
2019-04-07 02:42:23 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2017-11-29 00:03:11 +00:00
|
|
|
|
2023-06-11 17:01:55 +00:00
|
|
|
// Do we need data structures for ignoring duplicate frames?
|
|
|
|
if (prefs.ignore_dup_frames && capture_opts->real_time_mode) {
|
|
|
|
fifo_string_cache_init(&cap_session->frame_dup_cache,
|
|
|
|
prefs.ignore_dup_frames_cache_entries, g_free);
|
|
|
|
cap_session->frame_cksum = g_checksum_new(G_CHECKSUM_SHA256);
|
|
|
|
}
|
|
|
|
|
2019-04-07 02:42:23 +00:00
|
|
|
/* 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)) */
|
2019-04-07 01:35:00 +00:00
|
|
|
|
2019-04-07 02:42:23 +00:00
|
|
|
/* 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 */
|
|
|
|
capture_callback_invoke(capture_cb_capture_prepared, cap_session);
|
2017-12-11 12:10:30 +00:00
|
|
|
|
2019-04-07 02:42:23 +00:00
|
|
|
wtap_rec_init(&cap_session->rec);
|
|
|
|
ws_buffer_init(&cap_session->buf, 1514);
|
2017-12-11 12:10:30 +00:00
|
|
|
|
2021-10-01 08:31:30 +00:00
|
|
|
cap_session->wtap = NULL;
|
2017-12-18 21:42:12 +00:00
|
|
|
|
2021-10-01 08:31:30 +00:00
|
|
|
if (capture_opts->show_info) {
|
2019-04-07 02:42:23 +00:00
|
|
|
if (cap_data->counts.counts_hash != NULL)
|
|
|
|
{
|
|
|
|
/* Clean up any previous lists of packet counts */
|
|
|
|
g_hash_table_destroy(cap_data->counts.counts_hash);
|
2017-12-18 21:42:12 +00:00
|
|
|
}
|
2019-04-07 02:42:23 +00:00
|
|
|
|
|
|
|
cap_data->counts.counts_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, g_free);
|
|
|
|
cap_data->counts.other = 0;
|
|
|
|
cap_data->counts.total = 0;
|
|
|
|
|
|
|
|
cap_data->ui.counts = &cap_data->counts;
|
|
|
|
|
|
|
|
capture_info_ui_create(&cap_data->ui, cap_session);
|
2017-11-29 00:03:11 +00:00
|
|
|
}
|
|
|
|
|
2019-04-07 02:42:23 +00:00
|
|
|
return TRUE;
|
2004-02-21 12:58:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-11 18:57:19 +00:00
|
|
|
void
|
2013-05-22 07:44:28 +00:00
|
|
|
capture_stop(capture_session *cap_session)
|
2005-04-11 18:57:19 +00:00
|
|
|
{
|
2021-06-08 01:46:52 +00:00
|
|
|
ws_message("Capture Stop ...");
|
2005-05-26 17:50:27 +00:00
|
|
|
|
2017-11-29 00:03:11 +00:00
|
|
|
capture_callback_invoke(capture_cb_capture_stopping, cap_session);
|
2005-09-20 08:42:35 +00:00
|
|
|
|
2022-08-13 03:58:50 +00:00
|
|
|
if (!extcap_session_stop(cap_session)) {
|
|
|
|
extcap_request_stop(cap_session);
|
|
|
|
cap_session->capture_opts->stop_after_extcaps = TRUE;
|
|
|
|
} else {
|
|
|
|
/* stop the capture child gracefully */
|
|
|
|
sync_pipe_stop(cap_session);
|
|
|
|
}
|
2005-04-11 18:57:19 +00:00
|
|
|
}
|
|
|
|
|
2005-04-12 21:44:55 +00:00
|
|
|
|
2005-04-11 18:57:19 +00:00
|
|
|
void
|
2013-05-22 07:44:28 +00:00
|
|
|
capture_kill_child(capture_session *cap_session)
|
2005-04-11 18:57:19 +00:00
|
|
|
{
|
2021-06-08 01:46:52 +00:00
|
|
|
ws_info("Capture Kill");
|
2005-05-26 17:50:27 +00:00
|
|
|
|
2017-11-29 00:03:11 +00:00
|
|
|
/* kill the capture child */
|
|
|
|
sync_pipe_kill(cap_session->fork_child);
|
2005-04-11 18:57:19 +00:00
|
|
|
}
|
|
|
|
|
2009-01-04 14:21:54 +00:00
|
|
|
/* We've succeeded in doing a (non real-time) capture; try to read it into a new capture file */
|
2005-03-28 14:39:31 +00:00
|
|
|
static gboolean
|
2013-05-22 07:44:28 +00:00
|
|
|
capture_input_read_all(capture_session *cap_session, gboolean is_tempfile,
|
|
|
|
gboolean drops_known, guint32 drops)
|
2004-02-21 12:58:42 +00:00
|
|
|
{
|
2017-11-29 00:03:11 +00:00
|
|
|
capture_options *capture_opts = cap_session->capture_opts;
|
|
|
|
int err;
|
2004-02-21 12:58:42 +00:00
|
|
|
|
2017-11-29 00:03:11 +00:00
|
|
|
/* Capture succeeded; attempt to open the capture file. */
|
|
|
|
if (cf_open((capture_file *)cap_session->cf, capture_opts->save_file, WTAP_TYPE_AUTO, is_tempfile, &err) != CF_OK) {
|
|
|
|
/* We're not doing a capture any more, so we don't have a save file. */
|
|
|
|
return FALSE;
|
|
|
|
}
|
2005-04-10 08:55:56 +00:00
|
|
|
|
2017-11-29 00:03:11 +00:00
|
|
|
/* Set the read filter to NULL. */
|
|
|
|
/* XXX - this is odd here; try to put it somewhere where it fits better */
|
|
|
|
cf_set_rfcode((capture_file *)cap_session->cf, NULL);
|
|
|
|
|
|
|
|
/* Get the packet-drop statistics.
|
|
|
|
|
|
|
|
XXX - there are currently no packet-drop statistics stored
|
|
|
|
in libpcap captures, and that's what we're reading.
|
|
|
|
|
|
|
|
At some point, we will add support in Wiretap to return
|
|
|
|
packet-drop statistics for capture file formats that store it,
|
|
|
|
and will make "cf_read()" get those statistics from Wiretap.
|
|
|
|
We clear the statistics (marking them as "not known") in
|
|
|
|
"cf_open()", and "cf_read()" will only fetch them and mark
|
|
|
|
them as known if Wiretap supplies them, so if we get the
|
|
|
|
statistics now, after calling "cf_open()" but before calling
|
|
|
|
"cf_read()", the values we store will be used by "cf_read()".
|
|
|
|
|
|
|
|
If a future libpcap capture file format stores the statistics,
|
|
|
|
we'll put them into the capture file that we write, and will
|
|
|
|
thus not have to set them here - "cf_read()" will get them from
|
|
|
|
the file and use them. */
|
|
|
|
if (drops_known) {
|
|
|
|
cf_set_drops_known((capture_file *)cap_session->cf, TRUE);
|
|
|
|
|
|
|
|
/* XXX - on some systems, libpcap doesn't bother filling in
|
|
|
|
"ps_ifdrop" - it doesn't even set it to zero - so we don't
|
|
|
|
bother looking at it.
|
|
|
|
|
|
|
|
Ideally, libpcap would have an interface that gave us
|
|
|
|
several statistics - perhaps including various interface
|
|
|
|
error statistics - and would tell us which of them it
|
|
|
|
supplies, allowing us to display only the ones it does. */
|
|
|
|
cf_set_drops((capture_file *)cap_session->cf, drops);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* read in the packet data */
|
2023-06-04 14:12:19 +00:00
|
|
|
switch (cf_read((capture_file *)cap_session->cf, /*reloading=*/FALSE)) {
|
2017-11-29 00:03:11 +00:00
|
|
|
|
|
|
|
case CF_READ_OK:
|
|
|
|
case CF_READ_ERROR:
|
|
|
|
/* Just because we got an error, that doesn't mean we were unable
|
|
|
|
to read any of the file; we handle what we could get from the
|
|
|
|
file. */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CF_READ_ABORTED:
|
|
|
|
/* User wants to quit program. Exit by leaving the main loop,
|
|
|
|
so that any quit functions we registered get called. */
|
2022-06-29 08:44:30 +00:00
|
|
|
exit_application(0);
|
2017-11-29 00:03:11 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if we didn't capture even a single packet, close the file again */
|
|
|
|
if(cap_session->count == 0 && !capture_opts->restart) {
|
|
|
|
simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
|
|
|
|
"%sNo packets captured.%s\n"
|
|
|
|
"\n"
|
|
|
|
"As no data was captured, closing the %scapture file.\n"
|
|
|
|
"\n"
|
|
|
|
"\n"
|
|
|
|
"Help about capturing can be found at\n"
|
|
|
|
"\n"
|
2020-10-25 21:42:47 +00:00
|
|
|
" " WS_WIKI_URL("CaptureSetup")
|
2005-11-25 22:27:27 +00:00
|
|
|
#ifdef _WIN32
|
2017-11-29 00:03:11 +00:00
|
|
|
"\n\n"
|
|
|
|
"Wireless (Wi-Fi/WLAN):\n"
|
|
|
|
"Try to switch off promiscuous mode in the Capture Options"
|
2005-11-25 22:27:27 +00:00
|
|
|
#endif
|
2017-11-29 00:03:11 +00:00
|
|
|
"",
|
|
|
|
simple_dialog_primary_start(), simple_dialog_primary_end(),
|
|
|
|
(cf_is_tempfile((capture_file *)cap_session->cf)) ? "temporary " : "");
|
|
|
|
cf_close((capture_file *)cap_session->cf);
|
|
|
|
}
|
|
|
|
return TRUE;
|
2004-02-21 12:58:42 +00:00
|
|
|
}
|
|
|
|
|
2017-12-11 12:56:12 +00:00
|
|
|
static const char *
|
2021-02-18 00:08:31 +00:00
|
|
|
cf_open_error_message(int err, gchar *err_info)
|
2017-12-11 12:56:12 +00:00
|
|
|
{
|
|
|
|
const char *errmsg;
|
|
|
|
static char errmsg_errno[1024 + 1];
|
|
|
|
|
|
|
|
if (err < 0) {
|
|
|
|
/* Wiretap error. */
|
|
|
|
switch (err) {
|
|
|
|
|
|
|
|
case WTAP_ERR_NOT_REGULAR_FILE:
|
|
|
|
errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file.";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WTAP_ERR_FILE_UNKNOWN_FORMAT:
|
|
|
|
/* Seen only when opening a capture file for reading. */
|
|
|
|
errmsg = "The file \"%s\" isn't a capture file in a format Wireshark understands.";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WTAP_ERR_UNSUPPORTED:
|
2021-12-17 20:05:19 +00:00
|
|
|
snprintf(errmsg_errno, sizeof(errmsg_errno),
|
2018-03-03 06:43:16 +00:00
|
|
|
"The file \"%%s\" contains record data that Wireshark doesn't support.\n"
|
|
|
|
"(%s)", err_info != NULL ? err_info : "no information supplied");
|
2017-12-11 12:56:12 +00:00
|
|
|
g_free(err_info);
|
|
|
|
errmsg = errmsg_errno;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
|
2021-02-18 00:08:31 +00:00
|
|
|
errmsg = "The file \"%s\" is a capture for a network type that Wireshark doesn't support.";
|
2017-12-11 12:56:12 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case WTAP_ERR_BAD_FILE:
|
2021-12-17 20:05:19 +00:00
|
|
|
snprintf(errmsg_errno, sizeof(errmsg_errno),
|
2018-03-03 06:43:16 +00:00
|
|
|
"The file \"%%s\" appears to be damaged or corrupt.\n"
|
|
|
|
"(%s)", err_info != NULL ? err_info : "no information supplied");
|
2017-12-11 12:56:12 +00:00
|
|
|
g_free(err_info);
|
|
|
|
errmsg = errmsg_errno;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WTAP_ERR_CANT_OPEN:
|
2021-02-18 00:08:31 +00:00
|
|
|
errmsg = "The file \"%s\" could not be opened for some unknown reason.";
|
2017-12-11 12:56:12 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case WTAP_ERR_SHORT_READ:
|
|
|
|
errmsg = "The file \"%s\" appears to have been cut short"
|
|
|
|
" in the middle of a packet or other data.";
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WTAP_ERR_DECOMPRESS:
|
2021-12-17 20:05:19 +00:00
|
|
|
snprintf(errmsg_errno, sizeof(errmsg_errno),
|
2021-02-18 00:08:31 +00:00
|
|
|
"The file \"%%s\" cannot be decompressed; it may be damaged or corrupt.\n"
|
2018-03-03 06:43:16 +00:00
|
|
|
"(%s)", err_info != NULL ? err_info : "no information supplied");
|
2018-01-14 21:07:17 +00:00
|
|
|
g_free(err_info);
|
|
|
|
errmsg = errmsg_errno;
|
|
|
|
break;
|
|
|
|
|
2020-10-14 01:48:46 +00:00
|
|
|
case WTAP_ERR_INTERNAL:
|
2021-12-17 20:05:19 +00:00
|
|
|
snprintf(errmsg_errno, sizeof(errmsg_errno),
|
2021-02-18 00:08:31 +00:00
|
|
|
"An internal error occurred opening the file \"%%s\".\n"
|
|
|
|
"(%s)", err_info != NULL ? err_info : "no information supplied");
|
2020-10-14 01:48:46 +00:00
|
|
|
g_free(err_info);
|
|
|
|
errmsg = errmsg_errno;
|
|
|
|
break;
|
|
|
|
|
2018-01-14 21:07:17 +00:00
|
|
|
case WTAP_ERR_DECOMPRESSION_NOT_SUPPORTED:
|
2021-12-17 20:05:19 +00:00
|
|
|
snprintf(errmsg_errno, sizeof(errmsg_errno),
|
2021-02-18 00:08:31 +00:00
|
|
|
"The file \"%%s\" cannot be decompressed; it is compressed in a way that We don't support.\n"
|
2018-03-03 06:43:16 +00:00
|
|
|
"(%s)", err_info != NULL ? err_info : "no information supplied");
|
2017-12-11 12:56:12 +00:00
|
|
|
g_free(err_info);
|
|
|
|
errmsg = errmsg_errno;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2021-12-17 20:05:19 +00:00
|
|
|
snprintf(errmsg_errno, sizeof(errmsg_errno),
|
2021-02-18 00:08:31 +00:00
|
|
|
"The file \"%%s\" could not be opened: %s.",
|
2018-03-03 06:43:16 +00:00
|
|
|
wtap_strerror(err));
|
2017-12-11 12:56:12 +00:00
|
|
|
errmsg = errmsg_errno;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2021-02-18 00:08:31 +00:00
|
|
|
errmsg = file_open_error_message(err, FALSE);
|
2017-12-11 12:56:12 +00:00
|
|
|
return errmsg;
|
|
|
|
}
|
Enough is enough. Requiring anybody who uses Ethereal on Linux to
update their libpcap probably isn't going to scale - the increasing
frequency with which "Ethereal hangs when I try to capture packets"
shows up on "ethereal-dev" suggests that, unless and until a libpcap
with the "select()" in it becomes ubiquitous on Linux, that'll be the
source of a constant support burden - so we'll just put the "select()"
in Ethereal if it's being built for Linux.
(Putting it in for platforms where the read timeout argument to
"pcap_open_live()" works adds an extra useless system call at best and,
at worst, could make Ethereal not work - "select()" doesn't work on
"/dev/bpf" devices on FreeBSD 3.3, at least, unless you're in "immediate
mode", and, whilst "immediate mode" would make Ethereal respond more
quickly when packets arrive, it might cause Ethereal to respond too
quickly, doing reads for every new packet rather than waiting for
multiple packets to arrive and reading them all with one "read()", which
appears to be at least part of the intent of the read timeout on
"/dev/bpf" devices in BSD.)
svn path=/trunk/; revision=1451
2000-01-12 06:56:32 +00:00
|
|
|
|
2006-03-05 03:14:16 +00:00
|
|
|
/* capture child tells us we have a new (or the first) capture file */
|
2023-06-13 18:46:25 +00:00
|
|
|
static bool
|
2013-05-22 07:44:28 +00:00
|
|
|
capture_input_new_file(capture_session *cap_session, gchar *new_file)
|
2005-02-27 19:59:03 +00:00
|
|
|
{
|
2017-11-29 00:03:11 +00:00
|
|
|
capture_options *capture_opts = cap_session->capture_opts;
|
|
|
|
gboolean is_tempfile;
|
|
|
|
int err;
|
2017-12-11 12:56:12 +00:00
|
|
|
gchar *err_info;
|
|
|
|
gchar *err_msg;
|
2017-11-29 00:03:11 +00:00
|
|
|
|
|
|
|
if(cap_session->state == CAPTURE_PREPARING) {
|
2021-06-08 01:46:52 +00:00
|
|
|
ws_message("Capture started");
|
2017-11-29 00:03:11 +00:00
|
|
|
}
|
2021-06-08 01:46:52 +00:00
|
|
|
ws_message("File: \"%s\"", new_file);
|
2017-11-29 00:03:11 +00:00
|
|
|
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
|
2017-11-29 00:03:11 +00:00
|
|
|
|
|
|
|
/* free the old filename */
|
|
|
|
if(capture_opts->save_file != NULL) {
|
|
|
|
/* 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!) */
|
2023-06-11 14:18:18 +00:00
|
|
|
if (((capture_file*)cap_session->cf)->state == FILE_READ_PENDING) {
|
|
|
|
capture_callback_invoke(capture_cb_capture_fixed_finished, cap_session);
|
|
|
|
} else if (((capture_file*)cap_session->cf)->state != FILE_CLOSED) {
|
|
|
|
cap_session->session_will_restart = TRUE;
|
|
|
|
capture_callback_invoke(capture_cb_capture_update_finished, cap_session);
|
|
|
|
cf_finish_tail((capture_file *)cap_session->cf,
|
|
|
|
&cap_session->rec, &cap_session->buf, &err,
|
|
|
|
&cap_session->frame_dup_cache, cap_session->frame_cksum);
|
|
|
|
cf_close((capture_file *)cap_session->cf);
|
2012-07-28 11:13:24 +00:00
|
|
|
}
|
2017-11-29 00:03:11 +00:00
|
|
|
g_free(capture_opts->save_file);
|
|
|
|
is_tempfile = FALSE;
|
|
|
|
cf_set_tempfile((capture_file *)cap_session->cf, FALSE);
|
|
|
|
} else {
|
|
|
|
/* we didn't have a save_file before; must be a tempfile */
|
|
|
|
is_tempfile = TRUE;
|
|
|
|
cf_set_tempfile((capture_file *)cap_session->cf, TRUE);
|
2005-04-11 18:57:19 +00:00
|
|
|
}
|
2017-11-29 00:03:11 +00:00
|
|
|
|
|
|
|
/* save the new filename */
|
|
|
|
capture_opts->save_file = g_strdup(new_file);
|
|
|
|
|
|
|
|
/* if we are in real-time mode, open the new file now */
|
|
|
|
if(capture_opts->real_time_mode) {
|
|
|
|
/* Attempt to open the capture file and set up to read from it. */
|
|
|
|
switch(cf_open((capture_file *)cap_session->cf, capture_opts->save_file, WTAP_TYPE_AUTO, is_tempfile, &err)) {
|
|
|
|
case CF_OK:
|
|
|
|
break;
|
|
|
|
case CF_ERROR:
|
|
|
|
/* 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 FALSE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
capture_callback_invoke(capture_cb_capture_prepared, cap_session);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(capture_opts->show_info) {
|
2019-04-07 01:35:00 +00:00
|
|
|
if (cap_session->wtap != NULL) {
|
|
|
|
wtap_close(cap_session->wtap);
|
2017-12-11 12:56:12 +00:00
|
|
|
}
|
|
|
|
|
2019-04-07 01:35:00 +00:00
|
|
|
cap_session->wtap = wtap_open_offline(new_file, WTAP_TYPE_AUTO, &err, &err_info, FALSE);
|
|
|
|
if (!cap_session->wtap) {
|
2021-12-18 18:48:20 +00:00
|
|
|
err_msg = ws_strdup_printf(cf_open_error_message(err, err_info),
|
2018-03-03 06:39:12 +00:00
|
|
|
new_file);
|
2021-06-14 23:06:02 +00:00
|
|
|
ws_warning("capture_input_new_file: %d (%s)", err, err_msg);
|
2017-12-11 12:56:12 +00:00
|
|
|
g_free(err_msg);
|
2017-11-29 00:03:11 +00:00
|
|
|
return FALSE;
|
2017-12-11 12:56:12 +00:00
|
|
|
}
|
2017-11-29 00:03:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if(capture_opts->real_time_mode) {
|
|
|
|
capture_callback_invoke(capture_cb_capture_update_started, cap_session);
|
|
|
|
} else {
|
|
|
|
capture_callback_invoke(capture_cb_capture_fixed_started, cap_session);
|
2005-02-27 19:59:03 +00:00
|
|
|
}
|
2017-11-29 00:03:11 +00:00
|
|
|
cap_session->state = CAPTURE_RUNNING;
|
|
|
|
|
|
|
|
return TRUE;
|
2005-03-28 14:39:31 +00:00
|
|
|
}
|
|
|
|
|
2019-09-15 13:15:31 +00:00
|
|
|
static void
|
|
|
|
capture_info_packet(info_data_t* cap_info, gint wtap_linktype, const guchar *pd, guint32 caplen, union wtap_pseudo_header *pseudo_header)
|
|
|
|
{
|
|
|
|
capture_packet_info_t cpinfo;
|
|
|
|
|
|
|
|
/* Setup the capture packet structure */
|
|
|
|
cpinfo.counts = cap_info->counts.counts_hash;
|
|
|
|
|
|
|
|
cap_info->counts.total++;
|
|
|
|
if (!try_capture_dissector("wtap_encap", wtap_linktype, pd, 0, caplen, &cpinfo, pseudo_header))
|
|
|
|
cap_info->counts.other++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* new packets arrived */
|
2019-09-15 20:51:49 +00:00
|
|
|
static void
|
|
|
|
capture_info_new_packets(int to_read, wtap *wth, info_data_t* cap_info)
|
2019-09-15 13:15:31 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
gchar *err_info;
|
|
|
|
gint64 data_offset;
|
|
|
|
wtap_rec rec;
|
|
|
|
Buffer buf;
|
|
|
|
union wtap_pseudo_header *pseudo_header;
|
|
|
|
int wtap_linktype;
|
|
|
|
|
|
|
|
cap_info->ui.new_packets = to_read;
|
|
|
|
|
2021-06-14 23:06:02 +00:00
|
|
|
/*ws_warning("new packets: %u", to_read);*/
|
2019-09-15 13:15:31 +00:00
|
|
|
|
|
|
|
wtap_rec_init(&rec);
|
|
|
|
ws_buffer_init(&buf, 1514);
|
|
|
|
while (to_read > 0) {
|
|
|
|
wtap_cleareof(wth);
|
|
|
|
if (wtap_read(wth, &rec, &buf, &err, &err_info, &data_offset)) {
|
|
|
|
if (rec.rec_type == REC_TYPE_PACKET) {
|
|
|
|
pseudo_header = &rec.rec_header.packet_header.pseudo_header;
|
|
|
|
wtap_linktype = rec.rec_header.packet_header.pkt_encap;
|
|
|
|
|
|
|
|
capture_info_packet(cap_info, wtap_linktype,
|
|
|
|
ws_buffer_start_ptr(&buf),
|
|
|
|
rec.rec_header.packet_header.caplen,
|
|
|
|
pseudo_header);
|
|
|
|
|
2021-06-14 23:06:02 +00:00
|
|
|
/*ws_warning("new packet");*/
|
2019-09-15 13:15:31 +00:00
|
|
|
to_read--;
|
|
|
|
}
|
2021-08-04 17:18:46 +00:00
|
|
|
wtap_rec_reset(&rec);
|
2019-09-15 13:15:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
wtap_rec_cleanup(&rec);
|
|
|
|
ws_buffer_free(&buf);
|
|
|
|
|
|
|
|
capture_info_ui_update(&cap_info->ui);
|
|
|
|
}
|
2007-06-11 03:58:58 +00:00
|
|
|
|
2014-05-23 10:50:02 +00:00
|
|
|
/* capture child tells us we have new packets to read */
|
2020-03-25 22:33:01 +00:00
|
|
|
static void
|
2014-05-23 10:50:02 +00:00
|
|
|
capture_input_new_packets(capture_session *cap_session, int to_read)
|
2005-03-28 14:39:31 +00:00
|
|
|
{
|
2017-11-29 00:03:11 +00:00
|
|
|
capture_options *capture_opts = cap_session->capture_opts;
|
|
|
|
int err;
|
2006-01-22 16:26:41 +00:00
|
|
|
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert(capture_opts->save_file);
|
2005-12-04 02:04:18 +00:00
|
|
|
|
2017-11-29 00:03:11 +00:00
|
|
|
if(capture_opts->real_time_mode) {
|
2023-06-11 14:18:18 +00:00
|
|
|
if (((capture_file*)cap_session->cf)->state == FILE_READ_PENDING) {
|
|
|
|
/* Attempt to open the capture file and set up to read from it. */
|
|
|
|
switch (cf_open((capture_file*)cap_session->cf, capture_opts->save_file, WTAP_TYPE_AUTO, cf_is_tempfile((capture_file*)cap_session->cf), &err)) {
|
|
|
|
case CF_OK:
|
|
|
|
break;
|
|
|
|
case CF_ERROR:
|
|
|
|
/* Don't unlink (delete) the save file - leave it around,
|
|
|
|
for debugging purposes. */
|
|
|
|
g_free(capture_opts->save_file);
|
|
|
|
capture_opts->save_file = NULL;
|
|
|
|
capture_kill_child(cap_session);
|
|
|
|
}
|
|
|
|
capture_callback_invoke(capture_cb_capture_update_started, cap_session);
|
|
|
|
}
|
2017-11-29 00:03:11 +00:00
|
|
|
/* Read from the capture file the number of records the child told us it added. */
|
2023-06-11 14:18:18 +00:00
|
|
|
to_read += cap_session->count_pending;
|
|
|
|
cap_session->count_pending = 0;
|
2019-04-07 02:42:23 +00:00
|
|
|
switch (cf_continue_tail((capture_file *)cap_session->cf, to_read,
|
2023-06-05 22:07:09 +00:00
|
|
|
&cap_session->rec, &cap_session->buf, &err,
|
|
|
|
&cap_session->frame_dup_cache, cap_session->frame_cksum)) {
|
2017-11-29 00:03:11 +00:00
|
|
|
|
|
|
|
case CF_READ_OK:
|
|
|
|
case CF_READ_ERROR:
|
|
|
|
/* Just because we got an error, that doesn't mean we were unable
|
|
|
|
to read any of the file; we handle what we could get from the
|
|
|
|
file.
|
|
|
|
|
|
|
|
XXX - abort on a read error? */
|
|
|
|
capture_callback_invoke(capture_cb_capture_update_continue, cap_session);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CF_READ_ABORTED:
|
|
|
|
/* Kill the child capture process; the user wants to exit, and we
|
|
|
|
shouldn't just leave it running. */
|
|
|
|
capture_kill_child(cap_session);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
cf_fake_continue_tail((capture_file *)cap_session->cf);
|
2023-06-11 14:18:18 +00:00
|
|
|
cap_session->count_pending += to_read;
|
2017-11-29 00:03:11 +00:00
|
|
|
|
|
|
|
capture_callback_invoke(capture_cb_capture_fixed_continue, cap_session);
|
|
|
|
}
|
|
|
|
|
2021-10-01 08:31:30 +00:00
|
|
|
if(cap_session->wtap)
|
2019-04-07 01:35:00 +00:00
|
|
|
capture_info_new_packets(to_read, cap_session->wtap, cap_session->cap_data_info);
|
2005-03-28 14:39:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-03-05 03:14:16 +00:00
|
|
|
/* Capture child told us how many dropped packets it counted.
|
2005-12-03 18:15:02 +00:00
|
|
|
*/
|
2020-03-25 22:33:01 +00:00
|
|
|
static void
|
2019-03-18 00:20:40 +00:00
|
|
|
capture_input_drops(capture_session *cap_session, guint32 dropped, const char* interface_name)
|
2005-12-03 18:15:02 +00:00
|
|
|
{
|
2018-12-27 16:34:09 +00:00
|
|
|
if (interface_name != NULL) {
|
2021-06-08 01:46:52 +00:00
|
|
|
ws_info("%u packet%s dropped from %s", dropped, plurality(dropped, "", "s"), interface_name);
|
2018-12-27 16:34:09 +00:00
|
|
|
} else {
|
2021-06-08 01:46:52 +00:00
|
|
|
ws_info("%u packet%s dropped", dropped, plurality(dropped, "", "s"));
|
2018-12-27 16:34:09 +00:00
|
|
|
}
|
2005-12-03 18:15:02 +00:00
|
|
|
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert(cap_session->state == CAPTURE_RUNNING);
|
2005-12-03 18:15:02 +00:00
|
|
|
|
2017-11-29 00:03:11 +00:00
|
|
|
cf_set_drops_known((capture_file *)cap_session->cf, TRUE);
|
|
|
|
cf_set_drops((capture_file *)cap_session->cf, dropped);
|
2005-12-03 18:15:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-03-05 03:14:16 +00:00
|
|
|
/* Capture child told us that an error has occurred while starting/running
|
|
|
|
the capture.
|
|
|
|
The buffer we're handed has *two* null-terminated strings in it - a
|
|
|
|
primary message and a secondary message, one right after the other.
|
|
|
|
The secondary message might be a null string.
|
|
|
|
*/
|
2020-03-25 22:33:01 +00:00
|
|
|
static void
|
2021-06-18 18:21:42 +00:00
|
|
|
capture_input_error(capture_session *cap_session _U_, char *error_msg,
|
2020-03-25 22:33:01 +00:00
|
|
|
char *secondary_error_msg)
|
2005-12-03 18:15:02 +00:00
|
|
|
{
|
2017-11-29 00:03:11 +00:00
|
|
|
gchar *safe_error_msg;
|
|
|
|
gchar *safe_secondary_error_msg;
|
|
|
|
|
2024-01-18 03:40:34 +00:00
|
|
|
/* The primary message might be an empty string, e.g. when the error was
|
|
|
|
* from extcap. (The extcap stderr is gathered when the session closes
|
|
|
|
* and printed in capture_input_closed below.) */
|
|
|
|
if (*error_msg != '\0') {
|
|
|
|
ws_message("Error message from child: \"%s\", \"%s\"", error_msg, secondary_error_msg);
|
|
|
|
}
|
2017-11-29 00:03:11 +00:00
|
|
|
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
|
2017-11-29 00:03:11 +00:00
|
|
|
|
|
|
|
safe_error_msg = simple_dialog_format_message(error_msg);
|
capture child: send an errno message if exec of dumpcap fails.
On at least some Linux distributions, dumpcap is either installed with
elevated privileges sufficient to support traffic capture by default or
can optionally be given those privileges. If it has those privileges,
it's typically made group-executable but not world-executable and owned
by a special group, e.g. "wireshark", so that only users in that group
can use dumpcap to capture traffic.
The user installing the Wireshark package is *not* necessarily put into
that group by default; this means that any attempt by Wireshark or
TShark to run dumpcap will fail with EACCES.
If the exec call in the child process sends text error mesages, intended
for end users, up the message pipe, as we had been doing, then figuring
out *why* the exec failed would require some heuristic parsing to figure
out whether it's a permissions problem or not.
Instead of doing that, just send a message giving the errno for exec
failing.
For now, we just format an error message for that in the parent process,
but this leaves room to do a better job.
While we're at it, fix some cases where an empty error message could be
printed.
2023-09-10 05:14:08 +00:00
|
|
|
if (secondary_error_msg != NULL && *secondary_error_msg != '\0') {
|
2017-11-29 00:03:11 +00:00
|
|
|
/* We have both primary and secondary messages. */
|
|
|
|
safe_secondary_error_msg = simple_dialog_format_message(secondary_error_msg);
|
|
|
|
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s%s%s\n\n%s",
|
|
|
|
simple_dialog_primary_start(), safe_error_msg,
|
|
|
|
simple_dialog_primary_end(), safe_secondary_error_msg);
|
|
|
|
g_free(safe_secondary_error_msg);
|
|
|
|
} else {
|
|
|
|
/* We have only a primary message. */
|
|
|
|
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s%s%s",
|
|
|
|
simple_dialog_primary_start(), safe_error_msg,
|
|
|
|
simple_dialog_primary_end());
|
|
|
|
}
|
|
|
|
g_free(safe_error_msg);
|
|
|
|
|
|
|
|
/* the capture child will close the sync_pipe if required, nothing to do for now */
|
2006-03-05 03:14:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Capture child told us that an error has occurred while parsing a
|
|
|
|
capture filter when starting/running the capture.
|
|
|
|
*/
|
2020-03-25 22:33:01 +00:00
|
|
|
static void
|
|
|
|
capture_input_cfilter_error(capture_session *cap_session, guint i,
|
|
|
|
const char *error_message)
|
2006-03-05 03:14:16 +00:00
|
|
|
{
|
2017-11-29 00:03:11 +00:00
|
|
|
capture_options *capture_opts = cap_session->capture_opts;
|
|
|
|
dfilter_t *rfcode = NULL;
|
|
|
|
gchar *safe_cfilter;
|
|
|
|
gchar *safe_descr;
|
|
|
|
gchar *safe_cfilter_error_msg;
|
|
|
|
interface_options *interface_opts;
|
|
|
|
|
2021-06-08 01:46:52 +00:00
|
|
|
ws_message("Capture filter error message from child: \"%s\"", error_message);
|
2017-11-29 00:03:11 +00:00
|
|
|
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
|
|
|
|
ws_assert(i < capture_opts->ifaces->len);
|
2017-11-29 00:03:11 +00:00
|
|
|
|
|
|
|
interface_opts = &g_array_index(capture_opts->ifaces, interface_options, i);
|
|
|
|
safe_cfilter = simple_dialog_format_message(interface_opts->cfilter);
|
|
|
|
safe_descr = simple_dialog_format_message(interface_opts->descr);
|
|
|
|
safe_cfilter_error_msg = simple_dialog_format_message(error_message);
|
|
|
|
/* Did the user try a display filter? */
|
|
|
|
if (dfilter_compile(interface_opts->cfilter, &rfcode, NULL) && rfcode != NULL) {
|
|
|
|
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
|
|
|
|
"%sInvalid capture filter \"%s\" for interface %s.%s\n"
|
|
|
|
"\n"
|
|
|
|
"That string looks like a valid display filter; however, it isn't a valid\n"
|
|
|
|
"capture filter (%s).\n"
|
|
|
|
"\n"
|
|
|
|
"Note that display filters and capture filters don't have the same syntax,\n"
|
|
|
|
"so you can't use most display filter expressions as capture filters.\n"
|
|
|
|
"\n"
|
|
|
|
"See the User's Guide for a description of the capture filter syntax.",
|
|
|
|
simple_dialog_primary_start(), safe_cfilter, safe_descr,
|
|
|
|
simple_dialog_primary_end(), safe_cfilter_error_msg);
|
|
|
|
dfilter_free(rfcode);
|
|
|
|
} else {
|
|
|
|
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
|
|
|
|
"%sInvalid capture filter \"%s\" for interface %s.%s\n"
|
|
|
|
"\n"
|
|
|
|
"That string isn't a valid capture filter (%s).\n"
|
|
|
|
"See the User's Guide for a description of the capture filter syntax.",
|
|
|
|
simple_dialog_primary_start(), safe_cfilter, safe_descr,
|
|
|
|
simple_dialog_primary_end(), safe_cfilter_error_msg);
|
|
|
|
}
|
|
|
|
g_free(safe_cfilter_error_msg);
|
|
|
|
g_free(safe_descr);
|
|
|
|
g_free(safe_cfilter);
|
|
|
|
|
|
|
|
/* the capture child will close the sync_pipe if required, nothing to do for now */
|
2005-12-03 18:15:02 +00:00
|
|
|
}
|
|
|
|
|
2006-03-05 03:14:16 +00:00
|
|
|
/* capture child closed its side of the pipe, do the required cleanup */
|
2020-03-25 22:33:01 +00:00
|
|
|
static void
|
2013-05-22 07:44:28 +00:00
|
|
|
capture_input_closed(capture_session *cap_session, gchar *msg)
|
2005-03-28 14:39:31 +00:00
|
|
|
{
|
2017-11-29 00:03:11 +00:00
|
|
|
capture_options *capture_opts = cap_session->capture_opts;
|
|
|
|
int err;
|
|
|
|
|
2021-06-08 01:46:52 +00:00
|
|
|
ws_message("Capture stopped.");
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
|
2017-11-29 00:03:11 +00:00
|
|
|
|
2023-12-31 16:37:11 +00:00
|
|
|
if (msg != NULL && msg[0] != '\0') {
|
2022-09-06 23:48:17 +00:00
|
|
|
ESD_TYPE_E dlg_type = ESD_TYPE_ERROR;
|
|
|
|
if (strstr(msg, " WARNING] ")) {
|
|
|
|
dlg_type = ESD_TYPE_WARN;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* ws_log prefixes log messages with a timestamp delimited by " -- " and possibly
|
2023-09-26 04:26:25 +00:00
|
|
|
* a function name delimited by "(): ". Log it to sterr, but omit it in the UI.
|
2022-09-06 23:48:17 +00:00
|
|
|
*/
|
|
|
|
char *plain_msg = strstr(msg, "(): ");
|
|
|
|
if (plain_msg != NULL) {
|
|
|
|
plain_msg += strlen("(): ");
|
|
|
|
} else if ((plain_msg = strstr(msg, " -- ")) != NULL) {
|
|
|
|
plain_msg += strlen(" -- ");
|
|
|
|
} else {
|
|
|
|
plain_msg = msg;
|
|
|
|
}
|
|
|
|
ws_warning("%s", msg);
|
|
|
|
simple_dialog(dlg_type, ESD_BTN_OK, "%s", plain_msg);
|
|
|
|
}
|
2017-11-29 00:03:11 +00:00
|
|
|
|
2019-04-07 02:42:23 +00:00
|
|
|
wtap_rec_cleanup(&cap_session->rec);
|
|
|
|
ws_buffer_free(&cap_session->buf);
|
2017-11-29 00:03:11 +00:00
|
|
|
if(cap_session->state == CAPTURE_PREPARING) {
|
2019-04-07 02:42:23 +00:00
|
|
|
/* We started the capture child, but we didn't manage to start
|
|
|
|
the capture process; note that the attempt to start it
|
2017-11-29 00:03:11 +00:00
|
|
|
failed. */
|
|
|
|
capture_callback_invoke(capture_cb_capture_failed, cap_session);
|
|
|
|
} else {
|
|
|
|
/* 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
|
|
|
|
all of it if we weren't. */
|
2023-06-11 14:18:18 +00:00
|
|
|
if(((capture_file*)cap_session->cf)->state == FILE_READ_IN_PROGRESS) {
|
2017-11-29 00:03:11 +00:00
|
|
|
cf_read_status_t status;
|
|
|
|
|
|
|
|
/* Read what remains of the capture file. */
|
2019-04-07 02:42:23 +00:00
|
|
|
status = cf_finish_tail((capture_file *)cap_session->cf,
|
2023-06-05 22:07:09 +00:00
|
|
|
&cap_session->rec, &cap_session->buf, &err,
|
|
|
|
&cap_session->frame_dup_cache, cap_session->frame_cksum);
|
2017-11-29 00:03:11 +00:00
|
|
|
|
2023-06-11 17:01:55 +00:00
|
|
|
// The real-time reading of the pcap is done. Now we can clear the
|
|
|
|
// dup-frame cache, if present. But check that we actually have
|
|
|
|
// data structures to clear (by checking frame-checksum); the user
|
|
|
|
// could have changed the preference *during* the live capture.
|
|
|
|
if (cap_session->frame_cksum != NULL) {
|
|
|
|
fifo_string_cache_free(&cap_session->frame_dup_cache);
|
|
|
|
g_checksum_free(cap_session->frame_cksum);
|
|
|
|
cap_session->frame_cksum = NULL;
|
|
|
|
}
|
|
|
|
|
2017-11-29 00:03:11 +00:00
|
|
|
/* Tell the GUI we are not doing a capture any more.
|
|
|
|
Must be done after the cf_finish_tail(), so file lengths are
|
|
|
|
correctly displayed */
|
2019-11-07 11:35:47 +00:00
|
|
|
cap_session->session_will_restart = FALSE;
|
2017-11-29 00:03:11 +00:00
|
|
|
capture_callback_invoke(capture_cb_capture_update_finished, cap_session);
|
|
|
|
|
|
|
|
/* Finish the capture. */
|
|
|
|
switch (status) {
|
|
|
|
|
|
|
|
case CF_READ_OK:
|
|
|
|
if (cap_session->count == 0 && !capture_opts->restart) {
|
|
|
|
simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
|
|
|
|
"%sNo packets captured.%s\n"
|
|
|
|
"\n"
|
|
|
|
"As no data was captured, closing the %scapture file.\n"
|
|
|
|
"\n"
|
|
|
|
"\n"
|
|
|
|
"Help about capturing can be found at\n"
|
|
|
|
"\n"
|
2020-10-25 21:42:47 +00:00
|
|
|
" " WS_WIKI_URL("CaptureSetup")
|
2005-11-25 22:27:27 +00:00
|
|
|
#ifdef _WIN32
|
2017-11-29 00:03:11 +00:00
|
|
|
"\n\n"
|
|
|
|
"Wireless (Wi-Fi/WLAN):\n"
|
|
|
|
"Try to switch off promiscuous mode in the Capture Options."
|
2005-11-25 22:27:27 +00:00
|
|
|
#endif
|
2017-11-29 00:03:11 +00:00
|
|
|
"",
|
|
|
|
simple_dialog_primary_start(), simple_dialog_primary_end(),
|
|
|
|
cf_is_tempfile((capture_file *)cap_session->cf) ? "temporary " : "");
|
|
|
|
cf_close((capture_file *)cap_session->cf);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CF_READ_ERROR:
|
|
|
|
/* Just because we got an error, that doesn't mean we were unable
|
|
|
|
to read any of the file; we handle what we could get from the
|
|
|
|
file. */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case CF_READ_ABORTED:
|
|
|
|
/* Exit by leaving the main loop, so that any quit functions
|
|
|
|
we registered get called. */
|
2022-06-29 08:44:30 +00:00
|
|
|
exit_application(0);
|
2017-11-29 00:03:11 +00:00
|
|
|
break;
|
|
|
|
}
|
2023-06-11 14:18:18 +00:00
|
|
|
} else if (((capture_file*)cap_session->cf)->state == FILE_READ_PENDING) {
|
2017-11-29 00:03:11 +00:00
|
|
|
/* first of all, we are not doing a capture any more */
|
|
|
|
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 */
|
|
|
|
if(capture_opts->save_file != NULL) {
|
|
|
|
capture_input_read_all(cap_session, cf_is_tempfile((capture_file *)cap_session->cf),
|
|
|
|
cf_get_drops_known((capture_file *)cap_session->cf), cf_get_drops((capture_file *)cap_session->cf));
|
|
|
|
}
|
2012-03-13 08:36:25 +00:00
|
|
|
}
|
2012-01-24 17:12:56 +00:00
|
|
|
}
|
2005-04-12 21:44:55 +00:00
|
|
|
|
2021-10-01 08:31:30 +00:00
|
|
|
capture_info_ui_destroy(&cap_session->cap_data_info->ui);
|
|
|
|
if(cap_session->wtap) {
|
|
|
|
wtap_close(cap_session->wtap);
|
|
|
|
cap_session->wtap = NULL;
|
2018-03-03 06:55:11 +00:00
|
|
|
}
|
2012-01-24 16:05:26 +00:00
|
|
|
|
2017-11-29 00:03:11 +00:00
|
|
|
cap_session->state = CAPTURE_STOPPED;
|
2012-01-24 16:05:26 +00:00
|
|
|
|
2017-11-29 00:03:11 +00:00
|
|
|
/* if we couldn't open a capture file, there's nothing more for us to do */
|
|
|
|
if(capture_opts->save_file == NULL) {
|
|
|
|
cf_close((capture_file *)cap_session->cf);
|
|
|
|
return;
|
|
|
|
}
|
2012-01-24 16:05:26 +00:00
|
|
|
|
2017-11-29 00:03:11 +00:00
|
|
|
/* does the user wants to restart the current capture? */
|
|
|
|
if(capture_opts->restart) {
|
|
|
|
capture_opts->restart = FALSE;
|
2012-01-25 13:04:32 +00:00
|
|
|
|
2017-11-29 00:03:11 +00:00
|
|
|
/* If we have a ring buffer, the original save file has been overwritten
|
|
|
|
with the "ring filename". Restore it before starting again */
|
|
|
|
if ((capture_opts->multi_files_on) && (capture_opts->orig_save_file != NULL)) {
|
|
|
|
g_free(capture_opts->save_file);
|
|
|
|
capture_opts->save_file = g_strdup(capture_opts->orig_save_file);
|
|
|
|
}
|
2019-02-24 13:08:03 +00:00
|
|
|
|
|
|
|
/* If it was a tempfile, throw away the old filename (so it will become a tempfile again) */
|
|
|
|
if (cf_is_tempfile((capture_file *)cap_session->cf)) {
|
|
|
|
g_free(capture_opts->save_file);
|
|
|
|
capture_opts->save_file = NULL;
|
|
|
|
}
|
2017-11-29 00:03:11 +00:00
|
|
|
} else {
|
2024-01-03 15:10:28 +00:00
|
|
|
|
|
|
|
/* If we're in multiple file mode, restore the original save file
|
|
|
|
name (template), so that it will be used if a new capture is started
|
|
|
|
without opening the Capture Options dialog. Any files we just wrote
|
|
|
|
won't get overwritten. If we set it to NULL, a tempfile name would
|
|
|
|
be used, but that doesn't work in multiple file mode - we could turn
|
|
|
|
off multiple file mode instead, but that would change the behavior
|
|
|
|
if the Capture Options dialog is re-opened. */
|
|
|
|
if ((capture_opts->multi_files_on) && (capture_opts->orig_save_file != NULL)) {
|
|
|
|
g_free(capture_opts->save_file);
|
|
|
|
capture_opts->save_file = g_strdup(capture_opts->orig_save_file);
|
|
|
|
} else {
|
|
|
|
/* We're not doing a capture any more, so we don't have a save file.
|
|
|
|
If a new capture is started without opening the Capture Options
|
|
|
|
dialog (Start button or double-clicking on an interface from
|
|
|
|
the welcome screen), we'll use a tempfile. Thus if our current
|
|
|
|
capture is to a permanent file, we won't overwrite it. */
|
|
|
|
g_free(capture_opts->save_file);
|
|
|
|
capture_opts->save_file = NULL;
|
|
|
|
}
|
2017-11-29 00:03:11 +00:00
|
|
|
}
|
2005-02-27 19:59:03 +00:00
|
|
|
}
|
|
|
|
|
2007-08-02 21:45:27 +00:00
|
|
|
if_stat_cache_t *
|
2017-11-29 00:03:11 +00:00
|
|
|
capture_stat_start(capture_options *capture_opts)
|
|
|
|
{
|
|
|
|
int stat_fd;
|
|
|
|
ws_process_id fork_child;
|
|
|
|
gchar *msg;
|
2018-12-13 17:42:23 +00:00
|
|
|
if_stat_cache_t *sc = g_new0(if_stat_cache_t, 1);
|
2017-11-29 00:03:11 +00:00
|
|
|
if_stat_cache_item_t *sc_item;
|
|
|
|
guint i;
|
|
|
|
interface_t *device;
|
|
|
|
|
2018-12-13 17:42:23 +00:00
|
|
|
sc->stat_fd = -1;
|
|
|
|
sc->fork_child = WS_INVALID_PID;
|
|
|
|
|
2017-11-29 00:03:11 +00:00
|
|
|
/* Fire up dumpcap. */
|
|
|
|
/*
|
|
|
|
* XXX - on systems with BPF, the number of BPF devices limits the
|
|
|
|
* number of devices on which you can capture simultaneously.
|
|
|
|
*
|
|
|
|
* This means that
|
|
|
|
*
|
|
|
|
* 1) this might fail if you run out of BPF devices
|
|
|
|
*
|
|
|
|
* and
|
|
|
|
*
|
|
|
|
* 2) opening every interface could leave too few BPF devices
|
|
|
|
* for *other* programs.
|
|
|
|
*
|
|
|
|
* It also means the system could end up getting a lot of traffic
|
|
|
|
* that it has to pass through the networking stack and capture
|
|
|
|
* mechanism, so opening all the devices and presenting packet
|
|
|
|
* counts might not always be a good idea.
|
|
|
|
*/
|
2023-12-18 15:34:39 +00:00
|
|
|
if (sync_interface_stats_open(&stat_fd, &fork_child, NULL, &msg, NULL) == 0) {
|
2017-11-29 00:03:11 +00:00
|
|
|
sc->stat_fd = stat_fd;
|
|
|
|
sc->fork_child = fork_child;
|
|
|
|
|
|
|
|
/* Initialize the cache */
|
|
|
|
for (i = 0; i < capture_opts->all_ifaces->len; i++) {
|
|
|
|
device = &g_array_index(capture_opts->all_ifaces, interface_t, i);
|
2024-01-13 12:38:26 +00:00
|
|
|
if (device->if_info.type != IF_PIPE && device->if_info.type != IF_EXTCAP) {
|
2020-12-21 02:30:28 +00:00
|
|
|
sc_item = g_new0(if_stat_cache_item_t, 1);
|
2021-06-18 18:21:42 +00:00
|
|
|
ws_assert(device->if_info.name);
|
2017-11-29 00:03:11 +00:00
|
|
|
sc_item->name = g_strdup(device->if_info.name);
|
2017-12-04 12:20:19 +00:00
|
|
|
sc->cache_list = g_list_prepend(sc->cache_list, sc_item);
|
2017-11-29 00:03:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2023-09-16 19:49:47 +00:00
|
|
|
ws_warning("%s", msg);
|
|
|
|
g_free(msg); /* XXX: should we display this to the user via the GUI? */
|
2007-08-02 21:45:27 +00:00
|
|
|
}
|
2017-11-29 00:03:11 +00:00
|
|
|
return sc;
|
2007-08-02 21:45:27 +00:00
|
|
|
}
|
|
|
|
|
2023-12-18 04:30:29 +00:00
|
|
|
if_stat_cache_t *
|
|
|
|
capture_interface_stat_start(capture_options *capture_opts _U_, GList **if_list)
|
|
|
|
{
|
|
|
|
int stat_fd;
|
|
|
|
ws_process_id fork_child;
|
|
|
|
gchar *msg;
|
|
|
|
if_stat_cache_t *sc = g_new0(if_stat_cache_t, 1);
|
|
|
|
if_stat_cache_item_t *sc_item;
|
|
|
|
char *data = NULL;
|
|
|
|
|
|
|
|
sc->stat_fd = -1;
|
|
|
|
sc->fork_child = WS_INVALID_PID;
|
|
|
|
|
|
|
|
/* Fire up dumpcap. */
|
|
|
|
/*
|
|
|
|
* XXX - on systems with BPF, the number of BPF devices limits the
|
|
|
|
* number of devices on which you can capture simultaneously.
|
|
|
|
*
|
|
|
|
* This means that
|
|
|
|
*
|
|
|
|
* 1) this might fail if you run out of BPF devices
|
|
|
|
*
|
|
|
|
* and
|
|
|
|
*
|
|
|
|
* 2) opening every interface could leave too few BPF devices
|
|
|
|
* for *other* programs.
|
|
|
|
*
|
|
|
|
* It also means the system could end up getting a lot of traffic
|
|
|
|
* that it has to pass through the networking stack and capture
|
|
|
|
* mechanism, so opening all the devices and presenting packet
|
|
|
|
* counts might not always be a good idea.
|
|
|
|
*/
|
|
|
|
int status;
|
|
|
|
status = sync_interface_stats_open(&stat_fd, &fork_child, &data, &msg, NULL);
|
|
|
|
/* In order to initialize the stat cache (below), we need to have
|
|
|
|
* filled in capture_opts->all_ifaces
|
|
|
|
*
|
|
|
|
* Note that the operation above can return a failed status but
|
|
|
|
* valid data, e.g. if dumpcap returns an interface list but none
|
|
|
|
* of them have permission to do a capture.
|
|
|
|
*/
|
|
|
|
int err = 0;
|
2024-01-10 05:31:44 +00:00
|
|
|
char *err_msg = NULL;
|
2023-12-18 04:30:29 +00:00
|
|
|
*if_list = deserialize_interface_list(data, &err, &err_msg);
|
|
|
|
if (err != 0) {
|
|
|
|
ws_info("%s", err_msg);
|
|
|
|
g_free(err_msg);
|
|
|
|
}
|
|
|
|
if (status == 0) {
|
|
|
|
sc->stat_fd = stat_fd;
|
|
|
|
sc->fork_child = fork_child;
|
|
|
|
|
|
|
|
/* Initialize the cache */
|
|
|
|
for (GList *if_entry = *if_list; if_entry != NULL; if_entry = g_list_next(if_entry)) {
|
|
|
|
if_info_t *if_info = (if_info_t*)if_entry->data;
|
|
|
|
/* We just got this list from dumpcap so it shouldn't
|
|
|
|
* contain stdin, pipes, extcaps, or remote interfaces
|
|
|
|
* list. We could test if_info->type and the name to
|
|
|
|
* exclude those types from the cache anyway, though.
|
|
|
|
*/
|
|
|
|
sc_item = g_new0(if_stat_cache_item_t, 1);
|
|
|
|
ws_assert(if_info->name);
|
|
|
|
sc_item->name = g_strdup(if_info->name);
|
|
|
|
sc->cache_list = g_list_prepend(sc->cache_list, sc_item);
|
|
|
|
}
|
2024-01-18 09:09:46 +00:00
|
|
|
} else if (status == WS_EXIT_NO_INTERFACES) {
|
|
|
|
/*
|
|
|
|
* No interfaces were found. If that's not the
|
|
|
|
* result of an error when fetching the local
|
|
|
|
* interfaces, let the user know.
|
|
|
|
*/
|
|
|
|
ws_info("%s", msg);
|
|
|
|
g_free(msg); /* XXX: should we display this to the user via the GUI? */
|
2023-12-18 04:30:29 +00:00
|
|
|
} else {
|
|
|
|
ws_warning("%s", msg);
|
|
|
|
g_free(msg); /* XXX: should we display this to the user via the GUI? */
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef HAVE_PCAP_REMOTE
|
|
|
|
*if_list = append_remote_list(*if_list);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
*if_list = append_extcap_interface_list(*if_list);
|
|
|
|
return sc;
|
|
|
|
}
|
|
|
|
|
2007-08-02 21:45:27 +00:00
|
|
|
#define MAX_STAT_LINE_LEN 500
|
|
|
|
|
|
|
|
static void
|
2017-11-29 00:03:11 +00:00
|
|
|
capture_stat_cache_update(if_stat_cache_t *sc)
|
|
|
|
{
|
|
|
|
gchar stat_line[MAX_STAT_LINE_LEN] = "";
|
|
|
|
gchar **stat_parts;
|
|
|
|
GList *sc_entry;
|
|
|
|
if_stat_cache_item_t *sc_item;
|
|
|
|
|
2018-12-13 17:42:23 +00:00
|
|
|
if (!sc || sc->fork_child == WS_INVALID_PID) {
|
2017-11-29 00:03:11 +00:00
|
|
|
return;
|
2018-12-13 17:42:23 +00:00
|
|
|
}
|
2017-11-29 00:03:11 +00:00
|
|
|
|
|
|
|
while (sync_pipe_gets_nonblock(sc->stat_fd, stat_line, MAX_STAT_LINE_LEN) > 0) {
|
|
|
|
g_strstrip(stat_line);
|
|
|
|
stat_parts = g_strsplit(stat_line, "\t", 3);
|
|
|
|
if (stat_parts[0] == NULL || stat_parts[1] == NULL ||
|
|
|
|
stat_parts[2] == NULL) {
|
|
|
|
g_strfreev(stat_parts);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
for (sc_entry = sc->cache_list; sc_entry != NULL; sc_entry = g_list_next(sc_entry)) {
|
|
|
|
sc_item = (if_stat_cache_item_t *)sc_entry->data;
|
|
|
|
if (strcmp(sc_item->name, stat_parts[0]) == 0) {
|
|
|
|
sc_item->ps.ps_recv = (u_int) strtoul(stat_parts[1], NULL, 10);
|
|
|
|
sc_item->ps.ps_drop = (u_int) strtoul(stat_parts[2], NULL, 10);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
g_strfreev(stat_parts);
|
2007-08-02 21:45:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
gboolean
|
2017-11-29 00:03:11 +00:00
|
|
|
capture_stats(if_stat_cache_t *sc, char *ifname, struct pcap_stat *ps)
|
|
|
|
{
|
|
|
|
GList *sc_entry;
|
|
|
|
if_stat_cache_item_t *sc_item;
|
2007-08-02 21:45:27 +00:00
|
|
|
|
2018-12-13 17:42:23 +00:00
|
|
|
if (!sc || sc->fork_child == WS_INVALID_PID || !ifname || !ps) {
|
2017-11-29 00:03:11 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
capture_stat_cache_update(sc);
|
|
|
|
for (sc_entry = sc->cache_list; sc_entry != NULL; sc_entry = g_list_next(sc_entry)) {
|
|
|
|
sc_item = (if_stat_cache_item_t *)sc_entry->data;
|
|
|
|
if (strcmp(sc_item->name, ifname) == 0) {
|
|
|
|
memcpy(ps, &sc_item->ps, sizeof(struct pcap_stat));
|
|
|
|
return TRUE;
|
|
|
|
}
|
2007-08-02 21:45:27 +00:00
|
|
|
}
|
2017-11-29 00:03:11 +00:00
|
|
|
return FALSE;
|
2007-08-02 21:45:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-11-29 00:03:11 +00:00
|
|
|
capture_stat_stop(if_stat_cache_t *sc)
|
|
|
|
{
|
|
|
|
GList *sc_entry;
|
|
|
|
if_stat_cache_item_t *sc_item;
|
|
|
|
int ret;
|
|
|
|
gchar *msg;
|
|
|
|
|
2019-01-31 16:49:33 +00:00
|
|
|
if (!sc) {
|
2017-11-29 00:03:11 +00:00
|
|
|
return;
|
2018-12-13 17:42:23 +00:00
|
|
|
}
|
2017-11-29 00:03:11 +00:00
|
|
|
|
2019-01-31 16:49:33 +00:00
|
|
|
if (sc->fork_child != WS_INVALID_PID) {
|
|
|
|
ret = sync_interface_stats_close(&sc->stat_fd, &sc->fork_child, &msg);
|
|
|
|
if (ret == -1) {
|
|
|
|
/* XXX - report failure? */
|
|
|
|
g_free(msg);
|
|
|
|
}
|
2017-11-29 00:03:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (sc_entry = sc->cache_list; sc_entry != NULL; sc_entry = g_list_next(sc_entry)) {
|
|
|
|
sc_item = (if_stat_cache_item_t *)sc_entry->data;
|
|
|
|
g_free(sc_item->name);
|
|
|
|
g_free(sc_item);
|
|
|
|
}
|
|
|
|
g_list_free(sc->cache_list);
|
|
|
|
g_free(sc);
|
2007-08-02 21:45:27 +00:00
|
|
|
}
|
2005-02-27 19:59:03 +00:00
|
|
|
|
2020-03-25 22:33:01 +00:00
|
|
|
/* Initialize a capture session for our callbacks. */
|
|
|
|
void
|
|
|
|
capture_input_init(capture_session *cap_session, capture_file *cf)
|
|
|
|
{
|
|
|
|
capture_session_init(cap_session, cf,
|
|
|
|
capture_input_new_file, capture_input_new_packets,
|
|
|
|
capture_input_drops, capture_input_error,
|
|
|
|
capture_input_cfilter_error, capture_input_closed);
|
|
|
|
}
|
1999-07-09 04:18:36 +00:00
|
|
|
#endif /* HAVE_LIBPCAP */
|