static proto_item *
decode_ip_element(nsip_ip_element_info_t *element, build_info_t *bi, proto_tree * element_tree) {
guint16 udp_port;
guint32 ip4_addr;
struct e_in6_addr ip6_addr;
proto_item *tf = NULL;
proto_tree *field_tree = NULL;
if (bi->nsip_tree) {
tf = proto_tree_add_text(element_tree, bi->tvb, bi->offset,
element->total_length, "IP Element");
field_tree = proto_item_add_subtree(tf, ett_nsip_ip_element);
/* IP address */
switch (element->version) {
case NSIP_IP_VERSION_4:
ip4_addr = tvb_get_ipv4(bi->tvb, bi->offset);
proto_tree_add_item(field_tree, hf_nsip_ip_address_ipv4,
bi->tvb, bi->offset, element->address_length,
ENC_BIG_ENDIAN);
proto_item_append_text(tf, ": IP address: %s",
ip_to_str((guint8 *)&ip4_addr));
break;
case NSIP_IP_VERSION_6:
tvb_get_ipv6(bi->tvb, bi->offset, &ip6_addr);
proto_tree_add_item(field_tree, hf_nsip_ip_address_ipv6, bi->tvb,
bi->offset, element->address_length,
ENC_NA);
proto_item_append_text(tf, ": IP address: %s",
ip6_to_str((struct e_in6_addr *)&ip6_addr));
break;
default:
;
}
}
bi->offset += element->address_length;
if (bi->nsip_tree) {
/* UDP port value */
udp_port = tvb_get_ntohs(bi->tvb, bi->offset);
proto_tree_add_uint_format(field_tree, hf_nsip_ip_element_udp_port,
bi->tvb, bi->offset, 2, udp_port,
"UDP Port: %u", udp_port);
proto_item_append_text(tf, ", UDP Port: %u", udp_port);
}
bi->offset += 2;
if (bi->nsip_tree) {
/* Signalling weight */
proto_tree_add_item(field_tree, hf_nsip_ip_element_signalling_weight,
bi->tvb, bi->offset, 1, ENC_BIG_ENDIAN);
}
bi->offset++;
if (bi->nsip_tree) {
/* Data weight */
proto_tree_add_item(field_tree, hf_nsip_ip_element_data_weight,
bi->tvb, bi->offset, 1, ENC_BIG_ENDIAN);
}
bi->offset++;
return tf;
}
/* Code to actually dissect the packets */
static int
rsip_parameter(tvbuff_t *tvb, proto_tree *rsip_tree, int off, int eoff)
{
int consumed, i, paramleft;
guint8 addrtype, flowpolicy, method, number, paramtype, tuntype;
guint16 error, ind, paramlen, portnum;
guint32 bid, cid, leasetm, msgc;
proto_tree *p_tree, *v_tree;
proto_item *pti, *vti;
struct e_in6_addr in6;
/* XXX */
if (off >= eoff)
return 0;
paramtype = tvb_get_guint8(tvb, off);
paramlen = tvb_get_ntohs(tvb, off + 1);
pti = proto_tree_add_text(rsip_tree, tvb, off, 3 + paramlen,
"%s",
val_to_str(paramtype, param_type_vals, "Unknown (%d)"));
p_tree = proto_item_add_subtree(pti, ett_rsip_param);
proto_tree_add_item(p_tree, hf_rsip_parameter_type, tvb,
off, 1, FALSE);
proto_tree_add_item(p_tree, hf_rsip_parameter_length, tvb,
off + 1, 2, FALSE);
consumed = 3;
if (paramlen == 0)
return consumed;
vti = proto_tree_add_item(p_tree, hf_rsip_parameter_value,
tvb, off + 3, paramlen, FALSE);
v_tree = proto_item_add_subtree(vti, ett_rsip_param_val);
switch (paramtype) {
case 1: /* Address */
proto_tree_add_item(v_tree, hf_rsip_parameter_address_type,
tvb, off + 3, 1, FALSE);
addrtype = tvb_get_guint8(tvb, off + 3);
switch (addrtype) {
case 0: /* Reserved */
break;
case 1: /* IPv4 */
if (paramlen - 1 > 0) {
proto_tree_add_item(v_tree,
hf_rsip_parameter_address_ipv4, tvb,
off + 4, paramlen - 1, FALSE);
proto_item_append_text(pti, ": %s",
tvb_ip_to_str(tvb, off + 4));
} else
proto_item_append_text(pti,
": Any IPv4 Address");
break;
case 2: /* IPv4 netmask */
if (paramlen - 1 > 0) {
proto_tree_add_item(v_tree,
hf_rsip_parameter_address_ipv4_netmask,
tvb, off + 4, paramlen - 1, FALSE);
proto_item_append_text(pti, "(netmask): %s",
tvb_ip_to_str(tvb, off + 4));
} else
proto_item_append_text(pti,
": Any IPv4 Netmask");
break;
case 3: /* IPv6 */
if (paramlen - 1 > 0) {
tvb_get_ipv6(tvb, off + 4, &in6);
proto_tree_add_item(v_tree,
hf_rsip_parameter_address_ipv6, tvb,
off + 4, paramlen - 1, FALSE);
proto_item_append_text(pti, ": %s",
ip6_to_str(&in6));
} else
proto_item_append_text(pti,
": Any IPv6 Address");
break;
case 4: /* FQDN */
if (paramlen - 1 > 0) {
proto_tree_add_item(v_tree,
hf_rsip_parameter_address_fqdn, tvb,
off + 4, paramlen - 1, FALSE);
proto_item_append_text(pti, ": %s",
tvb_format_text(tvb, off + 4, paramlen - 1));
} else
proto_item_append_text(pti,
": Any Fully Qualified Domain Name");
break;
default:
proto_tree_add_text(p_tree, tvb, off + 4,
paramlen - 1, ": Unknown Address Type");
break;
}
break;
case 2: /* Ports */
proto_tree_add_item(v_tree, hf_rsip_parameter_ports_number,
tvb, off + 3, 1, FALSE);
number = tvb_get_guint8(tvb, off + 3);
if (paramlen == 1) {
switch (number) {
case 0:
proto_item_append_text(pti, ": Unspecified");
break;
case 1:
proto_item_append_text(pti, ": Any port");
break;
default:
proto_item_append_text(pti, ": Any %d ports",
number);
break;
}
} else {
portnum = tvb_get_ntohs(tvb, off + 4);
if (number == 1) {
proto_tree_add_item(v_tree,
hf_rsip_parameter_ports_port_number,
tvb, off + 4, 2, FALSE);
} else {
paramleft = paramlen - 1;
if (paramleft == 2) {
proto_tree_add_uint_format_value(v_tree,
hf_rsip_parameter_ports_port_number,
tvb, off + 4, 2, portnum, "%d - %d",
portnum, portnum + number);
proto_item_append_text(pti,
": %d - %d", portnum,
portnum + number);
} else {
for (i = off + 4;
paramleft > 0;
i += 2, paramleft -= 2)
proto_tree_add_item(v_tree,
hf_rsip_parameter_ports_port_number,
tvb, i, 2, FALSE);
proto_item_append_text(pti,
": List of %d Ports", number);
}
}
}
break;
case 3: /* Lease Time */
/* XXX if paramlen != 4 we've got a protocol violation */
proto_tree_add_item(v_tree, hf_rsip_parameter_lease_time,
tvb, off + 3, paramlen, FALSE);
leasetm = tvb_get_ntohl(tvb, off + 3);
proto_item_append_text(pti, ": %d seconds", leasetm);
break;
case 4: /* Client ID */
/* XXX if paramlen != 4 we've got a protocol violation */
proto_tree_add_item(v_tree, hf_rsip_parameter_client_id,
tvb, off + 3, paramlen, FALSE);
cid = tvb_get_ntohl(tvb, off + 3);
proto_item_append_text(pti, ": %d", cid);
break;
case 5: /* Bind ID */
/* XXX if paramlen != 4 we've got a protocol violation */
proto_tree_add_item(v_tree, hf_rsip_parameter_bind_id,
tvb, off + 3, paramlen, FALSE);
bid = tvb_get_ntohl(tvb, off + 3);
proto_item_append_text(pti, ": %d", bid);
break;
case 6: /* Tunnel Type */
/* XXX if paramlen != 1 we've got a protocol violation */
proto_tree_add_item(v_tree, hf_rsip_parameter_tunnel_type,
tvb, off + 3, paramlen, FALSE);
tuntype = tvb_get_guint8(tvb, off + 3);
proto_item_append_text(pti, ": %s",
val_to_str(tuntype, tunnel_type_vals,
"Unknown Tunnel Type (%d)"));
break;
case 7: /* RSIP Method */
/* XXX if paramlen != 1 we've got a protocol violation */
proto_tree_add_item(v_tree, hf_rsip_parameter_method,
tvb, off + 3, paramlen, FALSE);
method = tvb_get_guint8(tvb, off + 3);
proto_item_append_text(pti, ": %s",
val_to_str(method, method_vals,
"Unknown RSIP Method (%d)"));
break;
case 8: /* Error */
/* XXX if paramlen != 2 we've got a protocol violation */
proto_tree_add_item(v_tree, hf_rsip_parameter_error,
tvb, off + 3, paramlen, FALSE);
error = tvb_get_ntohs(tvb, off + 3);
proto_item_append_text(pti, ": %s",
val_to_str(error, error_number_vals, "Undefined Error (%d)"));
break;
case 9: /* Flow Policy */
/* XXX if paramlen != 2 we've got a protocol violation */
proto_tree_add_item(v_tree,
hf_rsip_parameter_flow_policy_local, tvb, off + 3, 1, FALSE);
flowpolicy = tvb_get_guint8(tvb, off + 3);
proto_item_append_text(pti, ": %s",
val_to_str(flowpolicy, lcl_flow_policy_vals,
"Undefined Local Flow Policy (%d)"));
proto_tree_add_item(v_tree,
hf_rsip_parameter_flow_policy_remote, tvb, off + 4, 1,
FALSE);
flowpolicy = tvb_get_guint8(tvb, off + 4);
proto_item_append_text(pti, "/%s",
val_to_str(flowpolicy, rmt_flow_policy_vals,
"Undefined Remote Flow Policy (%d)"));
break;
case 10: /* Indicator */
/* XXX if paramlen != 2 we've got a protocol violation */
proto_tree_add_item(v_tree, hf_rsip_parameter_indicator, tvb,
off + 3, 2, FALSE);
ind = tvb_get_ntohs(tvb, off + 3);
proto_item_append_text(pti, ": %d", ind);
break;
case 11: /* Message Counter */
/* XXX if paramlen != 4 we've got a protocol violation */
proto_tree_add_item(v_tree, hf_rsip_parameter_message_counter,
tvb, off + 3, 4, FALSE);
msgc = tvb_get_ntohl(tvb, off + 3);
proto_item_append_text(pti, ": %d", msgc);
break;
case 12: /* Vendor Specific */
proto_tree_add_item(v_tree,
hf_rsip_parameter_vendor_specific_vendor_id, tvb, off + 3,
2, FALSE);
proto_tree_add_item(v_tree,
hf_rsip_parameter_vendor_specific_subtype, tvb, off + 5,
2, FALSE);
proto_tree_add_item(v_tree,
hf_rsip_parameter_vendor_specific_value, tvb, off + 9,
paramlen - 4, FALSE);
break;
case 22: /* SPI */
proto_tree_add_item(v_tree, hf_rsip_parameter_spi_number, tvb,
off + 3, 2, FALSE);
/* XXX need loop? */
proto_tree_add_item(v_tree, hf_rsip_parameter_spi, tvb,
off + 5, 4, FALSE);
break;
default:
break;
}
consumed += paramlen;
return consumed;
}
static void
dissect_aodv_draft_01_v6_rreq(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *aodv_tree, proto_item *ti)
{
int offset = 1;
proto_item *tj;
proto_tree *aodv_flags_tree;
guint8 flags;
guint8 hop_count;
guint32 rreq_id;
guint32 dest_seqno;
guint32 orig_seqno;
struct e_in6_addr dest_addr_v6;
struct e_in6_addr orig_addr_v6;
int extlen;
flags = tvb_get_guint8(tvb, offset);
if (aodv_tree) {
aodv_flags_tree = proto_tree_add_subtree(aodv_tree, tvb, offset, 1, ett_aodv_flags, &tj, "Flags:");
proto_tree_add_boolean(aodv_flags_tree, hf_aodv_flags_rreq_join,
tvb, offset, 1, flags);
proto_tree_add_boolean(aodv_flags_tree, hf_aodv_flags_rreq_repair,
tvb, offset, 1, flags);
proto_tree_add_boolean(aodv_flags_tree, hf_aodv_flags_rreq_gratuitous,
tvb, offset, 1, flags);
proto_tree_add_boolean(aodv_flags_tree, hf_aodv_flags_rreq_destinationonly,
tvb, offset, 1, flags);
proto_tree_add_boolean(aodv_flags_tree, hf_aodv_flags_rreq_unknown,
tvb, offset, 1, flags);
if (flags & RREQ_JOIN)
proto_item_append_text(tj, " J");
if (flags & RREQ_REP)
proto_item_append_text(tj, " R");
if (flags & RREQ_GRATRREP)
proto_item_append_text(tj, " G");
if (flags & RREQ_DESTONLY)
proto_item_append_text(tj, " D");
if (flags & RREQ_UNKNSEQ)
proto_item_append_text(tj, " U");
}
offset += 2; /* skip reserved byte */
hop_count = tvb_get_guint8(tvb, offset);
if (aodv_tree)
proto_tree_add_uint(aodv_tree, hf_aodv_hopcount, tvb, offset, 1,
hop_count);
offset += 1;
rreq_id = tvb_get_ntohl(tvb, offset);
if (aodv_tree)
proto_tree_add_uint(aodv_tree, hf_aodv_rreq_id, tvb, offset, 4,
rreq_id);
offset += 4;
dest_seqno = tvb_get_ntohl(tvb, offset);
if (aodv_tree)
proto_tree_add_uint(aodv_tree, hf_aodv_dest_seqno, tvb, offset, 4,
dest_seqno);
offset += 4;
orig_seqno = tvb_get_ntohl(tvb, offset);
if (aodv_tree)
proto_tree_add_uint(aodv_tree, hf_aodv_orig_seqno, tvb, offset, 4,
orig_seqno);
offset += 4;
tvb_get_ipv6(tvb, offset, &dest_addr_v6);
if (aodv_tree) {
proto_tree_add_ipv6(aodv_tree, hf_aodv_dest_ipv6, tvb, offset,
INET6_ADDRLEN, (guint8 *)&dest_addr_v6);
proto_item_append_text(ti, ", Dest IP: %s",
ip6_to_str(&dest_addr_v6));
}
col_append_fstr(pinfo->cinfo, COL_INFO, ", D: %s",
ip6_to_str(&dest_addr_v6));
offset += INET6_ADDRLEN;
tvb_get_ipv6(tvb, offset, &orig_addr_v6);
if (aodv_tree) {
proto_tree_add_ipv6(aodv_tree, hf_aodv_orig_ipv6, tvb, offset,
INET6_ADDRLEN, (guint8 *)&orig_addr_v6);
proto_item_append_text(ti, ", Orig IP: %s",
ip6_to_str(&orig_addr_v6));
}
col_append_fstr(pinfo->cinfo, COL_INFO,
", O: %s Id=%u Hcnt=%u DSN=%u OSN=%u",
ip6_to_str(&orig_addr_v6),
rreq_id,
hop_count,
dest_seqno,
orig_seqno);
offset += INET6_ADDRLEN;
if (aodv_tree) {
extlen = tvb_reported_length_remaining(tvb, offset);
if (extlen > 0)
dissect_aodv_ext(tvb, pinfo, offset, aodv_tree);
}
}
static void
dissect_aodv_draft_01_v6_rrep(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *aodv_tree, proto_item *ti)
{
int offset = 1;
proto_item *tj;
proto_tree *aodv_flags_tree;
guint8 flags;
guint8 prefix_sz;
guint8 hop_count;
guint32 dest_seqno;
struct e_in6_addr dest_addr_v6;
struct e_in6_addr orig_addr_v6;
guint32 lifetime;
int extlen;
flags = tvb_get_guint8(tvb, offset);
if (aodv_tree) {
aodv_flags_tree = proto_tree_add_subtree(aodv_tree, tvb, offset, 1, ett_aodv_flags, &tj, "Flags:");
proto_tree_add_boolean(aodv_flags_tree, hf_aodv_flags_rrep_repair,
tvb, offset, 1, flags);
proto_tree_add_boolean(aodv_flags_tree, hf_aodv_flags_rrep_ack, tvb,
offset, 1, flags);
if (flags & RREP_REP)
proto_item_append_text(tj, " R");
if (flags & RREP_ACK_REQ)
proto_item_append_text(tj, " A");
}
offset += 1;
prefix_sz = tvb_get_guint8(tvb, offset) & 0x7F;
if (aodv_tree)
proto_tree_add_uint(aodv_tree, hf_aodv_prefix_sz, tvb, offset, 1,
prefix_sz);
offset += 1;
hop_count = tvb_get_guint8(tvb, offset);
if (aodv_tree)
proto_tree_add_uint(aodv_tree, hf_aodv_hopcount, tvb, offset, 1,
hop_count);
offset += 1;
dest_seqno = tvb_get_ntohl(tvb, offset);
if (aodv_tree)
proto_tree_add_uint(aodv_tree, hf_aodv_dest_seqno, tvb, offset, 4,
dest_seqno);
offset += 4;
tvb_get_ipv6(tvb, offset, &dest_addr_v6);
if (aodv_tree) {
proto_tree_add_ipv6(aodv_tree, hf_aodv_dest_ipv6, tvb, offset,
INET6_ADDRLEN, (guint8 *)&dest_addr_v6);
proto_item_append_text(ti, ", Dest IP: %s",
ip6_to_str(&dest_addr_v6));
}
col_append_fstr(pinfo->cinfo, COL_INFO, ", D: %s",
ip6_to_str(&dest_addr_v6));
offset += INET6_ADDRLEN;
tvb_get_ipv6(tvb, offset, &orig_addr_v6);
if (aodv_tree) {
proto_tree_add_ipv6(aodv_tree, hf_aodv_orig_ipv6, tvb, offset,
INET6_ADDRLEN, (guint8 *)&orig_addr_v6);
proto_item_append_text(ti, ", Orig IP: %s",
ip6_to_str(&orig_addr_v6));
}
col_append_fstr(pinfo->cinfo, COL_INFO, ", O: %s",
ip6_to_str(&orig_addr_v6));
offset += INET6_ADDRLEN;
lifetime = tvb_get_ntohl(tvb, offset);
if (aodv_tree) {
proto_tree_add_uint(aodv_tree, hf_aodv_lifetime, tvb, offset, 4,
lifetime);
proto_item_append_text(ti, ", Lifetime=%u", lifetime);
}
col_append_fstr(pinfo->cinfo, COL_INFO, " Hcnt=%u DSN=%u Lifetime=%u",
hop_count,
dest_seqno,
lifetime);
offset += 4;
if (aodv_tree) {
extlen = tvb_reported_length_remaining(tvb, offset);
if (extlen > 0)
dissect_aodv_ext(tvb, pinfo, offset, aodv_tree);
}
}
/*
* Fetch the list of local interfaces with capture_interface_list()
* and set the list of "all interfaces" in *capture_opts to include
* those interfaces.
*/
void
scan_local_interfaces(void (*update_cb)(void))
{
GList *if_entry, *lt_entry, *if_list;
if_info_t *if_info, *temp;
char *if_string;
gchar *descr;
if_capabilities_t *caps=NULL;
gint linktype_count;
gboolean monitor_mode;
GSList *curr_addr;
int ips = 0, i, err;
guint count = 0, j;
if_addr_t *addr, *temp_addr;
link_row *link = NULL;
data_link_info_t *data_link_info;
interface_t device;
GString *ip_str;
interface_options interface_opts;
gboolean found = FALSE;
if (global_capture_opts.all_ifaces->len > 0) {
for (i = (int)global_capture_opts.all_ifaces->len-1; i >= 0; i--) {
device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
if (device.local && device.type != IF_PIPE && device.type != IF_STDIN) {
global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
}
}
}
/* Scan through the list and build a list of strings to display. */
if_list = capture_interface_list(&err, NULL, update_cb);
count = 0;
for (if_entry = if_list; if_entry != NULL; if_entry = g_list_next(if_entry)) {
if_info = (if_info_t *)if_entry->data;
ip_str = g_string_new("");
ips = 0;
if (strstr(if_info->name, "rpcap:")) {
continue;
}
device.name = g_strdup(if_info->name);
if (if_info->friendly_name != NULL) {
device.friendly_name = g_strdup(if_info->friendly_name);
} else {
device.friendly_name = NULL;
}
device.hidden = FALSE;
device.locked = FALSE;
temp = (if_info_t *)g_malloc0(sizeof(if_info_t));
temp->name = g_strdup(if_info->name);
temp->friendly_name = g_strdup(if_info->friendly_name);
temp->vendor_description = g_strdup(if_info->vendor_description);
temp->loopback = if_info->loopback;
/* Is this interface hidden and, if so, should we include it anyway? */
/* Do we have a user-supplied description? */
descr = capture_dev_user_descr_find(if_info->name);
if (descr != NULL) {
/* Yes, we have a user-supplied description; use it. */
if_string = g_strdup_printf("%s: %s", descr, if_info->name);
g_free(descr);
} else {
/* No, we don't have a user-supplied description; did we get
one from the OS or libpcap? */
if (if_info->friendly_name != NULL) {
/* We have a friendly name from the OS, use it */
#ifdef _WIN32
/*
* On Windows, if we have a friendly name, just show it,
* don't show the name, as that's a string made out of
* the device GUID, and not at all friendly.
*/
if_string = g_strdup_printf("%s", if_info->friendly_name);
#else
/*
* On UN*X, if we have a friendly name, show it along
* with the interface name; the interface name is short
* and somewhat friendly, and many UN*X users are used
* to interface names, so we should show it.
*/
if_string = g_strdup_printf("%s: %s", if_info->friendly_name, if_info->name);
#endif
} else if (if_info->vendor_description != NULL) {
/* We have a device description from libpcap - use it. */
if_string = g_strdup_printf("%s: %s", if_info->vendor_description, if_info->name);
} else {
/* No. */
if_string = g_strdup(if_info->name);
}
}
device.display_name = if_string;
device.selected = FALSE;
if (prefs_is_capture_device_hidden(if_info->name)) {
device.hidden = TRUE;
}
device.type = if_info->type;
monitor_mode = prefs_capture_device_monitor_mode(if_info->name);
caps = capture_get_if_capabilities(if_info->name, monitor_mode, NULL, update_cb);
for (; (curr_addr = g_slist_nth(if_info->addrs, ips)) != NULL; ips++) {
temp_addr = (if_addr_t *)g_malloc0(sizeof(if_addr_t));
if (ips != 0) {
g_string_append(ip_str, "\n");
}
addr = (if_addr_t *)curr_addr->data;
if (addr) {
temp_addr->ifat_type = addr->ifat_type;
switch (addr->ifat_type) {
case IF_AT_IPv4:
temp_addr->addr.ip4_addr = addr->addr.ip4_addr;
g_string_append(ip_str, ip_to_str((guint8 *)&addr->addr.ip4_addr));
break;
case IF_AT_IPv6:
memcpy(temp_addr->addr.ip6_addr, addr->addr.ip6_addr, sizeof(addr->addr));
g_string_append(ip_str, ip6_to_str((struct e_in6_addr *)&addr->addr.ip6_addr));
break;
default:
/* In case we add non-IP addresses */
break;
}
} else {
g_free(temp_addr);
temp_addr = NULL;
}
if (temp_addr) {
temp->addrs = g_slist_append(temp->addrs, temp_addr);
}
}
#ifdef HAVE_PCAP_REMOTE
device.local = TRUE;
device.remote_opts.src_type = CAPTURE_IFLOCAL;
device.remote_opts.remote_host_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
device.remote_opts.remote_host_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
device.remote_opts.remote_host_opts.auth_type = global_capture_opts.default_options.auth_type;
device.remote_opts.remote_host_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
device.remote_opts.remote_host_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
device.remote_opts.remote_host_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
device.remote_opts.remote_host_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
device.remote_opts.remote_host_opts.nocap_local = global_capture_opts.default_options.nocap_local;
#endif
#ifdef HAVE_PCAP_SETSAMPLING
device.remote_opts.sampling_method = global_capture_opts.default_options.sampling_method;
device.remote_opts.sampling_param = global_capture_opts.default_options.sampling_param;
#endif
linktype_count = 0;
device.links = NULL;
if (caps != NULL) {
#if defined(HAVE_PCAP_CREATE)
device.monitor_mode_enabled = monitor_mode;
device.monitor_mode_supported = caps->can_set_rfmon;
#endif
/*
* If there's a preference for the link-layer header type for
* this interface, use it. If not, use the all-interface
* default; if that's not set on the command line, that will
* be -1, meaning "use per-interface defaults", otherwise
* we'll fail if it's not one of the types the interface
* supports.
*/
if ((device.active_dlt = capture_dev_user_linktype_find(if_info->name)) == -1) {
device.active_dlt = global_capture_opts.default_options.linktype;
}
/*
* Process the list of link-layer header types.
* If the active link-layer header type wasn't set from a
* preference or a global option (meaning it's -1), default
* to the first link-layer header type in the list.
*/
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;
if (linktype_count == 0 && device.active_dlt == -1) {
device.active_dlt = data_link_info->dlt;
}
link = (link_row *)g_malloc(sizeof(link_row));
if (data_link_info->description != NULL) {
link->dlt = data_link_info->dlt;
link->name = g_strdup_printf("%s", data_link_info->description);
} else {
link->dlt = -1;
link->name = g_strdup_printf("%s (not supported)", data_link_info->name);
}
device.links = g_list_append(device.links, link);
linktype_count++;
}
} else {
#if defined(HAVE_PCAP_CREATE)
device.monitor_mode_enabled = FALSE;
device.monitor_mode_supported = FALSE;
#endif
device.active_dlt = -1;
}
device.addresses = g_strdup(ip_str->str);
device.no_addresses = ips;
device.local = TRUE;
device.if_info = *temp;
device.last_packets = 0;
if ((device.pmode = capture_dev_user_pmode_find(if_info->name)) == -1) {
device.pmode = global_capture_opts.default_options.promisc_mode;
}
if ((device.has_snaplen = capture_dev_user_hassnap_find(if_info->name)) == -1) {
device.has_snaplen = global_capture_opts.default_options.has_snaplen;
}
if (capture_dev_user_snaplen_find(if_info->name) == -1) {
device.snaplen = global_capture_opts.default_options.snaplen;
} else {
device.snaplen = (guint)capture_dev_user_snaplen_find(if_info->name);
}
device.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
if ((device.buffer = capture_dev_user_buffersize_find(if_info->name)) == -1) {
device.buffer = global_capture_opts.default_options.buffer_size;
}
#endif
if (global_capture_opts.ifaces->len > 0) {
for (j = 0; j < global_capture_opts.ifaces->len; j++) {
interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, j);
if (strcmp(interface_opts.name, device.name) == 0) {
#if defined(HAVE_PCAP_CREATE)
device.buffer = interface_opts.buffer_size;
device.monitor_mode_enabled = interface_opts.monitor_mode;
#endif
device.pmode = interface_opts.promisc_mode;
device.has_snaplen = interface_opts.has_snaplen;
device.snaplen = interface_opts.snaplen;
device.cfilter = g_strdup(interface_opts.cfilter);
if (interface_opts.linktype != -1) {
device.active_dlt = interface_opts.linktype;
}
device.selected = TRUE;
global_capture_opts.num_selected++;
break;
}
}
}
if (global_capture_opts.all_ifaces->len <= count) {
g_array_append_val(global_capture_opts.all_ifaces, device);
count = global_capture_opts.all_ifaces->len;
} else {
g_array_insert_val(global_capture_opts.all_ifaces, count, device);
}
if (caps != NULL) {
free_if_capabilities(caps);
}
g_string_free(ip_str, TRUE);
count++;
}
free_interface_list(if_list);
/* see whether there are additional interfaces in ifaces */
for (j = 0; j < global_capture_opts.ifaces->len; j++) {
interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, j);
found = FALSE;
for (i = 0; i < (int)global_capture_opts.all_ifaces->len; i++) {
device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
if (strcmp(device.name, interface_opts.name) == 0) {
found = TRUE;
break;
}
}
if (!found) { /* new interface, maybe a pipe */
device.name = g_strdup(interface_opts.name);
device.display_name = g_strdup_printf("%s: %s", device.name, interface_opts.descr);
device.hidden = FALSE;
device.selected = TRUE;
device.type = IF_PIPE;
#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
device.buffer = interface_opts.buffer_size;
#endif
#if defined(HAVE_PCAP_CREATE)
device.monitor_mode_enabled = interface_opts.monitor_mode;
device.monitor_mode_supported = FALSE;
#endif
device.pmode = interface_opts.promisc_mode;
device.has_snaplen = interface_opts.has_snaplen;
device.snaplen = interface_opts.snaplen;
device.cfilter = g_strdup(interface_opts.cfilter);
device.active_dlt = interface_opts.linktype;
device.addresses = NULL;
device.no_addresses = 0;
device.last_packets = 0;
device.links = NULL;
device.local = TRUE;
device.locked = FALSE;
device.if_info.name = g_strdup(interface_opts.name);
device.if_info.friendly_name = NULL;
device.if_info.vendor_description = g_strdup(interface_opts.descr);
device.if_info.addrs = NULL;
device.if_info.loopback = FALSE;
g_array_append_val(global_capture_opts.all_ifaces, device);
global_capture_opts.num_selected++;
}
}
}
