2005-02-23 01:01:19 +00:00
|
|
|
/* capture_opts.c
|
|
|
|
* Routines for capture options setting
|
|
|
|
*
|
2006-05-21 05:12:17 +00:00
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
2005-02-23 01:01:19 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
2012-06-28 22:56:06 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
2005-02-23 01:01:19 +00:00
|
|
|
*/
|
|
|
|
|
2014-08-22 21:13:05 +00:00
|
|
|
#include <config.h>
|
2005-02-23 01:01:19 +00:00
|
|
|
|
2012-11-21 17:33:02 +00:00
|
|
|
#include <stdio.h>
|
2013-12-03 22:16:49 +00:00
|
|
|
#include <stdlib.h>
|
2012-11-21 17:33:02 +00:00
|
|
|
|
2005-02-23 01:01:19 +00:00
|
|
|
#ifdef HAVE_LIBPCAP
|
|
|
|
|
2005-02-24 05:39:59 +00:00
|
|
|
#include <string.h>
|
|
|
|
|
2015-11-04 08:45:54 +00:00
|
|
|
#include <errno.h>
|
|
|
|
|
2005-02-23 01:01:19 +00:00
|
|
|
#include <glib.h>
|
|
|
|
|
2005-12-03 19:32:54 +00:00
|
|
|
#include "capture_opts.h"
|
2005-02-23 01:01:19 +00:00
|
|
|
#include "ringbuffer.h"
|
|
|
|
|
2014-06-29 21:37:21 +00:00
|
|
|
#include <wsutil/clopts_common.h>
|
|
|
|
#include <wsutil/cmdarg_err.h>
|
2008-05-22 15:46:27 +00:00
|
|
|
#include <wsutil/file_util.h>
|
2005-12-13 22:48:58 +00:00
|
|
|
|
2014-07-04 07:24:02 +00:00
|
|
|
#include "caputils/capture_ifinfo.h"
|
|
|
|
#include "caputils/capture-pcap-util.h"
|
|
|
|
|
2014-12-20 22:13:05 +00:00
|
|
|
#include "filter_files.h"
|
|
|
|
|
2006-02-10 02:05:30 +00:00
|
|
|
static gboolean capture_opts_output_to_pipe(const char *save_file, gboolean *is_pipe);
|
2006-01-07 01:29:45 +00:00
|
|
|
|
2005-12-13 22:48:58 +00:00
|
|
|
|
2005-02-23 01:01:19 +00:00
|
|
|
void
|
2013-05-22 07:44:28 +00:00
|
|
|
capture_opts_init(capture_options *capture_opts)
|
2005-02-23 01:01:19 +00:00
|
|
|
{
|
2014-10-12 18:56:12 +00:00
|
|
|
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->num_selected = 0;
|
|
|
|
capture_opts->default_options.name = NULL;
|
|
|
|
capture_opts->default_options.descr = NULL;
|
|
|
|
capture_opts->default_options.cfilter = NULL;
|
|
|
|
capture_opts->default_options.has_snaplen = FALSE;
|
|
|
|
capture_opts->default_options.snaplen = WTAP_MAX_PACKET_SIZE;
|
|
|
|
capture_opts->default_options.linktype = -1; /* use interface default */
|
|
|
|
capture_opts->default_options.promisc_mode = TRUE;
|
|
|
|
capture_opts->default_options.if_type = IF_WIRED;
|
2014-02-25 13:05:11 +00:00
|
|
|
#ifdef HAVE_EXTCAP
|
2014-10-12 18:56:12 +00:00
|
|
|
capture_opts->default_options.extcap = NULL;
|
|
|
|
capture_opts->default_options.extcap_fifo = NULL;
|
|
|
|
capture_opts->default_options.extcap_args = NULL;
|
2016-01-04 17:32:39 +00:00
|
|
|
capture_opts->default_options.extcap_userdata = NULL;
|
2014-10-12 18:56:12 +00:00
|
|
|
capture_opts->default_options.extcap_pid = INVALID_EXTCAP_PID;
|
2014-02-25 13:05:11 +00:00
|
|
|
#endif
|
2015-03-25 03:22:00 +00:00
|
|
|
#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
|
2014-10-12 18:56:12 +00:00
|
|
|
capture_opts->default_options.buffer_size = DEFAULT_CAPTURE_BUFFER_SIZE;
|
2011-05-16 14:12:35 +00:00
|
|
|
#endif
|
2014-10-12 18:56:12 +00:00
|
|
|
capture_opts->default_options.monitor_mode = FALSE;
|
2011-05-16 15:19:54 +00:00
|
|
|
#ifdef HAVE_PCAP_REMOTE
|
2014-10-12 18:56:12 +00:00
|
|
|
capture_opts->default_options.src_type = CAPTURE_IFLOCAL;
|
|
|
|
capture_opts->default_options.remote_host = NULL;
|
|
|
|
capture_opts->default_options.remote_port = NULL;
|
|
|
|
capture_opts->default_options.auth_type = CAPTURE_AUTH_NULL;
|
|
|
|
capture_opts->default_options.auth_username = NULL;
|
|
|
|
capture_opts->default_options.auth_password = NULL;
|
|
|
|
capture_opts->default_options.datatx_udp = FALSE;
|
|
|
|
capture_opts->default_options.nocap_rpcap = TRUE;
|
|
|
|
capture_opts->default_options.nocap_local = FALSE;
|
2011-05-16 15:19:54 +00:00
|
|
|
#endif
|
2011-05-16 14:12:35 +00:00
|
|
|
#ifdef HAVE_PCAP_SETSAMPLING
|
2014-10-12 18:56:12 +00:00
|
|
|
capture_opts->default_options.sampling_method = CAPTURE_SAMP_NONE;
|
|
|
|
capture_opts->default_options.sampling_param = 0;
|
2011-05-12 16:54:16 +00:00
|
|
|
#endif
|
2014-10-12 18:56:12 +00:00
|
|
|
capture_opts->saving_to_file = FALSE;
|
|
|
|
capture_opts->save_file = NULL;
|
|
|
|
capture_opts->group_read_access = FALSE;
|
2011-06-17 17:52:31 +00:00
|
|
|
#ifdef PCAP_NG_DEFAULT
|
2014-10-12 18:56:12 +00:00
|
|
|
capture_opts->use_pcapng = TRUE; /* Save as pcap-ng by default */
|
2011-06-17 17:52:31 +00:00
|
|
|
#else
|
2014-10-12 18:56:12 +00:00
|
|
|
capture_opts->use_pcapng = FALSE; /* Save as pcap by default */
|
2011-06-17 17:52:31 +00:00
|
|
|
#endif
|
2014-10-12 18:56:12 +00:00
|
|
|
capture_opts->real_time_mode = TRUE;
|
|
|
|
capture_opts->show_info = TRUE;
|
|
|
|
capture_opts->restart = FALSE;
|
|
|
|
capture_opts->orig_save_file = NULL;
|
|
|
|
|
|
|
|
capture_opts->multi_files_on = FALSE;
|
|
|
|
capture_opts->has_file_duration = FALSE;
|
|
|
|
capture_opts->file_duration = 60; /* 1 min */
|
|
|
|
capture_opts->has_ring_num_files = FALSE;
|
|
|
|
capture_opts->ring_num_files = RINGBUFFER_MIN_NUM_FILES;
|
|
|
|
|
|
|
|
capture_opts->has_autostop_files = FALSE;
|
|
|
|
capture_opts->autostop_files = 1;
|
|
|
|
capture_opts->has_autostop_packets = FALSE;
|
|
|
|
capture_opts->autostop_packets = 0;
|
|
|
|
capture_opts->has_autostop_filesize = FALSE;
|
|
|
|
capture_opts->autostop_filesize = 1000; /* 1 MB */
|
|
|
|
capture_opts->has_autostop_duration = FALSE;
|
|
|
|
capture_opts->autostop_duration = 60; /* 1 min */
|
|
|
|
capture_opts->capture_comment = NULL;
|
|
|
|
|
|
|
|
capture_opts->output_to_pipe = FALSE;
|
|
|
|
capture_opts->capture_child = FALSE;
|
2005-02-23 01:01:19 +00:00
|
|
|
}
|
|
|
|
|
2017-01-25 09:16:35 +00:00
|
|
|
void
|
|
|
|
capture_opts_cleanup(capture_options *capture_opts)
|
|
|
|
{
|
2017-02-04 15:26:34 +00:00
|
|
|
if (!capture_opts)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (capture_opts->ifaces) {
|
|
|
|
g_array_free(capture_opts->ifaces, TRUE);
|
|
|
|
capture_opts->ifaces = NULL;
|
|
|
|
}
|
|
|
|
if (capture_opts->all_ifaces) {
|
|
|
|
g_array_free(capture_opts->all_ifaces, TRUE);
|
|
|
|
capture_opts->all_ifaces = NULL;
|
|
|
|
}
|
2017-01-25 09:16:35 +00:00
|
|
|
}
|
2005-03-28 00:19:02 +00:00
|
|
|
|
2005-05-26 17:50:27 +00:00
|
|
|
/* log content of capture_opts */
|
2005-03-28 00:19:02 +00:00
|
|
|
void
|
2005-05-26 17:50:27 +00:00
|
|
|
capture_opts_log(const char *log_domain, GLogLevelFlags log_level, capture_options *capture_opts) {
|
2011-05-16 00:55:04 +00:00
|
|
|
guint i;
|
2011-05-12 16:54:16 +00:00
|
|
|
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "CAPTURE OPTIONS :");
|
2011-05-12 16:54:16 +00:00
|
|
|
|
2011-05-16 00:55:04 +00:00
|
|
|
for (i = 0; i < capture_opts->ifaces->len; i++) {
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_options interface_opts;
|
|
|
|
|
|
|
|
interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
|
2012-08-15 08:08:17 +00:00
|
|
|
g_log(log_domain, log_level, "Interface name[%02d] : %s", i, interface_opts.name ? interface_opts.name : "(unspecified)");
|
2012-11-20 01:12:57 +00:00
|
|
|
g_log(log_domain, log_level, "Interface description[%02d] : %s", i, interface_opts.descr ? interface_opts.descr : "(unspecified)");
|
|
|
|
g_log(log_domain, log_level, "Console display name[%02d]: %s", i, interface_opts.console_display_name ? interface_opts.console_display_name : "(unspecified)");
|
2012-08-15 08:08:17 +00:00
|
|
|
g_log(log_domain, log_level, "Capture filter[%02d] : %s", i, interface_opts.cfilter ? interface_opts.cfilter : "(unspecified)");
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "Snap length[%02d] (%u) : %d", i, interface_opts.has_snaplen, interface_opts.snaplen);
|
|
|
|
g_log(log_domain, log_level, "Link Type[%02d] : %d", i, interface_opts.linktype);
|
2011-06-30 23:34:53 +00:00
|
|
|
g_log(log_domain, log_level, "Promiscuous Mode[%02d]: %s", i, interface_opts.promisc_mode?"TRUE":"FALSE");
|
2014-02-25 13:05:11 +00:00
|
|
|
#ifdef HAVE_EXTCAP
|
|
|
|
g_log(log_domain, log_level, "Extcap[%02d] : %s", i, interface_opts.extcap ? interface_opts.extcap : "(unspecified)");
|
|
|
|
g_log(log_domain, log_level, "Extcap FIFO[%02d] : %s", i, interface_opts.extcap_fifo ? interface_opts.extcap_fifo : "(unspecified)");
|
|
|
|
g_log(log_domain, log_level, "Extcap PID[%02d] : %d", i, interface_opts.extcap_pid);
|
|
|
|
#endif
|
2015-03-25 03:22:00 +00:00
|
|
|
#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "Buffer size[%02d] : %d (MB)", i, interface_opts.buffer_size);
|
2011-05-16 14:12:35 +00:00
|
|
|
#endif
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "Monitor Mode[%02d] : %s", i, interface_opts.monitor_mode?"TRUE":"FALSE");
|
2011-05-16 15:19:54 +00:00
|
|
|
#ifdef HAVE_PCAP_REMOTE
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "Capture source[%02d] : %s", i,
|
2011-05-16 15:19:54 +00:00
|
|
|
interface_opts.src_type == CAPTURE_IFLOCAL ? "Local interface" :
|
|
|
|
interface_opts.src_type == CAPTURE_IFREMOTE ? "Remote interface" :
|
|
|
|
"Unknown");
|
|
|
|
if (interface_opts.src_type == CAPTURE_IFREMOTE) {
|
2012-08-15 08:08:17 +00:00
|
|
|
g_log(log_domain, log_level, "Remote host[%02d] : %s", i, interface_opts.remote_host ? interface_opts.remote_host : "(unspecified)");
|
|
|
|
g_log(log_domain, log_level, "Remote port[%02d] : %s", i, interface_opts.remote_port ? interface_opts.remote_port : "(unspecified)");
|
2011-05-16 15:19:54 +00:00
|
|
|
}
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "Authentication[%02d] : %s", i,
|
2011-05-16 15:19:54 +00:00
|
|
|
interface_opts.auth_type == CAPTURE_AUTH_NULL ? "Null" :
|
|
|
|
interface_opts.auth_type == CAPTURE_AUTH_PWD ? "By username/password" :
|
|
|
|
"Unknown");
|
|
|
|
if (interface_opts.auth_type == CAPTURE_AUTH_PWD) {
|
2012-08-15 08:08:17 +00:00
|
|
|
g_log(log_domain, log_level, "Auth username[%02d] : %s", i, interface_opts.auth_username ? interface_opts.auth_username : "(unspecified)");
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "Auth password[%02d] : <hidden>", i);
|
2011-05-16 15:19:54 +00:00
|
|
|
}
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "UDP data tfer[%02d] : %u", i, interface_opts.datatx_udp);
|
|
|
|
g_log(log_domain, log_level, "No cap. RPCAP[%02d] : %u", i, interface_opts.nocap_rpcap);
|
|
|
|
g_log(log_domain, log_level, "No cap. local[%02d] : %u", i, interface_opts.nocap_local);
|
2011-05-16 15:19:54 +00:00
|
|
|
#endif
|
2011-05-16 14:12:35 +00:00
|
|
|
#ifdef HAVE_PCAP_SETSAMPLING
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "Sampling meth.[%02d] : %d", i, interface_opts.sampling_method);
|
|
|
|
g_log(log_domain, log_level, "Sampling param.[%02d] : %d", i, interface_opts.sampling_param);
|
2011-05-12 16:54:16 +00:00
|
|
|
#endif
|
|
|
|
}
|
2012-08-15 08:08:17 +00:00
|
|
|
g_log(log_domain, log_level, "Interface name[df] : %s", capture_opts->default_options.name ? capture_opts->default_options.name : "(unspecified)");
|
|
|
|
g_log(log_domain, log_level, "Interface Descr[df] : %s", capture_opts->default_options.descr ? capture_opts->default_options.descr : "(unspecified)");
|
|
|
|
g_log(log_domain, log_level, "Capture filter[df] : %s", capture_opts->default_options.cfilter ? capture_opts->default_options.cfilter : "(unspecified)");
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "Snap length[df] (%u) : %d", capture_opts->default_options.has_snaplen, capture_opts->default_options.snaplen);
|
|
|
|
g_log(log_domain, log_level, "Link Type[df] : %d", capture_opts->default_options.linktype);
|
2011-06-30 22:21:16 +00:00
|
|
|
g_log(log_domain, log_level, "Promiscuous Mode[df]: %s", capture_opts->default_options.promisc_mode?"TRUE":"FALSE");
|
2014-02-25 13:05:11 +00:00
|
|
|
#ifdef HAVE_EXTCAP
|
|
|
|
g_log(log_domain, log_level, "Extcap[df] : %s", capture_opts->default_options.extcap ? capture_opts->default_options.extcap : "(unspecified)");
|
|
|
|
g_log(log_domain, log_level, "Extcap FIFO[df] : %s", capture_opts->default_options.extcap_fifo ? capture_opts->default_options.extcap_fifo : "(unspecified)");
|
|
|
|
#endif
|
2015-03-25 03:22:00 +00:00
|
|
|
#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "Buffer size[df] : %d (MB)", capture_opts->default_options.buffer_size);
|
2011-05-16 14:12:35 +00:00
|
|
|
#endif
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "Monitor Mode[df] : %s", capture_opts->default_options.monitor_mode?"TRUE":"FALSE");
|
2011-05-16 15:19:54 +00:00
|
|
|
#ifdef HAVE_PCAP_REMOTE
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "Capture source[df] : %s",
|
2011-05-16 15:19:54 +00:00
|
|
|
capture_opts->default_options.src_type == CAPTURE_IFLOCAL ? "Local interface" :
|
|
|
|
capture_opts->default_options.src_type == CAPTURE_IFREMOTE ? "Remote interface" :
|
|
|
|
"Unknown");
|
|
|
|
if (capture_opts->default_options.src_type == CAPTURE_IFREMOTE) {
|
2012-08-15 08:08:17 +00:00
|
|
|
g_log(log_domain, log_level, "Remote host[df] : %s", capture_opts->default_options.remote_host ? capture_opts->default_options.remote_host : "(unspecified)");
|
|
|
|
g_log(log_domain, log_level, "Remote port[df] : %s", capture_opts->default_options.remote_port ? capture_opts->default_options.remote_port : "(unspecified)");
|
2011-05-16 15:19:54 +00:00
|
|
|
}
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "Authentication[df] : %s",
|
2011-05-16 15:19:54 +00:00
|
|
|
capture_opts->default_options.auth_type == CAPTURE_AUTH_NULL ? "Null" :
|
|
|
|
capture_opts->default_options.auth_type == CAPTURE_AUTH_PWD ? "By username/password" :
|
|
|
|
"Unknown");
|
|
|
|
if (capture_opts->default_options.auth_type == CAPTURE_AUTH_PWD) {
|
2012-08-15 08:08:17 +00:00
|
|
|
g_log(log_domain, log_level, "Auth username[df] : %s", capture_opts->default_options.auth_username ? capture_opts->default_options.auth_username : "(unspecified)");
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "Auth password[df] : <hidden>");
|
2011-05-16 15:19:54 +00:00
|
|
|
}
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "UDP data tfer[df] : %u", capture_opts->default_options.datatx_udp);
|
|
|
|
g_log(log_domain, log_level, "No cap. RPCAP[df] : %u", capture_opts->default_options.nocap_rpcap);
|
|
|
|
g_log(log_domain, log_level, "No cap. local[df] : %u", capture_opts->default_options.nocap_local);
|
2011-05-16 15:19:54 +00:00
|
|
|
#endif
|
2011-05-16 14:12:35 +00:00
|
|
|
#ifdef HAVE_PCAP_SETSAMPLING
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "Sampling meth. [df] : %d", capture_opts->default_options.sampling_method);
|
|
|
|
g_log(log_domain, log_level, "Sampling param.[df] : %d", capture_opts->default_options.sampling_param);
|
2011-05-16 14:12:35 +00:00
|
|
|
#endif
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "SavingToFile : %u", capture_opts->saving_to_file);
|
|
|
|
g_log(log_domain, log_level, "SaveFile : %s", (capture_opts->save_file) ? capture_opts->save_file : "");
|
|
|
|
g_log(log_domain, log_level, "GroupReadAccess : %u", capture_opts->group_read_access);
|
|
|
|
g_log(log_domain, log_level, "Fileformat : %s", (capture_opts->use_pcapng) ? "PCAPNG" : "PCAP");
|
|
|
|
g_log(log_domain, log_level, "RealTimeMode : %u", capture_opts->real_time_mode);
|
|
|
|
g_log(log_domain, log_level, "ShowInfo : %u", capture_opts->show_info);
|
|
|
|
|
|
|
|
g_log(log_domain, log_level, "MultiFilesOn : %u", capture_opts->multi_files_on);
|
|
|
|
g_log(log_domain, log_level, "FileDuration (%u) : %u", capture_opts->has_file_duration, capture_opts->file_duration);
|
|
|
|
g_log(log_domain, log_level, "RingNumFiles (%u) : %u", capture_opts->has_ring_num_files, capture_opts->ring_num_files);
|
|
|
|
|
|
|
|
g_log(log_domain, log_level, "AutostopFiles (%u) : %u", capture_opts->has_autostop_files, capture_opts->autostop_files);
|
|
|
|
g_log(log_domain, log_level, "AutostopPackets (%u) : %u", capture_opts->has_autostop_packets, capture_opts->autostop_packets);
|
2013-12-02 19:17:12 +00:00
|
|
|
g_log(log_domain, log_level, "AutostopFilesize(%u) : %u (KB)", capture_opts->has_autostop_filesize, capture_opts->autostop_filesize);
|
2011-06-30 22:41:54 +00:00
|
|
|
g_log(log_domain, log_level, "AutostopDuration(%u) : %u", capture_opts->has_autostop_duration, capture_opts->autostop_duration);
|
2005-03-28 00:19:02 +00:00
|
|
|
}
|
|
|
|
|
2005-02-23 01:01:19 +00:00
|
|
|
/*
|
|
|
|
* Given a string of the form "<autostop criterion>:<value>", as might appear
|
|
|
|
* as an argument to a "-a" option, parse it and set the criterion in
|
|
|
|
* question. Return an indication of whether it succeeded or failed
|
|
|
|
* in some fashion.
|
|
|
|
*/
|
|
|
|
static gboolean
|
2005-11-17 05:59:21 +00:00
|
|
|
set_autostop_criterion(capture_options *capture_opts, const char *autostoparg)
|
2005-02-23 01:01:19 +00:00
|
|
|
{
|
2014-10-12 18:56:12 +00:00
|
|
|
gchar *p, *colonp;
|
|
|
|
|
|
|
|
colonp = strchr(autostoparg, ':');
|
|
|
|
if (colonp == NULL)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
p = colonp;
|
|
|
|
*p++ = '\0';
|
|
|
|
|
2005-02-23 01:01:19 +00:00
|
|
|
/*
|
2014-10-12 18:56:12 +00:00
|
|
|
* Skip over any white space (there probably won't be any, but
|
|
|
|
* as we allow it in the preferences file, we might as well
|
|
|
|
* allow it here).
|
2005-02-23 01:01:19 +00:00
|
|
|
*/
|
2014-10-17 23:57:28 +00:00
|
|
|
while (g_ascii_isspace(*p))
|
2014-10-12 18:56:12 +00:00
|
|
|
p++;
|
|
|
|
if (*p == '\0') {
|
|
|
|
/*
|
|
|
|
* Put the colon back, so if our caller uses, in an
|
|
|
|
* error message, the string they passed us, the message
|
|
|
|
* looks correct.
|
|
|
|
*/
|
|
|
|
*colonp = ':';
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
if (strcmp(autostoparg,"duration") == 0) {
|
|
|
|
capture_opts->has_autostop_duration = TRUE;
|
|
|
|
capture_opts->autostop_duration = get_positive_int(p,"autostop duration");
|
|
|
|
} else if (strcmp(autostoparg,"filesize") == 0) {
|
|
|
|
capture_opts->has_autostop_filesize = TRUE;
|
2016-09-11 20:48:35 +00:00
|
|
|
capture_opts->autostop_filesize = get_nonzero_guint32(p,"autostop filesize");
|
2014-10-12 18:56:12 +00:00
|
|
|
} else if (strcmp(autostoparg,"files") == 0) {
|
|
|
|
capture_opts->multi_files_on = TRUE;
|
|
|
|
capture_opts->has_autostop_files = TRUE;
|
|
|
|
capture_opts->autostop_files = get_positive_int(p,"autostop files");
|
|
|
|
} else {
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
*colonp = ':'; /* put the colon back */
|
|
|
|
return TRUE;
|
2005-02-23 01:01:19 +00:00
|
|
|
}
|
|
|
|
|
2014-12-20 22:13:05 +00:00
|
|
|
static gboolean get_filter_arguments(capture_options* capture_opts, const char* arg)
|
|
|
|
{
|
|
|
|
char* colonp;
|
|
|
|
char* val;
|
|
|
|
char* filter_exp = NULL;
|
|
|
|
|
|
|
|
colonp = strchr(arg, ':');
|
|
|
|
if (colonp) {
|
|
|
|
val = colonp;
|
|
|
|
*val = '\0';
|
|
|
|
val++;
|
|
|
|
if (strcmp(arg, "predef") == 0) {
|
|
|
|
GList* filterItem;
|
|
|
|
|
|
|
|
filterItem = get_filter_list_first(CFILTER_LIST);
|
|
|
|
while (filterItem != NULL) {
|
|
|
|
filter_def *filterDef;
|
|
|
|
|
|
|
|
filterDef = (filter_def*)filterItem->data;
|
|
|
|
if (strcmp(val, filterDef->name) == 0) {
|
|
|
|
filter_exp = g_strdup(filterDef->strval);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
filterItem = filterItem->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (filter_exp == NULL) {
|
|
|
|
/* No filter expression found yet; fallback to previous implemention
|
|
|
|
and assume the arg contains a filter expression */
|
|
|
|
if (colonp) {
|
|
|
|
*colonp = ':'; /* restore colon */
|
|
|
|
}
|
|
|
|
filter_exp = g_strdup(arg);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (capture_opts->ifaces->len > 0) {
|
|
|
|
interface_options interface_opts;
|
|
|
|
|
|
|
|
interface_opts = g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1);
|
|
|
|
capture_opts->ifaces = g_array_remove_index(capture_opts->ifaces, capture_opts->ifaces->len - 1);
|
|
|
|
g_free(interface_opts.cfilter);
|
|
|
|
interface_opts.cfilter = filter_exp;
|
|
|
|
g_array_append_val(capture_opts->ifaces, interface_opts);
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
g_free(capture_opts->default_options.cfilter);
|
|
|
|
capture_opts->default_options.cfilter = filter_exp;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-02-23 01:01:19 +00:00
|
|
|
/*
|
|
|
|
* Given a string of the form "<ring buffer file>:<duration>", as might appear
|
|
|
|
* as an argument to a "-b" option, parse it and set the arguments in
|
|
|
|
* question. Return an indication of whether it succeeded or failed
|
|
|
|
* in some fashion.
|
|
|
|
*/
|
|
|
|
static gboolean
|
2005-11-17 05:59:21 +00:00
|
|
|
get_ring_arguments(capture_options *capture_opts, const char *arg)
|
2005-02-23 01:01:19 +00:00
|
|
|
{
|
2014-10-12 18:56:12 +00:00
|
|
|
gchar *p = NULL, *colonp;
|
|
|
|
|
|
|
|
colonp = strchr(arg, ':');
|
|
|
|
if (colonp == NULL)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
p = colonp;
|
|
|
|
*p++ = '\0';
|
|
|
|
|
2005-02-23 01:01:19 +00:00
|
|
|
/*
|
2014-10-12 18:56:12 +00:00
|
|
|
* Skip over any white space (there probably won't be any, but
|
|
|
|
* as we allow it in the preferences file, we might as well
|
|
|
|
* allow it here).
|
2005-02-23 01:01:19 +00:00
|
|
|
*/
|
2014-10-17 23:57:28 +00:00
|
|
|
while (g_ascii_isspace(*p))
|
2014-10-12 18:56:12 +00:00
|
|
|
p++;
|
|
|
|
if (*p == '\0') {
|
|
|
|
/*
|
|
|
|
* Put the colon back, so if our caller uses, in an
|
|
|
|
* error message, the string they passed us, the message
|
|
|
|
* looks correct.
|
|
|
|
*/
|
|
|
|
*colonp = ':';
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(arg,"files") == 0) {
|
|
|
|
capture_opts->has_ring_num_files = TRUE;
|
2016-09-11 20:48:35 +00:00
|
|
|
capture_opts->ring_num_files = get_nonzero_guint32(p, "number of ring buffer files");
|
2014-10-12 18:56:12 +00:00
|
|
|
} else if (strcmp(arg,"filesize") == 0) {
|
|
|
|
capture_opts->has_autostop_filesize = TRUE;
|
2016-09-11 20:48:35 +00:00
|
|
|
capture_opts->autostop_filesize = get_nonzero_guint32(p, "ring buffer filesize");
|
2014-10-12 18:56:12 +00:00
|
|
|
} else if (strcmp(arg,"duration") == 0) {
|
|
|
|
capture_opts->has_file_duration = TRUE;
|
|
|
|
capture_opts->file_duration = get_positive_int(p, "ring buffer duration");
|
|
|
|
}
|
|
|
|
|
|
|
|
*colonp = ':'; /* put the colon back */
|
|
|
|
return TRUE;
|
2005-02-23 01:01:19 +00:00
|
|
|
}
|
|
|
|
|
2007-12-04 11:19:29 +00:00
|
|
|
#ifdef HAVE_PCAP_SETSAMPLING
|
|
|
|
/*
|
|
|
|
* Given a string of the form "<sampling type>:<value>", as might appear
|
|
|
|
* as an argument to a "-m" option, parse it and set the arguments in
|
|
|
|
* question. Return an indication of whether it succeeded or failed
|
|
|
|
* in some fashion.
|
|
|
|
*/
|
|
|
|
static gboolean
|
|
|
|
get_sampling_arguments(capture_options *capture_opts, const char *arg)
|
|
|
|
{
|
|
|
|
gchar *p = NULL, *colonp;
|
|
|
|
|
|
|
|
colonp = strchr(arg, ':');
|
|
|
|
if (colonp == NULL)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
p = colonp;
|
|
|
|
*p++ = '\0';
|
|
|
|
|
2014-10-17 23:57:28 +00:00
|
|
|
while (g_ascii_isspace(*p))
|
2007-12-04 11:19:29 +00:00
|
|
|
p++;
|
|
|
|
if (*p == '\0') {
|
|
|
|
*colonp = ':';
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(arg, "count") == 0) {
|
2011-05-16 14:12:35 +00:00
|
|
|
if (capture_opts->ifaces->len > 0) {
|
|
|
|
interface_options interface_opts;
|
|
|
|
|
|
|
|
interface_opts = g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1);
|
|
|
|
capture_opts->ifaces = g_array_remove_index(capture_opts->ifaces, capture_opts->ifaces->len - 1);
|
|
|
|
interface_opts.sampling_method = CAPTURE_SAMP_BY_COUNT;
|
|
|
|
interface_opts.sampling_param = get_positive_int(p, "sampling count");
|
|
|
|
g_array_append_val(capture_opts->ifaces, interface_opts);
|
|
|
|
} else {
|
|
|
|
capture_opts->default_options.sampling_method = CAPTURE_SAMP_BY_COUNT;
|
|
|
|
capture_opts->default_options.sampling_param = get_positive_int(p, "sampling count");
|
|
|
|
}
|
2007-12-04 11:19:29 +00:00
|
|
|
} else if (strcmp(arg, "timer") == 0) {
|
2011-05-16 14:12:35 +00:00
|
|
|
if (capture_opts->ifaces->len > 0) {
|
|
|
|
interface_options interface_opts;
|
|
|
|
|
|
|
|
interface_opts = g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1);
|
|
|
|
capture_opts->ifaces = g_array_remove_index(capture_opts->ifaces, capture_opts->ifaces->len - 1);
|
|
|
|
interface_opts.sampling_method = CAPTURE_SAMP_BY_TIMER;
|
|
|
|
interface_opts.sampling_param = get_positive_int(p, "sampling timer");
|
|
|
|
g_array_append_val(capture_opts->ifaces, interface_opts);
|
|
|
|
} else {
|
2011-06-27 00:09:03 +00:00
|
|
|
capture_opts->default_options.sampling_method = CAPTURE_SAMP_BY_TIMER;
|
2011-05-16 14:12:35 +00:00
|
|
|
capture_opts->default_options.sampling_param = get_positive_int(p, "sampling timer");
|
|
|
|
}
|
2007-12-04 11:19:29 +00:00
|
|
|
}
|
|
|
|
*colonp = ':';
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_PCAP_REMOTE
|
|
|
|
/*
|
|
|
|
* Given a string of the form "<username>:<password>", as might appear
|
|
|
|
* as an argument to a "-A" option, parse it and set the arguments in
|
|
|
|
* question. Return an indication of whether it succeeded or failed
|
|
|
|
* in some fashion.
|
|
|
|
*/
|
|
|
|
static gboolean
|
|
|
|
get_auth_arguments(capture_options *capture_opts, const char *arg)
|
|
|
|
{
|
|
|
|
gchar *p = NULL, *colonp;
|
|
|
|
|
|
|
|
colonp = strchr(arg, ':');
|
|
|
|
if (colonp == NULL)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
p = colonp;
|
|
|
|
*p++ = '\0';
|
|
|
|
|
2014-10-17 23:57:28 +00:00
|
|
|
while (g_ascii_isspace(*p))
|
2007-12-04 11:19:29 +00:00
|
|
|
p++;
|
|
|
|
|
2011-05-16 15:19:54 +00:00
|
|
|
if (capture_opts->ifaces->len > 0) {
|
|
|
|
interface_options interface_opts;
|
|
|
|
|
|
|
|
interface_opts = g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1);
|
|
|
|
capture_opts->ifaces = g_array_remove_index(capture_opts->ifaces, capture_opts->ifaces->len - 1);
|
|
|
|
interface_opts.auth_type = CAPTURE_AUTH_PWD;
|
|
|
|
interface_opts.auth_username = g_strdup(arg);
|
|
|
|
interface_opts.auth_password = g_strdup(p);
|
|
|
|
g_array_append_val(capture_opts->ifaces, interface_opts);
|
|
|
|
} else {
|
|
|
|
capture_opts->default_options.auth_type = CAPTURE_AUTH_PWD;
|
|
|
|
capture_opts->default_options.auth_username = g_strdup(arg);
|
|
|
|
capture_opts->default_options.auth_password = g_strdup(p);
|
|
|
|
}
|
2007-12-04 11:19:29 +00:00
|
|
|
*colonp = ':';
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
#endif
|
2005-02-23 01:01:19 +00:00
|
|
|
|
2012-03-12 02:53:21 +00:00
|
|
|
static int
|
2010-01-29 16:09:25 +00:00
|
|
|
capture_opts_add_iface_opt(capture_options *capture_opts, const char *optarg_str_p)
|
2005-12-13 22:48:58 +00:00
|
|
|
{
|
|
|
|
long adapter_index;
|
|
|
|
char *p;
|
|
|
|
GList *if_list;
|
|
|
|
if_info_t *if_info;
|
|
|
|
int err;
|
2007-01-21 23:45:36 +00:00
|
|
|
gchar *err_str;
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_options interface_opts;
|
2005-12-13 22:48:58 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the argument is a number, treat it as an index into the list
|
2006-05-31 17:38:42 +00:00
|
|
|
* of adapters, as printed by "tshark -D".
|
2005-12-13 22:48:58 +00:00
|
|
|
*
|
|
|
|
* This should be OK on UNIX systems, as interfaces shouldn't have
|
|
|
|
* names that begin with digits. It can be useful on Windows, where
|
|
|
|
* more than one interface can have the same name.
|
|
|
|
*/
|
2010-01-29 16:09:25 +00:00
|
|
|
adapter_index = strtol(optarg_str_p, &p, 10);
|
2005-12-13 22:48:58 +00:00
|
|
|
if (p != NULL && *p == '\0') {
|
2011-05-12 10:58:14 +00:00
|
|
|
if (adapter_index < 0) {
|
|
|
|
cmdarg_err("The specified adapter index is a negative number");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (adapter_index > INT_MAX) {
|
|
|
|
cmdarg_err("The specified adapter index is too large (greater than %d)",
|
|
|
|
INT_MAX);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (adapter_index == 0) {
|
|
|
|
cmdarg_err("There is no interface with that adapter index");
|
|
|
|
return 1;
|
|
|
|
}
|
2013-06-27 17:27:41 +00:00
|
|
|
if_list = capture_interface_list(&err, &err_str, NULL);
|
2012-11-21 18:11:57 +00:00
|
|
|
if (if_list == NULL) {
|
2014-07-22 23:53:18 +00:00
|
|
|
if (err == 0)
|
|
|
|
cmdarg_err("There are no interfaces on which a capture can be done");
|
|
|
|
else {
|
2012-11-21 18:11:57 +00:00
|
|
|
cmdarg_err("%s", err_str);
|
|
|
|
g_free(err_str);
|
|
|
|
}
|
|
|
|
return 2;
|
|
|
|
}
|
2012-12-26 05:57:06 +00:00
|
|
|
if_info = (if_info_t *)g_list_nth_data(if_list, (int)(adapter_index - 1));
|
2011-05-12 10:58:14 +00:00
|
|
|
if (if_info == NULL) {
|
|
|
|
cmdarg_err("There is no interface with that adapter index");
|
|
|
|
return 1;
|
2005-12-13 22:48:58 +00:00
|
|
|
}
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_opts.name = g_strdup(if_info->name);
|
2012-11-20 01:12:57 +00:00
|
|
|
if (if_info->friendly_name != NULL) {
|
|
|
|
/*
|
|
|
|
* We have a friendly name for the interface, so display that
|
|
|
|
* instead of the interface name/guid.
|
|
|
|
*
|
|
|
|
* XXX - on UN*X, the interface name is not quite so ugly,
|
|
|
|
* and might be more familiar to users; display them both?
|
|
|
|
*/
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
interface_opts.console_display_name = g_strdup(if_info->friendly_name);
|
2012-11-20 01:12:57 +00:00
|
|
|
} else {
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
/* fallback to the interface name */
|
|
|
|
interface_opts.console_display_name = g_strdup(if_info->name);
|
|
|
|
}
|
2015-04-11 19:49:48 +00:00
|
|
|
interface_opts.if_type = if_info->type;
|
|
|
|
#ifdef HAVE_EXTCAP
|
|
|
|
interface_opts.extcap = g_strdup(if_info->extcap);
|
|
|
|
#endif
|
2012-11-21 18:11:57 +00:00
|
|
|
free_interface_list(if_list);
|
2013-06-04 04:36:19 +00:00
|
|
|
} else if (capture_opts->capture_child) {
|
|
|
|
/* In Wireshark capture child mode, thus proper device name is supplied. */
|
|
|
|
/* No need for trying to match it for friendly names. */
|
|
|
|
interface_opts.name = g_strdup(optarg_str_p);
|
|
|
|
interface_opts.console_display_name = g_strdup(optarg_str_p);
|
2015-04-11 19:49:48 +00:00
|
|
|
interface_opts.if_type = capture_opts->default_options.if_type;
|
|
|
|
#ifdef HAVE_EXTCAP
|
|
|
|
interface_opts.extcap = g_strdup(capture_opts->default_options.extcap);
|
|
|
|
#endif
|
2005-12-13 22:48:58 +00:00
|
|
|
} else {
|
2012-11-21 18:11:57 +00:00
|
|
|
/*
|
|
|
|
* Retrieve the interface list so that we can search for the
|
|
|
|
* specified option amongst both the interface names and the
|
|
|
|
* friendly names and so that we find the friendly name even
|
|
|
|
* if an interface name was specified.
|
|
|
|
*
|
|
|
|
* If we can't get the list, just use the specified option as
|
|
|
|
* the interface name, so that the user can try specifying an
|
|
|
|
* interface explicitly for testing purposes.
|
|
|
|
*/
|
2013-06-27 17:27:41 +00:00
|
|
|
if_list = capture_interface_list(&err, NULL, NULL);
|
2012-11-21 18:11:57 +00:00
|
|
|
if (if_list != NULL) {
|
|
|
|
/* try and do an exact match (case insensitive) */
|
|
|
|
GList *if_entry;
|
|
|
|
gboolean matched;
|
|
|
|
|
|
|
|
matched = FALSE;
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
for (if_entry = g_list_first(if_list); if_entry != NULL;
|
2012-11-19 21:00:44 +00:00
|
|
|
if_entry = g_list_next(if_entry))
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
{
|
|
|
|
if_info = (if_info_t *)if_entry->data;
|
2012-11-21 18:11:57 +00:00
|
|
|
/* exact name check */
|
|
|
|
if (g_ascii_strcasecmp(if_info->name, optarg_str_p) == 0) {
|
|
|
|
/* exact match on the interface name, use that for displaying etc */
|
|
|
|
interface_opts.name = g_strdup(if_info->name);
|
|
|
|
|
|
|
|
if (if_info->friendly_name != NULL) {
|
|
|
|
/*
|
|
|
|
* If we have a friendly name, use that for the
|
|
|
|
* console display name, as it is the basis for
|
|
|
|
* the auto generated temp filename.
|
|
|
|
*/
|
|
|
|
interface_opts.console_display_name = g_strdup(if_info->friendly_name);
|
|
|
|
} else {
|
|
|
|
interface_opts.console_display_name = g_strdup(if_info->name);
|
|
|
|
}
|
2015-04-11 19:49:48 +00:00
|
|
|
interface_opts.if_type = if_info->type;
|
|
|
|
#ifdef HAVE_EXTCAP
|
|
|
|
interface_opts.extcap = g_strdup(if_info->extcap);
|
|
|
|
#endif
|
2012-11-21 18:11:57 +00:00
|
|
|
matched = TRUE;
|
|
|
|
break;
|
|
|
|
}
|
2012-11-19 21:00:44 +00:00
|
|
|
|
2012-11-21 18:11:57 +00:00
|
|
|
/* exact friendly name check */
|
2012-11-20 01:12:57 +00:00
|
|
|
if (if_info->friendly_name != NULL &&
|
2012-11-21 18:11:57 +00:00
|
|
|
g_ascii_strcasecmp(if_info->friendly_name, optarg_str_p) == 0) {
|
|
|
|
/* exact match - use the friendly name for display */
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
interface_opts.name = g_strdup(if_info->name);
|
|
|
|
interface_opts.console_display_name = g_strdup(if_info->friendly_name);
|
2015-04-11 19:49:48 +00:00
|
|
|
interface_opts.if_type = if_info->type;
|
|
|
|
#ifdef HAVE_EXTCAP
|
|
|
|
interface_opts.extcap = g_strdup(if_info->extcap);
|
|
|
|
#endif
|
2012-11-20 01:12:57 +00:00
|
|
|
matched = TRUE;
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2012-11-21 18:11:57 +00:00
|
|
|
|
|
|
|
/* didn't find, attempt a case insensitive prefix match of the friendly name*/
|
|
|
|
if (!matched) {
|
|
|
|
size_t prefix_length;
|
|
|
|
|
|
|
|
prefix_length = strlen(optarg_str_p);
|
|
|
|
for (if_entry = g_list_first(if_list); if_entry != NULL;
|
|
|
|
if_entry = g_list_next(if_entry))
|
|
|
|
{
|
|
|
|
if_info = (if_info_t *)if_entry->data;
|
|
|
|
|
|
|
|
if (if_info->friendly_name != NULL &&
|
|
|
|
g_ascii_strncasecmp(if_info->friendly_name, optarg_str_p, prefix_length) == 0) {
|
|
|
|
/* prefix match - use the friendly name for display */
|
|
|
|
interface_opts.name = g_strdup(if_info->name);
|
|
|
|
interface_opts.console_display_name = g_strdup(if_info->friendly_name);
|
2015-04-11 19:49:48 +00:00
|
|
|
interface_opts.if_type = if_info->type;
|
|
|
|
#ifdef HAVE_EXTCAP
|
|
|
|
interface_opts.extcap = g_strdup(if_info->extcap);
|
|
|
|
#endif
|
2012-11-21 18:11:57 +00:00
|
|
|
matched = TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!matched) {
|
|
|
|
/*
|
|
|
|
* We didn't find the interface in the list; just use
|
|
|
|
* the specified name, so that, for example, if an
|
|
|
|
* interface doesn't show up in the list for some
|
|
|
|
* reason, the user can try specifying it explicitly
|
|
|
|
* for testing purposes.
|
|
|
|
*/
|
|
|
|
interface_opts.name = g_strdup(optarg_str_p);
|
|
|
|
interface_opts.console_display_name = g_strdup(optarg_str_p);
|
2015-04-11 19:49:48 +00:00
|
|
|
interface_opts.if_type = capture_opts->default_options.if_type;
|
|
|
|
#ifdef HAVE_EXTCAP
|
|
|
|
interface_opts.extcap = g_strdup(capture_opts->default_options.extcap);
|
|
|
|
#endif
|
2012-11-21 18:11:57 +00:00
|
|
|
}
|
|
|
|
free_interface_list(if_list);
|
|
|
|
} else {
|
2012-11-21 17:33:02 +00:00
|
|
|
interface_opts.name = g_strdup(optarg_str_p);
|
|
|
|
interface_opts.console_display_name = g_strdup(optarg_str_p);
|
2015-04-11 19:49:48 +00:00
|
|
|
interface_opts.if_type = capture_opts->default_options.if_type;
|
|
|
|
#ifdef HAVE_EXTCAP
|
|
|
|
interface_opts.extcap = g_strdup(capture_opts->default_options.extcap);
|
|
|
|
#endif
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
}
|
2011-05-16 14:12:35 +00:00
|
|
|
}
|
2012-11-19 21:00:44 +00:00
|
|
|
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
/* We don't set iface_descr here because doing so requires
|
|
|
|
* capture_ui_utils.c which requires epan/prefs.c which is
|
|
|
|
* probably a bit too much dependency for here...
|
|
|
|
*/
|
2011-07-21 17:30:42 +00:00
|
|
|
interface_opts.descr = g_strdup(capture_opts->default_options.descr);
|
|
|
|
interface_opts.cfilter = g_strdup(capture_opts->default_options.cfilter);
|
|
|
|
interface_opts.snaplen = capture_opts->default_options.snaplen;
|
|
|
|
interface_opts.has_snaplen = capture_opts->default_options.has_snaplen;
|
|
|
|
interface_opts.linktype = capture_opts->default_options.linktype;
|
|
|
|
interface_opts.promisc_mode = capture_opts->default_options.promisc_mode;
|
2014-02-25 13:05:11 +00:00
|
|
|
#ifdef HAVE_EXTCAP
|
|
|
|
interface_opts.extcap_fifo = g_strdup(capture_opts->default_options.extcap_fifo);
|
|
|
|
interface_opts.extcap_args = NULL;
|
2014-10-03 17:27:04 +00:00
|
|
|
interface_opts.extcap_pid = INVALID_EXTCAP_PID;
|
2016-06-28 19:34:46 +00:00
|
|
|
interface_opts.extcap_userdata = NULL;
|
2014-02-25 13:05:11 +00:00
|
|
|
#endif
|
2015-03-25 03:22:00 +00:00
|
|
|
#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
|
2011-07-21 17:30:42 +00:00
|
|
|
interface_opts.buffer_size = capture_opts->default_options.buffer_size;
|
2011-05-16 14:12:35 +00:00
|
|
|
#endif
|
2011-07-21 17:30:42 +00:00
|
|
|
interface_opts.monitor_mode = capture_opts->default_options.monitor_mode;
|
2011-05-16 15:19:54 +00:00
|
|
|
#ifdef HAVE_PCAP_REMOTE
|
2011-07-21 17:30:42 +00:00
|
|
|
interface_opts.src_type = capture_opts->default_options.src_type;
|
|
|
|
interface_opts.remote_host = g_strdup(capture_opts->default_options.remote_host);
|
|
|
|
interface_opts.remote_port = g_strdup(capture_opts->default_options.remote_port);
|
|
|
|
interface_opts.auth_type = capture_opts->default_options.auth_type;
|
|
|
|
interface_opts.auth_username = g_strdup(capture_opts->default_options.auth_username);
|
|
|
|
interface_opts.auth_password = g_strdup(capture_opts->default_options.auth_password);
|
|
|
|
interface_opts.datatx_udp = capture_opts->default_options.datatx_udp;
|
|
|
|
interface_opts.nocap_rpcap = capture_opts->default_options.nocap_rpcap;
|
|
|
|
interface_opts.nocap_local = capture_opts->default_options.nocap_local;
|
2011-05-16 15:19:54 +00:00
|
|
|
#endif
|
2011-05-16 14:12:35 +00:00
|
|
|
#ifdef HAVE_PCAP_SETSAMPLING
|
2011-07-21 17:30:42 +00:00
|
|
|
interface_opts.sampling_method = capture_opts->default_options.sampling_method;
|
|
|
|
interface_opts.sampling_param = capture_opts->default_options.sampling_param;
|
2011-05-12 16:54:16 +00:00
|
|
|
#endif
|
|
|
|
|
2011-07-21 17:30:42 +00:00
|
|
|
g_array_append_val(capture_opts->ifaces, interface_opts);
|
|
|
|
|
2006-02-10 02:05:30 +00:00
|
|
|
return 0;
|
2005-12-13 22:48:58 +00:00
|
|
|
}
|
|
|
|
|
2012-01-25 13:04:32 +00:00
|
|
|
|
2006-02-10 02:05:30 +00:00
|
|
|
int
|
2010-01-29 16:09:25 +00:00
|
|
|
capture_opts_add_opt(capture_options *capture_opts, int opt, const char *optarg_str_p, gboolean *start_capture)
|
2005-04-10 16:43:22 +00:00
|
|
|
{
|
2011-06-27 00:09:03 +00:00
|
|
|
int status, snaplen;
|
2006-02-10 02:05:30 +00:00
|
|
|
|
2005-02-23 01:01:19 +00:00
|
|
|
switch(opt) {
|
2013-07-27 16:25:08 +00:00
|
|
|
case LONGOPT_NUM_CAP_COMMENT: /* capture comment */
|
2013-07-27 16:28:03 +00:00
|
|
|
if (capture_opts->capture_comment) {
|
|
|
|
cmdarg_err("--capture-comment can be set only once per file");
|
|
|
|
return 1;
|
|
|
|
}
|
2013-07-27 16:25:08 +00:00
|
|
|
capture_opts->capture_comment = g_strdup(optarg_str_p);
|
|
|
|
break;
|
2005-02-23 01:01:19 +00:00
|
|
|
case 'a': /* autostop criteria */
|
2010-01-29 16:09:25 +00:00
|
|
|
if (set_autostop_criterion(capture_opts, optarg_str_p) == FALSE) {
|
2011-05-12 10:58:14 +00:00
|
|
|
cmdarg_err("Invalid or unknown -a flag \"%s\"", optarg_str_p);
|
|
|
|
return 1;
|
2005-02-23 01:01:19 +00:00
|
|
|
}
|
|
|
|
break;
|
2007-12-04 11:19:29 +00:00
|
|
|
#ifdef HAVE_PCAP_REMOTE
|
|
|
|
case 'A':
|
2010-01-29 16:09:25 +00:00
|
|
|
if (get_auth_arguments(capture_opts, optarg_str_p) == FALSE) {
|
|
|
|
cmdarg_err("Invalid or unknown -A arg \"%s\"", optarg_str_p);
|
2007-12-04 11:19:29 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif
|
2005-02-23 01:01:19 +00:00
|
|
|
case 'b': /* Ringbuffer option */
|
|
|
|
capture_opts->multi_files_on = TRUE;
|
2010-01-29 16:09:25 +00:00
|
|
|
if (get_ring_arguments(capture_opts, optarg_str_p) == FALSE) {
|
2011-05-12 10:58:14 +00:00
|
|
|
cmdarg_err("Invalid or unknown -b arg \"%s\"", optarg_str_p);
|
|
|
|
return 1;
|
2005-02-23 01:01:19 +00:00
|
|
|
}
|
|
|
|
break;
|
2015-03-25 03:22:00 +00:00
|
|
|
#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
|
2005-05-30 04:46:25 +00:00
|
|
|
case 'B': /* Buffer size */
|
2011-05-16 00:55:04 +00:00
|
|
|
if (capture_opts->ifaces->len > 0) {
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_options interface_opts;
|
2011-05-12 16:54:16 +00:00
|
|
|
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_opts = g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1);
|
2011-05-16 00:55:04 +00:00
|
|
|
capture_opts->ifaces = g_array_remove_index(capture_opts->ifaces, capture_opts->ifaces->len - 1);
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_opts.buffer_size = get_positive_int(optarg_str_p, "buffer size");
|
|
|
|
g_array_append_val(capture_opts->ifaces, interface_opts);
|
2011-05-12 16:54:16 +00:00
|
|
|
} else {
|
|
|
|
capture_opts->default_options.buffer_size = get_positive_int(optarg_str_p, "buffer size");
|
|
|
|
}
|
2005-05-30 04:46:25 +00:00
|
|
|
break;
|
|
|
|
#endif
|
2006-03-24 02:40:59 +00:00
|
|
|
case 'c': /* Capture n packets */
|
2005-02-23 01:01:19 +00:00
|
|
|
capture_opts->has_autostop_packets = TRUE;
|
2010-01-29 16:09:25 +00:00
|
|
|
capture_opts->autostop_packets = get_positive_int(optarg_str_p, "packet count");
|
2005-02-23 01:01:19 +00:00
|
|
|
break;
|
|
|
|
case 'f': /* capture filter */
|
2014-12-20 22:13:05 +00:00
|
|
|
get_filter_arguments(capture_opts, optarg_str_p);
|
2005-02-23 01:01:19 +00:00
|
|
|
break;
|
2012-12-12 03:25:35 +00:00
|
|
|
case 'g': /* enable group read access on the capture file(s) */
|
|
|
|
capture_opts->group_read_access = TRUE;
|
|
|
|
break;
|
2005-02-23 01:01:19 +00:00
|
|
|
case 'H': /* Hide capture info dialog box */
|
|
|
|
capture_opts->show_info = FALSE;
|
|
|
|
break;
|
2006-03-24 02:40:59 +00:00
|
|
|
case 'i': /* Use interface x */
|
2010-01-29 16:09:25 +00:00
|
|
|
status = capture_opts_add_iface_opt(capture_opts, optarg_str_p);
|
2011-03-01 17:29:09 +00:00
|
|
|
if (status != 0) {
|
2006-02-10 02:05:30 +00:00
|
|
|
return status;
|
|
|
|
}
|
2005-02-23 01:01:19 +00:00
|
|
|
break;
|
2010-05-07 01:25:53 +00:00
|
|
|
#ifdef HAVE_PCAP_CREATE
|
|
|
|
case 'I': /* Capture in monitor mode */
|
2011-05-16 00:55:04 +00:00
|
|
|
if (capture_opts->ifaces->len > 0) {
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_options interface_opts;
|
2011-05-12 16:54:16 +00:00
|
|
|
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_opts = g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1);
|
2011-05-16 00:55:04 +00:00
|
|
|
capture_opts->ifaces = g_array_remove_index(capture_opts->ifaces, capture_opts->ifaces->len - 1);
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_opts.monitor_mode = TRUE;
|
|
|
|
g_array_append_val(capture_opts->ifaces, interface_opts);
|
2011-05-12 16:54:16 +00:00
|
|
|
} else {
|
|
|
|
capture_opts->default_options.monitor_mode = TRUE;
|
|
|
|
}
|
2010-05-07 01:25:53 +00:00
|
|
|
break;
|
|
|
|
#endif
|
2005-02-23 01:01:19 +00:00
|
|
|
case 'k': /* Start capture immediately */
|
|
|
|
*start_capture = TRUE;
|
|
|
|
break;
|
|
|
|
/*case 'l':*/ /* Automatic scrolling in live capture mode */
|
2007-12-04 11:19:29 +00:00
|
|
|
#ifdef HAVE_PCAP_SETSAMPLING
|
|
|
|
case 'm':
|
2010-01-29 16:09:25 +00:00
|
|
|
if (get_sampling_arguments(capture_opts, optarg_str_p) == FALSE) {
|
|
|
|
cmdarg_err("Invalid or unknown -m arg \"%s\"", optarg_str_p);
|
2007-12-04 11:19:29 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
#endif
|
2009-04-27 08:11:10 +00:00
|
|
|
case 'n': /* Use pcapng format */
|
|
|
|
capture_opts->use_pcapng = TRUE;
|
|
|
|
break;
|
2005-02-23 01:01:19 +00:00
|
|
|
case 'p': /* Don't capture in promiscuous mode */
|
2011-05-16 00:55:04 +00:00
|
|
|
if (capture_opts->ifaces->len > 0) {
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_options interface_opts;
|
2011-05-12 16:54:16 +00:00
|
|
|
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_opts = g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1);
|
2011-05-16 00:55:04 +00:00
|
|
|
capture_opts->ifaces = g_array_remove_index(capture_opts->ifaces, capture_opts->ifaces->len - 1);
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_opts.promisc_mode = FALSE;
|
|
|
|
g_array_append_val(capture_opts->ifaces, interface_opts);
|
2011-05-12 16:54:16 +00:00
|
|
|
} else {
|
|
|
|
capture_opts->default_options.promisc_mode = FALSE;
|
|
|
|
}
|
2005-02-23 01:01:19 +00:00
|
|
|
break;
|
2011-06-17 17:52:31 +00:00
|
|
|
case 'P': /* Use pcap format */
|
|
|
|
capture_opts->use_pcapng = FALSE;
|
|
|
|
break;
|
2007-12-04 11:19:29 +00:00
|
|
|
#ifdef HAVE_PCAP_REMOTE
|
|
|
|
case 'r':
|
2011-05-16 15:19:54 +00:00
|
|
|
if (capture_opts->ifaces->len > 0) {
|
|
|
|
interface_options interface_opts;
|
|
|
|
|
|
|
|
interface_opts = g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1);
|
|
|
|
capture_opts->ifaces = g_array_remove_index(capture_opts->ifaces, capture_opts->ifaces->len - 1);
|
|
|
|
interface_opts.nocap_rpcap = FALSE;
|
|
|
|
g_array_append_val(capture_opts->ifaces, interface_opts);
|
|
|
|
} else {
|
|
|
|
capture_opts->default_options.nocap_rpcap = FALSE;
|
|
|
|
}
|
2007-12-04 11:19:29 +00:00
|
|
|
break;
|
|
|
|
#endif
|
2005-02-23 01:01:19 +00:00
|
|
|
case 's': /* Set the snapshot (capture) length */
|
2011-06-27 00:09:03 +00:00
|
|
|
snaplen = get_natural_int(optarg_str_p, "snapshot length");
|
2011-03-01 17:29:09 +00:00
|
|
|
/*
|
|
|
|
* Make a snapshot length of 0 equivalent to the maximum packet
|
|
|
|
* length, mirroring what tcpdump does.
|
|
|
|
*/
|
2011-06-27 00:09:03 +00:00
|
|
|
if (snaplen == 0)
|
|
|
|
snaplen = WTAP_MAX_PACKET_SIZE;
|
2011-05-16 00:55:04 +00:00
|
|
|
if (capture_opts->ifaces->len > 0) {
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_options interface_opts;
|
2011-05-12 16:54:16 +00:00
|
|
|
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_opts = g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1);
|
2011-05-16 00:55:04 +00:00
|
|
|
capture_opts->ifaces = g_array_remove_index(capture_opts->ifaces, capture_opts->ifaces->len - 1);
|
2011-06-27 00:09:03 +00:00
|
|
|
interface_opts.has_snaplen = TRUE;
|
|
|
|
interface_opts.snaplen = snaplen;
|
2011-05-16 14:12:35 +00:00
|
|
|
g_array_append_val(capture_opts->ifaces, interface_opts);
|
2011-05-12 16:54:16 +00:00
|
|
|
} else {
|
2011-06-27 00:09:03 +00:00
|
|
|
capture_opts->default_options.snaplen = snaplen;
|
|
|
|
capture_opts->default_options.has_snaplen = TRUE;
|
2011-05-12 16:54:16 +00:00
|
|
|
}
|
2005-02-23 01:01:19 +00:00
|
|
|
break;
|
2005-03-28 16:14:34 +00:00
|
|
|
case 'S': /* "Real-Time" mode: used for following file ala tail -f */
|
|
|
|
capture_opts->real_time_mode = TRUE;
|
2005-02-23 01:01:19 +00:00
|
|
|
break;
|
2007-12-04 11:19:29 +00:00
|
|
|
#ifdef HAVE_PCAP_REMOTE
|
|
|
|
case 'u':
|
2011-05-16 15:19:54 +00:00
|
|
|
if (capture_opts->ifaces->len > 0) {
|
|
|
|
interface_options interface_opts;
|
|
|
|
|
|
|
|
interface_opts = g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1);
|
|
|
|
capture_opts->ifaces = g_array_remove_index(capture_opts->ifaces, capture_opts->ifaces->len - 1);
|
|
|
|
interface_opts.datatx_udp = TRUE;
|
|
|
|
g_array_append_val(capture_opts->ifaces, interface_opts);
|
|
|
|
} else {
|
|
|
|
capture_opts->default_options.datatx_udp = TRUE;
|
|
|
|
}
|
2007-12-04 11:19:29 +00:00
|
|
|
break;
|
|
|
|
#endif
|
2006-03-24 02:40:59 +00:00
|
|
|
case 'w': /* Write to capture file x */
|
2006-04-03 00:52:59 +00:00
|
|
|
capture_opts->saving_to_file = TRUE;
|
2006-11-02 09:45:12 +00:00
|
|
|
g_free(capture_opts->save_file);
|
2011-07-11 22:51:46 +00:00
|
|
|
capture_opts->save_file = g_strdup(optarg_str_p);
|
2006-02-10 02:05:30 +00:00
|
|
|
status = capture_opts_output_to_pipe(capture_opts->save_file, &capture_opts->output_to_pipe);
|
|
|
|
return status;
|
2005-02-23 01:01:19 +00:00
|
|
|
case 'y': /* Set the pcap data link type */
|
2011-05-16 00:55:04 +00:00
|
|
|
if (capture_opts->ifaces->len > 0) {
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_options interface_opts;
|
2011-05-12 16:54:16 +00:00
|
|
|
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_opts = g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1);
|
2011-05-16 00:55:04 +00:00
|
|
|
capture_opts->ifaces = g_array_remove_index(capture_opts->ifaces, capture_opts->ifaces->len - 1);
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_opts.linktype = linktype_name_to_val(optarg_str_p);
|
2011-06-27 00:09:03 +00:00
|
|
|
if (interface_opts.linktype == -1) {
|
|
|
|
cmdarg_err("The specified data link type \"%s\" isn't valid",
|
|
|
|
optarg_str_p);
|
|
|
|
return 1;
|
|
|
|
}
|
2011-05-16 14:12:35 +00:00
|
|
|
g_array_append_val(capture_opts->ifaces, interface_opts);
|
2011-05-12 16:54:16 +00:00
|
|
|
} else {
|
|
|
|
capture_opts->default_options.linktype = linktype_name_to_val(optarg_str_p);
|
2011-06-27 00:09:03 +00:00
|
|
|
if (capture_opts->default_options.linktype == -1) {
|
|
|
|
cmdarg_err("The specified data link type \"%s\" isn't valid",
|
|
|
|
optarg_str_p);
|
|
|
|
return 1;
|
|
|
|
}
|
2011-05-12 16:54:16 +00:00
|
|
|
}
|
2005-02-23 01:01:19 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* the caller is responsible to send us only the right opt's */
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
2006-02-10 02:05:30 +00:00
|
|
|
|
|
|
|
return 0;
|
2005-02-23 01:01:19 +00:00
|
|
|
}
|
|
|
|
|
2010-05-07 08:06:25 +00:00
|
|
|
void
|
2011-05-13 11:28:51 +00:00
|
|
|
capture_opts_print_if_capabilities(if_capabilities_t *caps, char *name,
|
2010-05-13 17:37:39 +00:00
|
|
|
gboolean monitor_mode)
|
2005-12-13 22:48:58 +00:00
|
|
|
{
|
2010-05-07 08:06:25 +00:00
|
|
|
GList *lt_entry;
|
2005-12-13 22:48:58 +00:00
|
|
|
data_link_info_t *data_link_info;
|
|
|
|
|
2010-05-13 17:37:39 +00:00
|
|
|
if (caps->can_set_rfmon)
|
2013-04-25 05:47:11 +00:00
|
|
|
printf("Data link types of interface %s when %sin monitor mode (use option -y to set):\n",
|
|
|
|
name, monitor_mode ? "" : "not ");
|
2010-05-13 17:37:39 +00:00
|
|
|
else
|
2013-04-25 05:47:11 +00:00
|
|
|
printf("Data link types of interface %s (use option -y to set):\n", name);
|
2010-05-13 17:37:39 +00:00
|
|
|
for (lt_entry = caps->data_link_types; lt_entry != NULL;
|
2010-05-07 08:06:25 +00:00
|
|
|
lt_entry = g_list_next(lt_entry)) {
|
|
|
|
data_link_info = (data_link_info_t *)lt_entry->data;
|
2013-04-25 05:47:11 +00:00
|
|
|
printf(" %s", data_link_info->name);
|
2010-05-07 08:06:25 +00:00
|
|
|
if (data_link_info->description != NULL)
|
2013-04-25 05:47:11 +00:00
|
|
|
printf(" (%s)", data_link_info->description);
|
2010-05-07 08:06:25 +00:00
|
|
|
else
|
2013-04-25 05:47:11 +00:00
|
|
|
printf(" (not supported)");
|
|
|
|
printf("\n");
|
2005-12-13 22:48:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-07 19:24:32 +00:00
|
|
|
/* Print an ASCII-formatted list of interfaces. */
|
|
|
|
void
|
|
|
|
capture_opts_print_interfaces(GList *if_list)
|
2005-12-13 22:48:58 +00:00
|
|
|
{
|
2010-05-07 19:24:32 +00:00
|
|
|
int i;
|
2005-12-13 22:48:58 +00:00
|
|
|
GList *if_entry;
|
|
|
|
if_info_t *if_info;
|
|
|
|
|
|
|
|
i = 1; /* Interface id number */
|
|
|
|
for (if_entry = g_list_first(if_list); if_entry != NULL;
|
2010-03-04 01:12:04 +00:00
|
|
|
if_entry = g_list_next(if_entry)) {
|
2010-03-04 09:37:05 +00:00
|
|
|
if_info = (if_info_t *)if_entry->data;
|
2013-04-25 05:47:11 +00:00
|
|
|
printf("%d. %s", i++, if_info->name);
|
2007-06-11 03:58:58 +00:00
|
|
|
|
2012-11-22 06:02:49 +00:00
|
|
|
/* Print the interface friendly name, if it exists;
|
|
|
|
if not fall back to vendor description, if it exists. */
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
if (if_info->friendly_name != NULL){
|
2013-04-25 05:47:11 +00:00
|
|
|
printf(" (%s)", if_info->friendly_name);
|
2012-11-22 06:02:49 +00:00
|
|
|
} else {
|
|
|
|
if (if_info->vendor_description != NULL)
|
2013-04-25 05:47:11 +00:00
|
|
|
printf(" (%s)", if_info->vendor_description);
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
}
|
2013-04-25 05:47:11 +00:00
|
|
|
printf("\n");
|
2005-12-13 22:48:58 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-12-12 03:25:35 +00:00
|
|
|
void
|
|
|
|
capture_opts_trim_snaplen(capture_options *capture_opts, int snaplen_min)
|
2005-12-05 21:26:01 +00:00
|
|
|
{
|
2011-05-16 00:55:04 +00:00
|
|
|
guint i;
|
2011-05-16 14:12:35 +00:00
|
|
|
interface_options interface_opts;
|
2011-05-12 16:54:16 +00:00
|
|
|
|
2011-06-27 00:09:03 +00:00
|
|
|
if (capture_opts->ifaces->len > 0) {
|
|
|
|
for (i = 0; i < capture_opts->ifaces->len; i++) {
|
|
|
|
interface_opts = g_array_index(capture_opts->ifaces, interface_options, 0);
|
|
|
|
capture_opts->ifaces = g_array_remove_index(capture_opts->ifaces, 0);
|
|
|
|
if (interface_opts.snaplen < 1)
|
|
|
|
interface_opts.snaplen = WTAP_MAX_PACKET_SIZE;
|
|
|
|
else if (interface_opts.snaplen < snaplen_min)
|
|
|
|
interface_opts.snaplen = snaplen_min;
|
|
|
|
g_array_append_val(capture_opts->ifaces, interface_opts);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (capture_opts->default_options.snaplen < 1)
|
|
|
|
capture_opts->default_options.snaplen = WTAP_MAX_PACKET_SIZE;
|
|
|
|
else if (capture_opts->default_options.snaplen < snaplen_min)
|
|
|
|
capture_opts->default_options.snaplen = snaplen_min;
|
2011-05-12 16:54:16 +00:00
|
|
|
}
|
2005-12-13 22:48:58 +00:00
|
|
|
}
|
|
|
|
|
2005-12-05 21:26:01 +00:00
|
|
|
|
2012-12-12 03:25:35 +00:00
|
|
|
void
|
|
|
|
capture_opts_trim_ring_num_files(capture_options *capture_opts)
|
2005-12-13 22:48:58 +00:00
|
|
|
{
|
2011-05-12 10:58:14 +00:00
|
|
|
/* Check the value range of the ring_num_files parameter */
|
|
|
|
if (capture_opts->ring_num_files > RINGBUFFER_MAX_NUM_FILES) {
|
|
|
|
cmdarg_err("Too many ring buffer files (%u). Reducing to %u.\n", capture_opts->ring_num_files, RINGBUFFER_MAX_NUM_FILES);
|
|
|
|
capture_opts->ring_num_files = RINGBUFFER_MAX_NUM_FILES;
|
|
|
|
} else if (capture_opts->ring_num_files > RINGBUFFER_WARN_NUM_FILES) {
|
|
|
|
cmdarg_err("%u is a lot of ring buffer files.\n", capture_opts->ring_num_files);
|
|
|
|
}
|
2005-12-05 21:26:01 +00:00
|
|
|
#if RINGBUFFER_MIN_NUM_FILES > 0
|
2011-05-12 10:58:14 +00:00
|
|
|
else if (capture_opts->ring_num_files < RINGBUFFER_MIN_NUM_FILES)
|
|
|
|
cmdarg_err("Too few ring buffer files (%u). Increasing to %u.\n", capture_opts->ring_num_files, RINGBUFFER_MIN_NUM_FILES);
|
|
|
|
capture_opts->ring_num_files = RINGBUFFER_MIN_NUM_FILES;
|
2005-12-05 21:26:01 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2013-05-22 04:49:31 +00:00
|
|
|
/*
|
|
|
|
* If no interface was specified explicitly, pick a default.
|
|
|
|
*/
|
2012-11-21 17:14:54 +00:00
|
|
|
int
|
2013-05-22 04:49:31 +00:00
|
|
|
capture_opts_default_iface_if_necessary(capture_options *capture_opts,
|
|
|
|
const char *capture_device)
|
2005-12-13 22:48:58 +00:00
|
|
|
{
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
int status;
|
2005-12-13 22:48:58 +00:00
|
|
|
|
|
|
|
/* Did the user specify an interface to use? */
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
if (capture_opts->num_selected != 0 || capture_opts->ifaces->len != 0) {
|
2012-11-21 17:14:54 +00:00
|
|
|
/* yes they did, return immediately - nothing further to do here */
|
|
|
|
return 0;
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
}
|
2011-05-12 12:06:19 +00:00
|
|
|
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
/* No - is a default specified in the preferences file? */
|
|
|
|
if (capture_device != NULL) {
|
|
|
|
/* Yes - use it. */
|
2012-11-20 01:12:57 +00:00
|
|
|
status = capture_opts_add_iface_opt(capture_opts, capture_device);
|
2012-11-21 17:14:54 +00:00
|
|
|
return status;
|
2005-12-13 22:48:58 +00:00
|
|
|
}
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
/* No default in preferences file, just pick the first interface from the list of interfaces. */
|
2012-11-21 17:14:54 +00:00
|
|
|
return capture_opts_add_iface_opt(capture_opts, "1");
|
2005-12-13 22:48:58 +00:00
|
|
|
}
|
|
|
|
|
2006-01-07 01:29:45 +00:00
|
|
|
#ifndef S_IFIFO
|
2012-11-20 01:12:57 +00:00
|
|
|
#define S_IFIFO _S_IFIFO
|
2006-01-07 01:29:45 +00:00
|
|
|
#endif
|
|
|
|
#ifndef S_ISFIFO
|
|
|
|
#define S_ISFIFO(mode) (((mode) & S_IFMT) == S_IFIFO)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* copied from filesystem.c */
|
2012-12-12 03:25:35 +00:00
|
|
|
static int
|
|
|
|
capture_opts_test_for_fifo(const char *path)
|
2006-01-07 01:29:45 +00:00
|
|
|
{
|
2014-10-12 18:56:12 +00:00
|
|
|
ws_statb64 statb;
|
2006-01-07 01:29:45 +00:00
|
|
|
|
2014-10-12 18:56:12 +00:00
|
|
|
if (ws_stat64(path, &statb) < 0)
|
|
|
|
return errno;
|
2006-01-07 01:29:45 +00:00
|
|
|
|
2014-10-12 18:56:12 +00:00
|
|
|
if (S_ISFIFO(statb.st_mode))
|
|
|
|
return ESPIPE;
|
|
|
|
else
|
|
|
|
return 0;
|
2006-01-07 01:29:45 +00:00
|
|
|
}
|
|
|
|
|
2012-12-12 03:25:35 +00:00
|
|
|
static gboolean
|
|
|
|
capture_opts_output_to_pipe(const char *save_file, gboolean *is_pipe)
|
2006-01-07 01:29:45 +00:00
|
|
|
{
|
2014-10-12 18:56:12 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
*is_pipe = FALSE;
|
|
|
|
|
|
|
|
if (save_file != NULL) {
|
|
|
|
/* We're writing to a capture file. */
|
|
|
|
if (strcmp(save_file, "-") == 0) {
|
|
|
|
/* Writing to stdout. */
|
|
|
|
/* XXX - should we check whether it's a pipe? It's arguably
|
|
|
|
silly to do "-w - >output_file" rather than "-w output_file",
|
|
|
|
but by not checking we might be violating the Principle Of
|
|
|
|
Least Astonishment. */
|
|
|
|
*is_pipe = TRUE;
|
|
|
|
} else {
|
|
|
|
/* not writing to stdout, test for a FIFO (aka named pipe) */
|
|
|
|
err = capture_opts_test_for_fifo(save_file);
|
|
|
|
switch (err) {
|
|
|
|
|
|
|
|
case ENOENT: /* it doesn't exist, so we'll be creating it,
|
|
|
|
and it won't be a FIFO */
|
|
|
|
case 0: /* found it, but it's not a FIFO */
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ESPIPE: /* it is a FIFO */
|
|
|
|
*is_pipe = TRUE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default: /* couldn't stat it */
|
|
|
|
break; /* ignore: later attempt to open */
|
|
|
|
/* will generate a nice msg */
|
|
|
|
}
|
|
|
|
}
|
2006-01-07 01:29:45 +00:00
|
|
|
}
|
|
|
|
|
2014-10-12 18:56:12 +00:00
|
|
|
return 0;
|
2006-01-07 01:29:45 +00:00
|
|
|
}
|
|
|
|
|
2012-01-25 13:04:32 +00:00
|
|
|
void
|
2014-07-14 14:22:53 +00:00
|
|
|
capture_opts_del_iface(capture_options *capture_opts, guint if_index)
|
2012-01-25 13:04:32 +00:00
|
|
|
{
|
2014-10-12 18:56:12 +00:00
|
|
|
interface_options interface_opts;
|
2012-03-13 03:48:27 +00:00
|
|
|
|
2014-10-12 18:56:12 +00:00
|
|
|
interface_opts = g_array_index(capture_opts->ifaces, interface_options, if_index);
|
|
|
|
/* XXX - check if found? */
|
2014-07-04 22:18:07 +00:00
|
|
|
|
2012-03-13 03:48:27 +00:00
|
|
|
g_free(interface_opts.name);
|
|
|
|
g_free(interface_opts.descr);
|
2012-11-20 01:12:57 +00:00
|
|
|
if (interface_opts.console_display_name != NULL)
|
From Mike Garratt:
Friendly Names for interfaces on Windows
Notes on the changes the patch covers:
* if_info_t struct: addition of friendly_name
* Dumpcap Interface list format changes:
+ Win32: "dumpcap -D" shows friendly_name in place of descript if known
+ All: machine interface "dumpcap -D -Z none" includes friendly_name in the
list in addition to the existing parameters
* interface_options struct: addition of console_display_name
+ When an interface name is displayed in a console, it will typically be the
console_display_name (instead of name).
+ console_display_name is used as the basis of the autogenerated temp
filenames
+ console_display_name is typically set to the friendly_name if known,
otherwise it is set to the interface name
* Enhancements to capture_opts_add_iface_opt() (the function which process -i
options).
+ Can now specify the interface using its name and friendly_name
+ Interface name matching is case insenstive
+ Name matching first attempts exact matching, then falls back to prefix
matching
(e.g. dumpcap -i local)
+ Validates interface names, instead of blindly sending them off to
winpcap/libpcap
+ Interface specification by number is still supported.
* capture_opts_trim_iface() has been refactored:
+ Instead of repeating a decent chunk of the cost in
capture_opts_add_iface_opt(), it calls capture_opts_trim_iface() to specify the
interface.
* introduction of capture_win_ifnames.[ch] (windows only code)
+ Implements static function GetInterfaceFriendlyNameFromDeviceGuid() - a
windows version independant function to convert an interface guid into its
friendly name. Uses published api functions on windows vista and higher, but
falls back to unpublished API functions on older windows releases.
+ void get_windows_interface_friendlyname(/* IN */ char
*interface_devicename, /* OUT */char **interface_friendlyname); - extracts the
GUID from the interface_devicename, then uses
GetInterfaceFriendlyNameFromDeviceGuid() to do the resolution
* Auto temp filename generation:
+ Now uses wireshark_pcapng_* or wireshark_pcap_* depending on file format
+ Basis temp filename format on console_display_name
+ Win32: if console_display_name is a windows interface guid, extracts
numbers from GUID here (instead of in interface option processing)
GUI CHANGES:
* Dialog that displays when you click the "Manage Interfaces" button (within
Capture Options dialog) has been renamed from "Add new interfaces" to
"Interface Management"
* ui/gtk/capture_dlg.c: new_interfaces_w variable renamed to
interface_management_w
* Win32: Local Interfaces tab on Interface Management dialog, shows includes
friendly name as far left column
* Interface Management dialog defaults to larger size on win32 - so it fits
without resizing local interfaces tab
* Interface Management dialog now saves preferences when you click the apply
button (local hidden interfaces was not persisting across restarts)
* Tweaks: "Interface Details" dialog (Interface list->Capture Interfaces ->
Details):
+ "Friendly Name" renamed to "NDIS Friendly Name"
+ Added "OS Friendly Name" to the top of the list
* Win32: The "Capture Interfaces" dialog now shows the friendly name instead of
device guid
* Welcome screen:
+ The height of the interface list scrollbox dynamically adjusts & updates to
the number visible interfaces.
Up to 10 interfaces can be listed without a scroll bar, the minimum height
is for 2 interfaces.
+ Win32: now shows just the Friendly Name if known - in place of
"Interfacename_Guid:(Description)"
svn path=/trunk/; revision=46083
2012-11-19 20:07:27 +00:00
|
|
|
g_free(interface_opts.console_display_name);
|
2012-03-13 03:48:27 +00:00
|
|
|
g_free(interface_opts.cfilter);
|
2014-02-25 13:05:11 +00:00
|
|
|
#ifdef HAVE_EXTCAP
|
|
|
|
g_free(interface_opts.extcap);
|
|
|
|
g_free(interface_opts.extcap_fifo);
|
|
|
|
if (interface_opts.extcap_args)
|
|
|
|
g_hash_table_unref(interface_opts.extcap_args);
|
2014-10-03 17:27:04 +00:00
|
|
|
if (interface_opts.extcap_pid != INVALID_EXTCAP_PID)
|
2014-02-25 13:05:11 +00:00
|
|
|
g_spawn_close_pid(interface_opts.extcap_pid);
|
2016-06-28 19:34:46 +00:00
|
|
|
g_free(interface_opts.extcap_userdata);
|
2014-02-25 13:05:11 +00:00
|
|
|
#endif
|
2012-03-13 03:48:27 +00:00
|
|
|
#ifdef HAVE_PCAP_REMOTE
|
|
|
|
if (interface_opts.src_type == CAPTURE_IFREMOTE) {
|
2014-10-12 18:56:12 +00:00
|
|
|
g_free(interface_opts.remote_host);
|
|
|
|
g_free(interface_opts.remote_port);
|
|
|
|
g_free(interface_opts.auth_username);
|
|
|
|
g_free(interface_opts.auth_password);
|
2012-03-13 03:48:27 +00:00
|
|
|
}
|
|
|
|
#endif
|
2014-07-14 14:22:53 +00:00
|
|
|
capture_opts->ifaces = g_array_remove_index(capture_opts->ifaces, if_index);
|
2014-07-04 22:18:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add all non-hidden selected interfaces in the "all interfaces" list
|
|
|
|
* to the list of interfaces for the capture.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
collect_ifaces(capture_options *capture_opts)
|
|
|
|
{
|
2014-10-12 18:56:12 +00:00
|
|
|
guint i;
|
|
|
|
interface_t device;
|
|
|
|
interface_options interface_opts;
|
|
|
|
|
|
|
|
/* Empty out the existing list of interfaces. */
|
|
|
|
for (i = capture_opts->ifaces->len; i != 0; i--)
|
|
|
|
capture_opts_del_iface(capture_opts, i-1);
|
|
|
|
|
|
|
|
/* Now fill the list up again. */
|
|
|
|
for (i = 0; i < capture_opts->all_ifaces->len; i++) {
|
|
|
|
device = g_array_index(capture_opts->all_ifaces, interface_t, i);
|
|
|
|
if (!device.hidden && device.selected) {
|
|
|
|
interface_opts.name = g_strdup(device.name);
|
|
|
|
interface_opts.descr = g_strdup(device.display_name);
|
|
|
|
interface_opts.console_display_name = g_strdup(device.name);
|
|
|
|
interface_opts.linktype = device.active_dlt;
|
|
|
|
interface_opts.cfilter = g_strdup(device.cfilter);
|
|
|
|
interface_opts.snaplen = device.snaplen;
|
|
|
|
interface_opts.has_snaplen = device.has_snaplen;
|
|
|
|
interface_opts.promisc_mode = device.pmode;
|
|
|
|
interface_opts.if_type = device.if_info.type;
|
2014-02-25 13:05:11 +00:00
|
|
|
#ifdef HAVE_EXTCAP
|
2014-10-12 18:56:12 +00:00
|
|
|
interface_opts.extcap = g_strdup(device.if_info.extcap);
|
|
|
|
interface_opts.extcap_fifo = NULL;
|
2016-01-04 17:32:39 +00:00
|
|
|
interface_opts.extcap_userdata = NULL;
|
2014-10-12 18:56:12 +00:00
|
|
|
interface_opts.extcap_args = device.external_cap_args_settings;
|
|
|
|
interface_opts.extcap_pid = INVALID_EXTCAP_PID;
|
|
|
|
if (interface_opts.extcap_args)
|
|
|
|
g_hash_table_ref(interface_opts.extcap_args);
|
2016-06-28 19:34:46 +00:00
|
|
|
interface_opts.extcap_userdata = NULL;
|
2014-02-25 13:05:11 +00:00
|
|
|
#endif
|
2015-03-25 03:22:00 +00:00
|
|
|
#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
|
2014-10-12 18:56:12 +00:00
|
|
|
interface_opts.buffer_size = device.buffer;
|
2012-01-25 19:40:22 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_PCAP_CREATE
|
2014-10-12 18:56:12 +00:00
|
|
|
interface_opts.monitor_mode = device.monitor_mode_enabled;
|
2012-01-25 13:04:32 +00:00
|
|
|
#endif
|
2012-01-25 14:29:09 +00:00
|
|
|
#ifdef HAVE_PCAP_REMOTE
|
2014-10-12 18:56:12 +00:00
|
|
|
interface_opts.src_type = CAPTURE_IFREMOTE;
|
|
|
|
interface_opts.remote_host = g_strdup(device.remote_opts.remote_host_opts.remote_host);
|
|
|
|
interface_opts.remote_port = g_strdup(device.remote_opts.remote_host_opts.remote_port);
|
|
|
|
interface_opts.auth_type = device.remote_opts.remote_host_opts.auth_type;
|
|
|
|
interface_opts.auth_username = g_strdup(device.remote_opts.remote_host_opts.auth_username);
|
|
|
|
interface_opts.auth_password = g_strdup(device.remote_opts.remote_host_opts.auth_password);
|
|
|
|
interface_opts.datatx_udp = device.remote_opts.remote_host_opts.datatx_udp;
|
|
|
|
interface_opts.nocap_rpcap = device.remote_opts.remote_host_opts.nocap_rpcap;
|
|
|
|
interface_opts.nocap_local = device.remote_opts.remote_host_opts.nocap_local;
|
2012-01-25 13:04:32 +00:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_PCAP_SETSAMPLING
|
2014-10-12 18:56:12 +00:00
|
|
|
interface_opts.sampling_method = device.remote_opts.sampling_method;
|
|
|
|
interface_opts.sampling_param = device.remote_opts.sampling_param;
|
2012-01-25 13:04:32 +00:00
|
|
|
#endif
|
2014-10-12 18:56:12 +00:00
|
|
|
g_array_append_val(capture_opts->ifaces, interface_opts);
|
|
|
|
} else {
|
|
|
|
continue;
|
|
|
|
}
|
2012-01-25 13:04:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-26 08:27:51 +00:00
|
|
|
static void
|
|
|
|
capture_opts_free_interface_t_links(gpointer elem, gpointer unused _U_)
|
|
|
|
{
|
|
|
|
link_row* e = (link_row*)elem;
|
|
|
|
if (e != NULL)
|
|
|
|
g_free(e->name);
|
|
|
|
g_free(elem);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
capture_opts_free_interface_t_addrs(gpointer elem, gpointer unused _U_)
|
|
|
|
{
|
|
|
|
g_free(elem);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
capture_opts_free_interface_t(interface_t *device)
|
|
|
|
{
|
|
|
|
if (device != NULL) {
|
|
|
|
g_free(device->name);
|
|
|
|
g_free(device->display_name);
|
|
|
|
g_free(device->friendly_name);
|
|
|
|
g_free(device->addresses);
|
|
|
|
g_free(device->cfilter);
|
|
|
|
g_list_foreach(device->links,
|
|
|
|
capture_opts_free_interface_t_links, NULL);
|
|
|
|
g_list_free(device->links);
|
|
|
|
#ifdef HAVE_PCAP_REMOTE
|
|
|
|
g_free(device->remote_opts.remote_host_opts.remote_host);
|
|
|
|
g_free(device->remote_opts.remote_host_opts.remote_port);
|
|
|
|
g_free(device->remote_opts.remote_host_opts.auth_username);
|
|
|
|
g_free(device->remote_opts.remote_host_opts.auth_password);
|
|
|
|
#endif
|
|
|
|
g_free(device->if_info.name);
|
|
|
|
g_free(device->if_info.friendly_name);
|
|
|
|
g_free(device->if_info.vendor_description);
|
|
|
|
g_slist_foreach(device->if_info.addrs,
|
|
|
|
capture_opts_free_interface_t_addrs, NULL);
|
|
|
|
g_slist_free(device->if_info.addrs);
|
|
|
|
#ifdef HAVE_EXTCAP
|
|
|
|
g_free(device->if_info.extcap);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
2012-01-25 13:04:32 +00:00
|
|
|
|
2005-02-24 05:39:59 +00:00
|
|
|
#endif /* HAVE_LIBPCAP */
|
2014-10-12 18:56:12 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Editor modelines - http://www.wireshark.org/tools/modelines.html
|
|
|
|
*
|
|
|
|
* Local variables:
|
|
|
|
* c-basic-offset: 4
|
|
|
|
* tab-width: 8
|
|
|
|
* indent-tabs-mode: nil
|
|
|
|
* End:
|
|
|
|
*
|
|
|
|
* vi: set shiftwidth=4 tabstop=8 expandtab:
|
|
|
|
* :indentSize=4:tabSize=8:noTabs=true:
|
|
|
|
*/
|