X-Git-Url: http://git.samba.org/?p=metze%2Fwireshark%2Fwip.git;a=blobdiff_plain;f=capture_opts.c;h=16d44d197012d8dd1d301d45d2716bf6326f01be;hp=3b0f77c99e6050407b6423406e77fef51dc939d8;hb=ffb3328d1fb10f599bdd25e98f75c39acd2c0ed9;hpb=7c0c580c4b0093437ee81e11934ef5b8d27a5bb4 diff --git a/capture_opts.c b/capture_opts.c index 3b0f77c99e..16d44d1970 100644 --- a/capture_opts.c +++ b/capture_opts.c @@ -5,19 +5,7 @@ * By Gerald Combs * 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 - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + * SPDX-License-Identifier: GPL-2.0-or-later */ #include @@ -36,14 +24,15 @@ #include "capture_opts.h" #include "ringbuffer.h" -#include -#include +#include +#include #include +#include #include "caputils/capture_ifinfo.h" #include "caputils/capture-pcap-util.h" -#include "filter_files.h" +#include "ui/filter_files.h" static gboolean capture_opts_output_to_pipe(const char *save_file, gboolean *is_pipe); @@ -58,17 +47,22 @@ capture_opts_init(capture_options *capture_opts) 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.snaplen = WTAP_MAX_PACKET_SIZE_STANDARD; capture_opts->default_options.linktype = -1; /* use interface default */ capture_opts->default_options.promisc_mode = TRUE; capture_opts->default_options.if_type = IF_WIRED; -#ifdef HAVE_EXTCAP capture_opts->default_options.extcap = NULL; capture_opts->default_options.extcap_fifo = NULL; capture_opts->default_options.extcap_args = NULL; - capture_opts->default_options.extcap_userdata = NULL; - capture_opts->default_options.extcap_pid = INVALID_EXTCAP_PID; + capture_opts->default_options.extcap_pipedata = NULL; + capture_opts->default_options.extcap_pid = WS_INVALID_PID; +#ifdef _WIN32 + capture_opts->default_options.extcap_pipe_h = INVALID_HANDLE_VALUE; + capture_opts->default_options.extcap_control_in_h = INVALID_HANDLE_VALUE; + capture_opts->default_options.extcap_control_out_h = INVALID_HANDLE_VALUE; #endif + capture_opts->default_options.extcap_control_in = NULL; + capture_opts->default_options.extcap_control_out = NULL; #ifdef CAN_SET_CAPTURE_BUFFER_SIZE capture_opts->default_options.buffer_size = DEFAULT_CAPTURE_BUFFER_SIZE; #endif @@ -88,11 +82,12 @@ capture_opts_init(capture_options *capture_opts) capture_opts->default_options.sampling_method = CAPTURE_SAMP_NONE; capture_opts->default_options.sampling_param = 0; #endif + capture_opts->default_options.timestamp_type = NULL; capture_opts->saving_to_file = FALSE; capture_opts->save_file = NULL; capture_opts->group_read_access = FALSE; #ifdef PCAP_NG_DEFAULT - capture_opts->use_pcapng = TRUE; /* Save as pcap-ng by default */ + capture_opts->use_pcapng = TRUE; /* Save as pcapng by default */ #else capture_opts->use_pcapng = FALSE; /* Save as pcap by default */ #endif @@ -103,7 +98,11 @@ capture_opts_init(capture_options *capture_opts) capture_opts->multi_files_on = FALSE; capture_opts->has_file_duration = FALSE; - capture_opts->file_duration = 60; /* 1 min */ + capture_opts->file_duration = 60.0; /* 1 min */ + capture_opts->has_file_interval = FALSE; + capture_opts->file_interval = 60; /* 1 min */ + capture_opts->has_file_packets = FALSE; + capture_opts->file_packets = 0; capture_opts->has_ring_num_files = FALSE; capture_opts->ring_num_files = RINGBUFFER_MIN_NUM_FILES; @@ -114,7 +113,7 @@ capture_opts_init(capture_options *capture_opts) 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->autostop_duration = 60.0; /* 1 min */ capture_opts->capture_comment = NULL; capture_opts->output_to_pipe = FALSE; @@ -128,13 +127,22 @@ capture_opts_cleanup(capture_options *capture_opts) return; if (capture_opts->ifaces) { + while (capture_opts->ifaces->len > 0) { + capture_opts_del_iface(capture_opts, 0); + } g_array_free(capture_opts->ifaces, TRUE); capture_opts->ifaces = NULL; } if (capture_opts->all_ifaces) { + while (capture_opts->all_ifaces->len > 0) { + interface_t *device = &g_array_index(capture_opts->all_ifaces, interface_t, 0); + capture_opts_free_interface_t(device); + capture_opts->all_ifaces = g_array_remove_index(capture_opts->all_ifaces, 0); + } g_array_free(capture_opts->all_ifaces, TRUE); capture_opts->all_ifaces = NULL; } + g_free(capture_opts->save_file); } /* log content of capture_opts */ @@ -145,50 +153,49 @@ capture_opts_log(const char *log_domain, GLogLevelFlags log_level, capture_optio g_log(log_domain, log_level, "CAPTURE OPTIONS :"); for (i = 0; i < capture_opts->ifaces->len; i++) { - interface_options interface_opts; - - interface_opts = g_array_index(capture_opts->ifaces, interface_options, i); - g_log(log_domain, log_level, "Interface name[%02d] : %s", i, interface_opts.name ? interface_opts.name : "(unspecified)"); - 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)"); - g_log(log_domain, log_level, "Capture filter[%02d] : %s", i, interface_opts.cfilter ? interface_opts.cfilter : "(unspecified)"); - 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); - g_log(log_domain, log_level, "Promiscuous Mode[%02d]: %s", i, interface_opts.promisc_mode?"TRUE":"FALSE"); -#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 + interface_options *interface_opts; + + interface_opts = &g_array_index(capture_opts->ifaces, interface_options, i); + g_log(log_domain, log_level, "Interface name[%02d] : %s", i, interface_opts->name ? interface_opts->name : "(unspecified)"); + g_log(log_domain, log_level, "Interface description[%02d] : %s", i, interface_opts->descr ? interface_opts->descr : "(unspecified)"); + g_log(log_domain, log_level, "Display name[%02d]: %s", i, interface_opts->display_name ? interface_opts->display_name : "(unspecified)"); + g_log(log_domain, log_level, "Capture filter[%02d] : %s", i, interface_opts->cfilter ? interface_opts->cfilter : "(unspecified)"); + 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); + g_log(log_domain, log_level, "Promiscuous Mode[%02d]: %s", i, interface_opts->promisc_mode?"TRUE":"FALSE"); + 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); #ifdef CAN_SET_CAPTURE_BUFFER_SIZE - g_log(log_domain, log_level, "Buffer size[%02d] : %d (MB)", i, interface_opts.buffer_size); + g_log(log_domain, log_level, "Buffer size[%02d] : %d (MB)", i, interface_opts->buffer_size); #endif - g_log(log_domain, log_level, "Monitor Mode[%02d] : %s", i, interface_opts.monitor_mode?"TRUE":"FALSE"); + g_log(log_domain, log_level, "Monitor Mode[%02d] : %s", i, interface_opts->monitor_mode?"TRUE":"FALSE"); #ifdef HAVE_PCAP_REMOTE g_log(log_domain, log_level, "Capture source[%02d] : %s", i, - interface_opts.src_type == CAPTURE_IFLOCAL ? "Local interface" : - interface_opts.src_type == CAPTURE_IFREMOTE ? "Remote interface" : + interface_opts->src_type == CAPTURE_IFLOCAL ? "Local interface" : + interface_opts->src_type == CAPTURE_IFREMOTE ? "Remote interface" : "Unknown"); - if (interface_opts.src_type == CAPTURE_IFREMOTE) { - 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)"); + if (interface_opts->src_type == CAPTURE_IFREMOTE) { + 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)"); } g_log(log_domain, log_level, "Authentication[%02d] : %s", i, - interface_opts.auth_type == CAPTURE_AUTH_NULL ? "Null" : - interface_opts.auth_type == CAPTURE_AUTH_PWD ? "By username/password" : + 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) { - g_log(log_domain, log_level, "Auth username[%02d] : %s", i, interface_opts.auth_username ? interface_opts.auth_username : "(unspecified)"); + if (interface_opts->auth_type == CAPTURE_AUTH_PWD) { + g_log(log_domain, log_level, "Auth username[%02d] : %s", i, interface_opts->auth_username ? interface_opts->auth_username : "(unspecified)"); g_log(log_domain, log_level, "Auth password[%02d] : ", i); } - 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); + 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); #endif #ifdef HAVE_PCAP_SETSAMPLING - 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); + 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); #endif + g_log(log_domain, log_level, "Timestamp type [%02d] : %s", i, interface_opts->timestamp_type); } 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)"); @@ -196,10 +203,8 @@ capture_opts_log(const char *log_domain, GLogLevelFlags log_level, capture_optio 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); g_log(log_domain, log_level, "Promiscuous Mode[df]: %s", capture_opts->default_options.promisc_mode?"TRUE":"FALSE"); -#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 #ifdef CAN_SET_CAPTURE_BUFFER_SIZE g_log(log_domain, log_level, "Buffer size[df] : %d (MB)", capture_opts->default_options.buffer_size); #endif @@ -229,6 +234,7 @@ capture_opts_log(const char *log_domain, GLogLevelFlags log_level, capture_optio 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); #endif + g_log(log_domain, log_level, "Timestamp type [df] : %s", capture_opts->default_options.timestamp_type ? capture_opts->default_options.timestamp_type : "(unspecified)"); 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); @@ -237,13 +243,15 @@ capture_opts_log(const char *log_domain, GLogLevelFlags log_level, capture_optio 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, "FileDuration (%u) : %.3f", capture_opts->has_file_duration, capture_opts->file_duration); + g_log(log_domain, log_level, "FileInterval (%u) : %u", capture_opts->has_file_interval, capture_opts->file_interval); + g_log(log_domain, log_level, "FilePackets (%u) : %u", capture_opts->has_file_packets, capture_opts->file_packets); 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); g_log(log_domain, log_level, "AutostopFilesize(%u) : %u (KB)", capture_opts->has_autostop_filesize, capture_opts->autostop_filesize); - g_log(log_domain, log_level, "AutostopDuration(%u) : %u", capture_opts->has_autostop_duration, capture_opts->autostop_duration); + g_log(log_domain, log_level, "AutostopDuration(%u) : %.3f", capture_opts->has_autostop_duration, capture_opts->autostop_duration); } /* @@ -282,7 +290,7 @@ set_autostop_criterion(capture_options *capture_opts, const char *autostoparg) } if (strcmp(autostoparg,"duration") == 0) { capture_opts->has_autostop_duration = TRUE; - capture_opts->autostop_duration = get_positive_int(p,"autostop duration"); + capture_opts->autostop_duration = get_positive_double(p,"autostop duration"); } else if (strcmp(autostoparg,"filesize") == 0) { capture_opts->has_autostop_filesize = TRUE; capture_opts->autostop_filesize = get_nonzero_guint32(p,"autostop filesize"); @@ -290,6 +298,9 @@ set_autostop_criterion(capture_options *capture_opts, const char *autostoparg) capture_opts->multi_files_on = TRUE; capture_opts->has_autostop_files = TRUE; capture_opts->autostop_files = get_positive_int(p,"autostop files"); + } else if (strcmp(autostoparg,"packets") == 0) { + capture_opts->has_autostop_packets = TRUE; + capture_opts->autostop_packets = get_positive_int(p,"packet count"); } else { return FALSE; } @@ -335,13 +346,11 @@ static gboolean get_filter_arguments(capture_options* capture_opts, const char* } if (capture_opts->ifaces->len > 0) { - interface_options interface_opts; + 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); + interface_opts = &g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1); + g_free(interface_opts->cfilter); + interface_opts->cfilter = filter_exp; return TRUE; } else { @@ -394,7 +403,13 @@ get_ring_arguments(capture_options *capture_opts, const char *arg) capture_opts->autostop_filesize = get_nonzero_guint32(p, "ring buffer filesize"); } else if (strcmp(arg,"duration") == 0) { capture_opts->has_file_duration = TRUE; - capture_opts->file_duration = get_positive_int(p, "ring buffer duration"); + capture_opts->file_duration = get_positive_double(p, "ring buffer duration"); + } else if (strcmp(arg,"interval") == 0) { + capture_opts->has_file_interval = TRUE; + capture_opts->file_interval = get_positive_int(p, "ring buffer interval"); + } else if (strcmp(arg,"packets") == 0) { + capture_opts->has_file_packets = TRUE; + capture_opts->file_packets = get_positive_int(p, "ring buffer packet count"); } *colonp = ':'; /* put the colon back */ @@ -429,26 +444,22 @@ get_sampling_arguments(capture_options *capture_opts, const char *arg) if (strcmp(arg, "count") == 0) { if (capture_opts->ifaces->len > 0) { - interface_options interface_opts; + 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); + interface_opts = &g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1); + interface_opts->sampling_method = CAPTURE_SAMP_BY_COUNT; + interface_opts->sampling_param = get_positive_int(p, "sampling count"); } else { capture_opts->default_options.sampling_method = CAPTURE_SAMP_BY_COUNT; capture_opts->default_options.sampling_param = get_positive_int(p, "sampling count"); } } else if (strcmp(arg, "timer") == 0) { if (capture_opts->ifaces->len > 0) { - interface_options interface_opts; + 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); + interface_opts = &g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1); + interface_opts->sampling_method = CAPTURE_SAMP_BY_TIMER; + interface_opts->sampling_param = get_positive_int(p, "sampling timer"); } else { capture_opts->default_options.sampling_method = CAPTURE_SAMP_BY_TIMER; capture_opts->default_options.sampling_param = get_positive_int(p, "sampling timer"); @@ -482,14 +493,12 @@ get_auth_arguments(capture_options *capture_opts, const char *arg) p++; 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); + interface_options *interface_opts; + + interface_opts = &g_array_index(capture_opts->ifaces, interface_options, 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); } else { capture_opts->default_options.auth_type = CAPTURE_AUTH_PWD; capture_opts->default_options.auth_username = g_strdup(arg); @@ -500,6 +509,140 @@ get_auth_arguments(capture_options *capture_opts, const char *arg) } #endif +#ifdef _WIN32 +static char * +capture_opts_generate_display_name(const char *friendly_name, + const char *name _U_) +{ + /* + * Display the friendly name rather than the not-so-friendly + * GUID-based interface name. + */ + return g_strdup(friendly_name); +} +#else +static char * +capture_opts_generate_display_name(const char *friendly_name, + const char *name) +{ + /* + * On UN*X, however, users are more used to interface names, + * and may find it helpful to see them. + */ + return g_strdup_printf("%s: %s", friendly_name, name); +} +#endif + +static void +fill_in_interface_opts_from_ifinfo(interface_options *interface_opts, + const if_info_t *if_info) +{ + interface_opts->name = g_strdup(if_info->name); + + if (if_info->friendly_name != NULL) { + /* + * We have a friendly name; remember it as the + * description... + */ + interface_opts->descr = g_strdup(if_info->friendly_name); + /* + * ...and use it in the console display name. + */ + interface_opts->display_name = capture_opts_generate_display_name(if_info->friendly_name, if_info->name); + } else { + /* fallback to the interface name */ + interface_opts->descr = NULL; + interface_opts->display_name = g_strdup(if_info->name); + } + interface_opts->if_type = if_info->type; + interface_opts->extcap = g_strdup(if_info->extcap); +} + +static gboolean +fill_in_interface_opts_from_ifinfo_by_name(interface_options *interface_opts, + const char *name) +{ + gboolean matched; + GList *if_list; + int err; + GList *if_entry; + if_info_t *if_info; + size_t prefix_length; + + matched = FALSE; + if_list = capture_interface_list(&err, NULL, NULL); + if (if_list != NULL) { + /* + * Try and do an exact match (case insensitive) on the + * interface name, the interface description, and the + * hardware description. + */ + 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; + + /* + * Does the specified name match the interface name + * with a case-insensitive match? + */ + if (g_ascii_strcasecmp(if_info->name, name) == 0) { + /* + * Yes. + */ + matched = TRUE; + break; + } + + /* + * Does this interface have a friendly name and, if so, + * does the specified name match the friendly name with + * a case-insensitive match? + */ + if (if_info->friendly_name != NULL && + g_ascii_strcasecmp(if_info->friendly_name, name) == 0) { + /* + * Yes. + */ + matched = TRUE; + break; + } + } + + if (!matched) { + /* + * We didn't find it; attempt a case-insensitive prefix match + * of the friendly name. + */ + prefix_length = strlen(name); + 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, name, prefix_length) == 0) { + /* + * We found an interface whose friendly name matches + * with a case-insensitive prefix match. + */ + matched = TRUE; + break; + } + } + } + } + + if (matched) { + /* + * We found an interface that matches. + */ + fill_in_interface_opts_from_ifinfo(interface_opts, if_info); + } + free_interface_list(if_list); + return matched; +} + static int capture_opts_add_iface_opt(capture_options *capture_opts, const char *optarg_str_p) { @@ -549,160 +692,54 @@ capture_opts_add_iface_opt(capture_options *capture_opts, const char *optarg_str cmdarg_err("There is no interface with that adapter index"); return 1; } - interface_opts.name = g_strdup(if_info->name); - 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? - */ - interface_opts.console_display_name = g_strdup(if_info->friendly_name); - } else { - /* fallback to the interface name */ - interface_opts.console_display_name = g_strdup(if_info->name); - } - interface_opts.if_type = if_info->type; -#ifdef HAVE_EXTCAP - interface_opts.extcap = g_strdup(if_info->extcap); -#endif + fill_in_interface_opts_from_ifinfo(&interface_opts, if_info); free_interface_list(if_list); } 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); - interface_opts.if_type = capture_opts->default_options.if_type; -#ifdef HAVE_EXTCAP - interface_opts.extcap = g_strdup(capture_opts->default_options.extcap); -#endif + /* + * In Wireshark capture child mode, so the exact interface name + * is supplied, and we don't need to look it up. + */ + if_info = if_info_get(optarg_str_p); + fill_in_interface_opts_from_ifinfo(&interface_opts, if_info); + if_info_free(if_info); } else { /* - * 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. + * Search for that name in the interface list and, if we found + * it, fill in fields in the interface_opts structure. */ - if_list = capture_interface_list(&err, NULL, NULL); - if (if_list != NULL) { - /* try and do an exact match (case insensitive) */ - GList *if_entry; - gboolean matched; - - matched = FALSE; - 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; - /* 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); - } - interface_opts.if_type = if_info->type; -#ifdef HAVE_EXTCAP - interface_opts.extcap = g_strdup(if_info->extcap); -#endif - matched = TRUE; - break; - } - - /* exact friendly name check */ - if (if_info->friendly_name != NULL && - g_ascii_strcasecmp(if_info->friendly_name, optarg_str_p) == 0) { - /* exact 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); - interface_opts.if_type = if_info->type; -#ifdef HAVE_EXTCAP - interface_opts.extcap = g_strdup(if_info->extcap); -#endif - matched = TRUE; - break; - } - } - - /* 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); - interface_opts.if_type = if_info->type; -#ifdef HAVE_EXTCAP - interface_opts.extcap = g_strdup(if_info->extcap); -#endif - 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); - interface_opts.if_type = capture_opts->default_options.if_type; -#ifdef HAVE_EXTCAP - interface_opts.extcap = g_strdup(capture_opts->default_options.extcap); -#endif - } - free_interface_list(if_list); - } else { + if (!fill_in_interface_opts_from_ifinfo_by_name(&interface_opts, + optarg_str_p)) { + /* + * 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); + interface_opts.descr = NULL; + interface_opts.display_name = g_strdup(optarg_str_p); interface_opts.if_type = capture_opts->default_options.if_type; -#ifdef HAVE_EXTCAP interface_opts.extcap = g_strdup(capture_opts->default_options.extcap); -#endif } } - /* 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... - */ - 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; -#ifdef HAVE_EXTCAP interface_opts.extcap_fifo = g_strdup(capture_opts->default_options.extcap_fifo); interface_opts.extcap_args = NULL; - interface_opts.extcap_pid = INVALID_EXTCAP_PID; - interface_opts.extcap_userdata = NULL; + interface_opts.extcap_pid = WS_INVALID_PID; + interface_opts.extcap_pipedata = NULL; +#ifdef _WIN32 + interface_opts.extcap_pipe_h = INVALID_HANDLE_VALUE; + interface_opts.extcap_control_in_h = INVALID_HANDLE_VALUE; + interface_opts.extcap_control_out_h = INVALID_HANDLE_VALUE; #endif + interface_opts.extcap_control_in = g_strdup(capture_opts->default_options.extcap_control_in); + interface_opts.extcap_control_out = g_strdup(capture_opts->default_options.extcap_control_out); #ifdef CAN_SET_CAPTURE_BUFFER_SIZE interface_opts.buffer_size = capture_opts->default_options.buffer_size; #endif @@ -722,6 +759,7 @@ capture_opts_add_iface_opt(capture_options *capture_opts, const char *optarg_str interface_opts.sampling_method = capture_opts->default_options.sampling_method; interface_opts.sampling_param = capture_opts->default_options.sampling_param; #endif + interface_opts.timestamp_type = capture_opts->default_options.timestamp_type; g_array_append_val(capture_opts->ifaces, interface_opts); @@ -766,18 +804,17 @@ capture_opts_add_opt(capture_options *capture_opts, int opt, const char *optarg_ #ifdef CAN_SET_CAPTURE_BUFFER_SIZE case 'B': /* Buffer size */ if (capture_opts->ifaces->len > 0) { - interface_options interface_opts; + 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.buffer_size = get_positive_int(optarg_str_p, "buffer size"); - g_array_append_val(capture_opts->ifaces, interface_opts); + interface_opts = &g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1); + interface_opts->buffer_size = get_positive_int(optarg_str_p, "buffer size"); } else { capture_opts->default_options.buffer_size = get_positive_int(optarg_str_p, "buffer size"); } break; #endif case 'c': /* Capture n packets */ + /* XXX Use set_autostop_criterion instead? */ capture_opts->has_autostop_packets = TRUE; capture_opts->autostop_packets = get_positive_int(optarg_str_p, "packet count"); break; @@ -790,6 +827,18 @@ capture_opts_add_opt(capture_options *capture_opts, int opt, const char *optarg_ case 'H': /* Hide capture info dialog box */ capture_opts->show_info = FALSE; break; + case LONGOPT_SET_TSTAMP_TYPE: /* Set capture time stamp type */ + 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); + g_free(interface_opts->timestamp_type); + interface_opts->timestamp_type = g_strdup(optarg_str_p); + } else { + g_free(capture_opts->default_options.timestamp_type); + capture_opts->default_options.timestamp_type = g_strdup(optarg_str_p); + } + break; case 'i': /* Use interface x */ status = capture_opts_add_iface_opt(capture_opts, optarg_str_p); if (status != 0) { @@ -799,12 +848,10 @@ capture_opts_add_opt(capture_options *capture_opts, int opt, const char *optarg_ #ifdef HAVE_PCAP_CREATE case 'I': /* Capture in monitor mode */ if (capture_opts->ifaces->len > 0) { - interface_options interface_opts; + 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.monitor_mode = TRUE; - g_array_append_val(capture_opts->ifaces, interface_opts); + interface_opts = &g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1); + interface_opts->monitor_mode = TRUE; } else { capture_opts->default_options.monitor_mode = TRUE; } @@ -827,12 +874,10 @@ capture_opts_add_opt(capture_options *capture_opts, int opt, const char *optarg_ break; case 'p': /* Don't capture in promiscuous mode */ if (capture_opts->ifaces->len > 0) { - interface_options interface_opts; + 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.promisc_mode = FALSE; - g_array_append_val(capture_opts->ifaces, interface_opts); + interface_opts = &g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1); + interface_opts->promisc_mode = FALSE; } else { capture_opts->default_options.promisc_mode = FALSE; } @@ -843,12 +888,10 @@ capture_opts_add_opt(capture_options *capture_opts, int opt, const char *optarg_ #ifdef HAVE_PCAP_REMOTE case 'r': if (capture_opts->ifaces->len > 0) { - interface_options interface_opts; + 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); + interface_opts = &g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1); + interface_opts->nocap_rpcap = FALSE; } else { capture_opts->default_options.nocap_rpcap = FALSE; } @@ -861,15 +904,13 @@ capture_opts_add_opt(capture_options *capture_opts, int opt, const char *optarg_ * length, mirroring what tcpdump does. */ if (snaplen == 0) - snaplen = WTAP_MAX_PACKET_SIZE; + snaplen = WTAP_MAX_PACKET_SIZE_STANDARD; if (capture_opts->ifaces->len > 0) { - interface_options interface_opts; + 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.has_snaplen = TRUE; - interface_opts.snaplen = snaplen; - g_array_append_val(capture_opts->ifaces, interface_opts); + interface_opts = &g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1); + interface_opts->has_snaplen = TRUE; + interface_opts->snaplen = snaplen; } else { capture_opts->default_options.snaplen = snaplen; capture_opts->default_options.has_snaplen = TRUE; @@ -881,12 +922,10 @@ capture_opts_add_opt(capture_options *capture_opts, int opt, const char *optarg_ #ifdef HAVE_PCAP_REMOTE case 'u': if (capture_opts->ifaces->len > 0) { - interface_options interface_opts; + 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); + interface_opts = &g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1); + interface_opts->datatx_udp = TRUE; } else { capture_opts->default_options.datatx_udp = TRUE; } @@ -900,17 +939,15 @@ capture_opts_add_opt(capture_options *capture_opts, int opt, const char *optarg_ return status; case 'y': /* Set the pcap data link type */ if (capture_opts->ifaces->len > 0) { - interface_options interface_opts; + 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.linktype = linktype_name_to_val(optarg_str_p); - if (interface_opts.linktype == -1) { + interface_opts = &g_array_index(capture_opts->ifaces, interface_options, capture_opts->ifaces->len - 1); + interface_opts->linktype = linktype_name_to_val(optarg_str_p); + if (interface_opts->linktype == -1) { cmdarg_err("The specified data link type \"%s\" isn't valid", optarg_str_p); return 1; } - g_array_append_val(capture_opts->ifaces, interface_opts); } else { capture_opts->default_options.linktype = linktype_name_to_val(optarg_str_p); if (capture_opts->default_options.linktype == -1) { @@ -929,26 +966,40 @@ capture_opts_add_opt(capture_options *capture_opts, int opt, const char *optarg_ } void -capture_opts_print_if_capabilities(if_capabilities_t *caps, char *name, - gboolean monitor_mode) +capture_opts_print_if_capabilities(if_capabilities_t *caps, char *name, int queries) { - GList *lt_entry; - data_link_info_t *data_link_info; + GList *lt_entry, *ts_entry; - if (caps->can_set_rfmon) - printf("Data link types of interface %s when %sin monitor mode (use option -y to set):\n", - name, monitor_mode ? "" : "not "); - else - printf("Data link types of interface %s (use option -y to set):\n", name); - for (lt_entry = caps->data_link_types; lt_entry != NULL; - lt_entry = g_list_next(lt_entry)) { - data_link_info = (data_link_info_t *)lt_entry->data; - printf(" %s", data_link_info->name); - if (data_link_info->description != NULL) - printf(" (%s)", data_link_info->description); + if (queries & CAPS_QUERY_LINK_TYPES) { + if (caps->can_set_rfmon) + printf("Data link types of interface %s when %sin monitor mode (use option -y to set):\n", + name, queries & CAPS_MONITOR_MODE ? "" : "not "); else - printf(" (not supported)"); - printf("\n"); + printf("Data link types of interface %s (use option -y to set):\n", name); + for (lt_entry = caps->data_link_types; lt_entry != NULL; + lt_entry = g_list_next(lt_entry)) { + data_link_info_t *data_link_info = (data_link_info_t *)lt_entry->data; + printf(" %s", data_link_info->name); + if (data_link_info->description != NULL) + printf(" (%s)", data_link_info->description); + else + printf(" (not supported)"); + printf("\n"); + } + } + + if (queries & CAPS_QUERY_TIMESTAMP_TYPES) { + printf("Timestamp types of the interface (use option --time-stamp-type to set):\n"); + for (ts_entry = caps->timestamp_types; ts_entry != NULL; + ts_entry = g_list_next(ts_entry)) { + timestamp_info_t *timestamp = (timestamp_info_t *)ts_entry->data; + printf(" %s", timestamp->name); + if (timestamp->description != NULL) + printf(" (%s)", timestamp->description); + else + printf(" (none)"); + printf("\n"); + } } } @@ -967,7 +1018,7 @@ capture_opts_print_interfaces(GList *if_list) printf("%d. %s", i++, if_info->name); /* Print the interface friendly name, if it exists; - if not fall back to vendor description, if it exists. */ + if not, fall back to the vendor description, if it exists. */ if (if_info->friendly_name != NULL){ printf(" (%s)", if_info->friendly_name); } else { @@ -983,21 +1034,19 @@ void capture_opts_trim_snaplen(capture_options *capture_opts, int snaplen_min) { guint i; - interface_options interface_opts; + interface_options *interface_opts; 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); + interface_opts = &g_array_index(capture_opts->ifaces, interface_options, 0); + if (interface_opts->snaplen < 1) + interface_opts->snaplen = WTAP_MAX_PACKET_SIZE_STANDARD; + else if (interface_opts->snaplen < snaplen_min) + interface_opts->snaplen = snaplen_min; } } else { if (capture_opts->default_options.snaplen < 1) - capture_opts->default_options.snaplen = WTAP_MAX_PACKET_SIZE; + capture_opts->default_options.snaplen = WTAP_MAX_PACKET_SIZE_STANDARD; else if (capture_opts->default_options.snaplen < snaplen_min) capture_opts->default_options.snaplen = snaplen_min; } @@ -1111,31 +1160,31 @@ capture_opts_output_to_pipe(const char *save_file, gboolean *is_pipe) void capture_opts_del_iface(capture_options *capture_opts, guint if_index) { - interface_options interface_opts; + interface_options *interface_opts; - interface_opts = g_array_index(capture_opts->ifaces, interface_options, if_index); + interface_opts = &g_array_index(capture_opts->ifaces, interface_options, if_index); /* XXX - check if found? */ - g_free(interface_opts.name); - g_free(interface_opts.descr); - if (interface_opts.console_display_name != NULL) - g_free(interface_opts.console_display_name); - g_free(interface_opts.cfilter); -#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); - if (interface_opts.extcap_pid != INVALID_EXTCAP_PID) - g_spawn_close_pid(interface_opts.extcap_pid); - g_free(interface_opts.extcap_userdata); -#endif + g_free(interface_opts->name); + g_free(interface_opts->descr); + g_free(interface_opts->display_name); + g_free(interface_opts->cfilter); + g_free(interface_opts->timestamp_type); + g_free(interface_opts->extcap); + g_free(interface_opts->extcap_fifo); + if (interface_opts->extcap_args) + g_hash_table_unref(interface_opts->extcap_args); + if (interface_opts->extcap_pid != WS_INVALID_PID) + ws_pipe_close((ws_pipe_t *) interface_opts->extcap_pipedata); + g_free(interface_opts->extcap_pipedata); + g_free(interface_opts->extcap_control_in); + g_free(interface_opts->extcap_control_out); #ifdef HAVE_PCAP_REMOTE - if (interface_opts.src_type == CAPTURE_IFREMOTE) { - g_free(interface_opts.remote_host); - g_free(interface_opts.remote_port); - g_free(interface_opts.auth_username); - g_free(interface_opts.auth_password); + if (interface_opts->src_type == CAPTURE_IFREMOTE) { + g_free(interface_opts->remote_host); + g_free(interface_opts->remote_port); + g_free(interface_opts->auth_username); + g_free(interface_opts->auth_password); } #endif capture_opts->ifaces = g_array_remove_index(capture_opts->ifaces, if_index); @@ -1151,7 +1200,7 @@ void collect_ifaces(capture_options *capture_opts) { guint i; - interface_t device; + interface_t *device; interface_options interface_opts; /* Empty out the existing list of interfaces. */ @@ -1160,47 +1209,53 @@ collect_ifaces(capture_options *capture_opts) /* 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; -#ifdef HAVE_EXTCAP - interface_opts.extcap = g_strdup(device.if_info.extcap); + 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->friendly_name); + interface_opts.display_name = g_strdup(device->display_name); + interface_opts.linktype = device->active_dlt; + interface_opts.cfilter = g_strdup(device->cfilter); + interface_opts.timestamp_type = g_strdup(device->timestamp_type); + 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; + interface_opts.extcap = g_strdup(device->if_info.extcap); interface_opts.extcap_fifo = NULL; - interface_opts.extcap_userdata = NULL; - interface_opts.extcap_args = device.external_cap_args_settings; - interface_opts.extcap_pid = INVALID_EXTCAP_PID; + interface_opts.extcap_pipedata = NULL; + interface_opts.extcap_args = device->external_cap_args_settings; + interface_opts.extcap_pid = WS_INVALID_PID; if (interface_opts.extcap_args) g_hash_table_ref(interface_opts.extcap_args); - interface_opts.extcap_userdata = NULL; + interface_opts.extcap_pipedata = NULL; +#ifdef _WIN32 + interface_opts.extcap_pipe_h = INVALID_HANDLE_VALUE; + interface_opts.extcap_control_in_h = INVALID_HANDLE_VALUE; + interface_opts.extcap_control_out_h = INVALID_HANDLE_VALUE; #endif + interface_opts.extcap_control_in = NULL; + interface_opts.extcap_control_out = NULL; #ifdef CAN_SET_CAPTURE_BUFFER_SIZE - interface_opts.buffer_size = device.buffer; + interface_opts.buffer_size = device->buffer; #endif #ifdef HAVE_PCAP_CREATE - interface_opts.monitor_mode = device.monitor_mode_enabled; + interface_opts.monitor_mode = device->monitor_mode_enabled; #endif #ifdef HAVE_PCAP_REMOTE 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; + 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; #endif #ifdef HAVE_PCAP_SETSAMPLING - interface_opts.sampling_method = device.remote_opts.sampling_method; - interface_opts.sampling_param = device.remote_opts.sampling_param; + interface_opts.sampling_method = device->remote_opts.sampling_method; + interface_opts.sampling_param = device->remote_opts.sampling_param; #endif g_array_append_val(capture_opts->ifaces, interface_opts); } else { @@ -1218,12 +1273,6 @@ capture_opts_free_interface_t_links(gpointer elem, gpointer unused _U_) 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) { @@ -1233,6 +1282,7 @@ capture_opts_free_interface_t(interface_t *device) g_free(device->friendly_name); g_free(device->addresses); g_free(device->cfilter); + g_free(device->timestamp_type); g_list_foreach(device->links, capture_opts_free_interface_t_links, NULL); g_list_free(device->links); @@ -1245,12 +1295,8 @@ capture_opts_free_interface_t(interface_t *device) 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_slist_free_full(device->if_info.addrs, g_free); g_free(device->if_info.extcap); -#endif } }