void CapturePreferencesFrame::updateWidgets() { #ifdef HAVE_LIBPCAP GList *if_list, *combo_list, *combo_entry; int err; ui->defaultInterfaceComboBox->clear(); if_list = capture_interface_list(&err, NULL,main_window_update); combo_list = build_capture_combo_list(if_list, FALSE); free_interface_list(if_list); for (combo_entry = combo_list; combo_entry != NULL && combo_entry->data != NULL; combo_entry = g_list_next(combo_entry)) { ui->defaultInterfaceComboBox->addItem(QString((const char *)combo_entry->data)); } if (pref_device_->stashed_val.string) { ui->defaultInterfaceComboBox->setEditText(pref_device_->stashed_val.string); } else { ui->defaultInterfaceComboBox->clearEditText(); } ui->capturePromModeCheckBox->setChecked(pref_prom_mode_->stashed_val.boolval); ui->capturePcapNgCheckBox->setChecked(pref_pcap_ng_->stashed_val.boolval); ui->captureRealTimeCheckBox->setChecked(pref_real_time_->stashed_val.boolval); ui->captureAutoScrollCheckBox->setChecked(pref_auto_scroll_->stashed_val.boolval); ui->captureShowInfoCheckBox->setChecked(pref_show_info_->stashed_val.boolval); #endif // HAVE_LIBPCAP }
/* * Return as descriptive a name for an interface as we can get. * If the user has specified a comment, use that. Otherwise, * if capture_interface_list() supplies a description, use that, * otherwise use the interface name. * * The result must be g_free()'d when you're done with it. * * Note: given that this calls capture_interface_list(), which attempts to * open all adapters it finds in order to check whether they can be * captured on, this is an expensive routine to call, so don't call it * frequently. */ char * get_interface_descriptive_name(const char *if_name) { char *descr; GList *if_list; GList *if_entry; if_info_t *if_info; int err; /* Do we have a user-supplied description? */ descr = capture_dev_user_descr_find(if_name); if (descr != NULL) { /* Yes - make a copy of that. */ descr = g_strdup(descr); } else if (strcmp(if_name, "-") == 0) { /* * Strictly speaking, -X (extension) options are for modules, e.g. Lua * and using one here stretches that definition. However, this doesn't * waste a single-letter option on something that might be rarely used * and is backward-compatible to 1.0. */ descr = g_strdup(ex_opt_get_nth("stdin_descr", 0)); if (!descr) { descr = g_strdup("Standard input"); } } else { /* No, we don't have a user-supplied description; did we get one from the OS or libpcap? */ descr = NULL; if_list = capture_interface_list(&err, NULL); if (if_list != NULL) { if_entry = if_list; do { if_info = if_entry->data; if (strcmp(if_info->name, if_name) == 0) { if (if_info->description != NULL) { /* Return a copy of that - when we free the interface list, that'll also free up the strings to which it refers. */ descr = g_strdup(if_info->description); } break; } } while ((if_entry = g_list_next(if_entry)) != NULL); } free_interface_list(if_list); if (descr == NULL) { /* The interface name is all we have, so just return a copy of that. */ descr = g_strdup(if_name); } } return descr; }
void node_info_unref (NodeInfo *info) { info->base.refcount -= 1; if (info->base.refcount == 0) { free_interface_list (&info->interfaces); free_node_list (&info->nodes); base_info_free (info); } }
gboolean capture_opts_trim_iface(capture_options *capture_opts, const char *capture_device) { GList *if_list; if_info_t *if_info; int err; gchar *err_str; /* Did the user specify an interface to use? */ if (capture_opts->iface == NULL) { /* No - is a default specified in the preferences file? */ if (capture_device != NULL) { /* Yes - use it. */ capture_opts->iface = g_strdup(capture_device); /* 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... */ } else { /* No - pick the first one from the list of interfaces. */ if_list = capture_interface_list(&err, &err_str); if (if_list == NULL) { switch (err) { case CANT_GET_INTERFACE_LIST: cmdarg_err("%s", err_str); g_free(err_str); break; case NO_INTERFACES_FOUND: cmdarg_err("There are no interfaces on which a capture can be done"); break; } return FALSE; } if_info = (if_info_t *)if_list->data; /* first interface */ capture_opts->iface = g_strdup(if_info->name); /* 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... */ free_interface_list(if_list); } } return TRUE; }
/* * 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) { 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); 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); 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 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 = 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++; } } }
void InterfaceTree::getInterfaceList() { #ifdef HAVE_LIBPCAP GList *if_list; int err; gchar *err_str = NULL; clear(); if_list = capture_interface_list(&err, &err_str,main_window_update); if_list = g_list_sort(if_list, if_list_comparator_alph); if (if_list == NULL) { QTreeWidgetItem *ti = new QTreeWidgetItem(); QLabel *err_label = new QLabel(gchar_free_to_qstring(err_str)); err_label->setWordWrap(true); setColumnCount(1); addTopLevelItem(ti); setItemWidget(ti, 0, err_label); resizeColumnToContents(0); return; } else if (err_str) { g_free(err_str); } // XXX Do we need to check for this? capture_interface_list returns an error if the length is 0. if (g_list_length(if_list) > 0) { interface_t device; setDisabled(false); for (guint i = 0; i < global_capture_opts.all_ifaces->len; i++) { QList<int> *points; device = g_array_index(global_capture_opts.all_ifaces, interface_t, i); /* Continue if capture device is hidden */ if (device.hidden) { continue; } QTreeWidgetItem *ti = new QTreeWidgetItem(); ti->setText(0, QString().fromUtf8(device.display_name)); ti->setData(0, Qt::UserRole, QString(device.name)); points = new QList<int>(); ti->setData(1, Qt::UserRole, qVariantFromValue(points)); addTopLevelItem(ti); // XXX Add other device information resizeColumnToContents(1); if (strstr(prefs.capture_device, device.name) != NULL) { device.selected = TRUE; global_capture_opts.num_selected++; global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i); g_array_insert_val(global_capture_opts.all_ifaces, i, device); } if (device.selected) { ti->setSelected(true); } } } free_interface_list(if_list); resizeEvent(NULL); if (!stat_timer_) { updateStatistics(); stat_timer_ = new QTimer(this); connect(stat_timer_, SIGNAL(timeout()), this, SLOT(updateStatistics())); stat_timer_->start(stat_update_interval_); } #else QTreeWidgetItem *ti = new QTreeWidgetItem(); clear(); setColumnCount(1); ti->setText(0, tr("Interface information not available")); addTopLevelItem(ti); resizeColumnToContents(0); #endif // HAVE_LIBPCAP }
gboolean capture_opts_trim_iface(capture_options *capture_opts, const char *capture_device) { GList *if_list; if_info_t *if_info; int err; gchar *err_str; interface_options interface_opts; /* Did the user specify an interface to use? */ if (capture_opts->num_selected == 0 && capture_opts->ifaces->len == 0) { /* No - is a default specified in the preferences file? */ if (capture_device != NULL) { /* Yes - use it. */ interface_opts.name = g_strdup(capture_device); /* 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... */ } else { /* No - pick the first one from the list of interfaces. */ if_list = capture_interface_list(&err, &err_str); if (if_list == NULL) { switch (err) { case CANT_GET_INTERFACE_LIST: case DONT_HAVE_PCAP: cmdarg_err("%s", err_str); g_free(err_str); break; case NO_INTERFACES_FOUND: cmdarg_err("There are no interfaces on which a capture can be done"); break; } return FALSE; } if_info = (if_info_t *)if_list->data; /* first interface */ interface_opts.name = g_strdup(if_info->name); /* 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... */ free_interface_list(if_list); } if (capture_opts->default_options.descr) { interface_opts.descr = g_strdup(capture_opts->default_options.descr); } else { interface_opts.descr = NULL; } 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; #if defined(_WIN32) || defined(HAVE_PCAP_CREATE) interface_opts.buffer_size = capture_opts->default_options.buffer_size; #endif interface_opts.monitor_mode = capture_opts->default_options.monitor_mode; #ifdef HAVE_PCAP_REMOTE 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; #endif #ifdef HAVE_PCAP_SETSAMPLING interface_opts.sampling_method = capture_opts->default_options.sampling_method; interface_opts.sampling_param = capture_opts->default_options.sampling_param; #endif g_array_append_val(capture_opts->ifaces, interface_opts); } return TRUE; }
static int capture_opts_add_iface_opt(capture_options *capture_opts, const char *optarg_str_p) { long adapter_index; char *p; GList *if_list; if_info_t *if_info; int err; gchar *err_str; interface_options interface_opts; /* * If the argument is a number, treat it as an index into the list * of adapters, as printed by "tshark -D". * * 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. */ adapter_index = strtol(optarg_str_p, &p, 10); if (p != NULL && *p == '\0') { 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; } if_list = capture_interface_list(&err, &err_str); if (if_list == NULL) { switch (err) { case CANT_GET_INTERFACE_LIST: case DONT_HAVE_PCAP: cmdarg_err("%s", err_str); g_free(err_str); break; case NO_INTERFACES_FOUND: cmdarg_err("There are no interfaces on which a capture can be done"); break; } return 2; } if_info = (if_info_t *)g_list_nth_data(if_list, adapter_index - 1); if (if_info == NULL) { cmdarg_err("There is no interface with that adapter index"); return 1; } interface_opts.name = g_strdup(if_info->name); /* 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... */ free_interface_list(if_list); } else { interface_opts.name = g_strdup(optarg_str_p); } 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; #if defined(_WIN32) || defined(HAVE_PCAP_CREATE) interface_opts.buffer_size = capture_opts->default_options.buffer_size; #endif interface_opts.monitor_mode = capture_opts->default_options.monitor_mode; #ifdef HAVE_PCAP_REMOTE 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; #endif #ifdef HAVE_PCAP_SETSAMPLING interface_opts.sampling_method = capture_opts->default_options.sampling_method; interface_opts.sampling_param = capture_opts->default_options.sampling_param; #endif g_array_append_val(capture_opts->ifaces, interface_opts); return 0; }
static int capture_opts_add_iface_opt(capture_options *capture_opts, const char *optarg_str_p) { long adapter_index; char *p; GList *if_list; if_info_t *if_info; int err; gchar *err_str; interface_options interface_opts; /* * If the argument is a number, treat it as an index into the list * of adapters, as printed by "tshark -D". * * 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. */ adapter_index = strtol(optarg_str_p, &p, 10); if (p != NULL && *p == '\0') { 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; } if_list = capture_interface_list(&err, &err_str, NULL); if (if_list == NULL) { switch (err) { case CANT_GET_INTERFACE_LIST: case DONT_HAVE_PCAP: cmdarg_err("%s", err_str); g_free(err_str); break; case NO_INTERFACES_FOUND: cmdarg_err("There are no interfaces on which a capture can be done"); break; } return 2; } if_info = (if_info_t *)g_list_nth_data(if_list, (int)(adapter_index - 1)); if (if_info == NULL) { 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); } 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); } 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. */ 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); } 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); 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); 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); } free_interface_list(if_list); } else { interface_opts.name = g_strdup(optarg_str_p); interface_opts.console_display_name = g_strdup(optarg_str_p); } } /* 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; #if defined(_WIN32) || defined(HAVE_PCAP_CREATE) interface_opts.buffer_size = capture_opts->default_options.buffer_size; #endif interface_opts.monitor_mode = capture_opts->default_options.monitor_mode; #ifdef HAVE_PCAP_REMOTE 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; #endif #ifdef HAVE_PCAP_SETSAMPLING interface_opts.sampling_method = capture_opts->default_options.sampling_method; interface_opts.sampling_param = capture_opts->default_options.sampling_param; #endif g_array_append_val(capture_opts->ifaces, interface_opts); return 0; }
static int capture_opts_add_iface_opt(capture_options *capture_opts, const char *optarg_str_p) { long adapter_index; char *p; GList *if_list; if_info_t *if_info; int err; gchar *err_str; /* * If the argument is a number, treat it as an index into the list * of adapters, as printed by "tshark -D". * * 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. */ adapter_index = strtol(optarg_str_p, &p, 10); if (p != NULL && *p == '\0') { 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; } if_list = capture_interface_list(&err, &err_str); if (if_list == NULL) { switch (err) { case CANT_GET_INTERFACE_LIST: cmdarg_err("%s", err_str); g_free(err_str); break; case NO_INTERFACES_FOUND: cmdarg_err("There are no interfaces on which a capture can be done"); break; } return 2; } if_info = (if_info_t *)g_list_nth_data(if_list, adapter_index - 1); if (if_info == NULL) { cmdarg_err("There is no interface with that adapter index"); return 1; } capture_opts->iface = g_strdup(if_info->name); /* 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... */ free_interface_list(if_list); } else { capture_opts->iface = g_strdup(optarg_str_p); } return 0; }
GtkWidget* capture_prefs_show(void) { GtkWidget *main_tb, *main_vb; GtkWidget *if_cbxe, *if_lb, *promisc_cb, *pcap_ng_cb, *sync_cb, *auto_scroll_cb, *show_info_cb; GtkWidget *ifopts_lb, *ifopts_bt; GList *if_list, *combo_list; int err; int row = 0; const gchar *tooltips_text; /* Main vertical box */ main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 7, FALSE); gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5); /* Main table */ main_tb = gtk_table_new(CAPTURE_TABLE_ROWS, 2, FALSE); gtk_box_pack_start(GTK_BOX(main_vb), main_tb, FALSE, FALSE, 0); gtk_table_set_row_spacings(GTK_TABLE(main_tb), 10); gtk_table_set_col_spacings(GTK_TABLE(main_tb), 15); gtk_widget_show(main_tb); /* Default device */ if_lb = gtk_label_new("Default interface:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(if_lb), 1.0f, 0.5f); gtk_widget_show(if_lb); if_cbxe = gtk_combo_box_text_new_with_entry(); /* * XXX - what if we can't get the list? */ if_list = capture_interface_list(&err, NULL); combo_list = build_capture_combo_list(if_list, FALSE); free_interface_list(if_list); if (combo_list != NULL) { GList *combo_entry; for (combo_entry = combo_list; combo_entry != NULL; combo_entry = g_list_next(combo_entry)) { gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(if_cbxe), combo_entry->data); } } if (prefs.capture_device) { gtk_entry_set_text(GTK_ENTRY(gtk_bin_get_child(GTK_BIN(if_cbxe))), prefs.capture_device); } else if (combo_list != NULL) { gtk_combo_box_set_active(GTK_COMBO_BOX(if_cbxe), 0); } free_capture_combo_list(combo_list); gtk_table_attach_defaults(GTK_TABLE(main_tb), if_cbxe, 1, 2, row, row+1); tooltips_text = "The default interface to be captured from."; gtk_widget_set_tooltip_text(if_lb, tooltips_text); gtk_widget_set_tooltip_text(gtk_bin_get_child(GTK_BIN(if_cbxe)), tooltips_text); gtk_widget_show(if_cbxe); g_object_set_data(G_OBJECT(main_vb), DEVICE_KEY, if_cbxe); row++; /* Interface properties */ ifopts_lb = gtk_label_new("Interfaces:"); gtk_table_attach_defaults(GTK_TABLE(main_tb), ifopts_lb, 0, 1, row, row+1); gtk_misc_set_alignment(GTK_MISC(ifopts_lb), 1.0f, 0.5f); gtk_widget_show(ifopts_lb); ifopts_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_EDIT); tooltips_text = "Open a dialog box to set various interface options."; gtk_widget_set_tooltip_text(ifopts_lb, tooltips_text); gtk_widget_set_tooltip_text(ifopts_bt, tooltips_text); g_signal_connect(ifopts_bt, "clicked", G_CALLBACK(ifopts_edit_cb), NULL); gtk_table_attach_defaults(GTK_TABLE(main_tb), ifopts_bt, 1, 2, row, row+1); row++; /* Promiscuous mode */ promisc_cb = create_preference_check_button(main_tb, row++, "Capture packets in promiscuous mode:", "Usually a network card will only capture the traffic sent to its own network address. " "If you want to capture all traffic that the network card can \"see\", mark this option. " "See the FAQ for some more details of capturing packets from a switched network. ", prefs.capture_prom_mode); g_object_set_data(G_OBJECT(main_vb), PROM_MODE_KEY, promisc_cb); /* Pcap-NG format */ pcap_ng_cb = create_preference_check_button(main_tb, row++, "Capture packets in pcap-ng format:", "Capture packets in the next-generation capture file format.", prefs.capture_pcap_ng); g_object_set_data(G_OBJECT(main_vb), PCAP_NG_KEY, pcap_ng_cb); /* Real-time capture */ sync_cb = create_preference_check_button(main_tb, row++, "Update list of packets in real time:", "Update the list of packets while capture is in progress. " "Don't use this option if you notice packet drops.", prefs.capture_real_time); g_object_set_data(G_OBJECT(main_vb), CAPTURE_REAL_TIME_KEY, sync_cb); /* Auto-scroll real-time capture */ auto_scroll_cb = create_preference_check_button(main_tb, row++, "Automatic scrolling in live capture:", "Automatic scrolling of the packet list while live capture is in progress. ", prefs.capture_auto_scroll); g_object_set_data(G_OBJECT(main_vb), AUTO_SCROLL_KEY, auto_scroll_cb); /* Show capture info dialog */ show_info_cb = create_preference_check_button(main_tb, row++, "Hide capture info dialog:", "Hide the capture info dialog while capturing. ", !prefs.capture_show_info); g_object_set_data(G_OBJECT(main_vb), SHOW_INFO_KEY, show_info_cb); /* Show 'em what we got */ gtk_widget_show_all(main_vb); return(main_vb); }
/* * 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; gchar *descr; if_capabilities_t *caps=NULL; gint linktype_count; gboolean monitor_mode; GSList *curr_addr; int ips = 0, i; 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); if (device.selected) { global_capture_opts.num_selected--; /* if device was to be used after this statement, we should set device.selected=FALSE here */ } /* if we remove an interface from all_interfaces, it must also be removed from ifaces if it is present there otherwise, it would be re-added to all_interfaces below (interfaces set with -i on the command line are initially present in ifaces but not in all_interfaces, but these interfaces are not removed here) */ for (j = 0; j < global_capture_opts.ifaces->len; j++) { interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, j); if (strcmp(device.name, interface_opts.name) == 0) { /* 2nd param must be the index of ifaces (not all_ifaces) */ capture_opts_del_iface(&global_capture_opts, j); } } capture_opts_free_interface_t(&device); } } } /* Scan through the list and build a list of strings to display. */ g_free(global_capture_opts.ifaces_err_info); if_list = capture_interface_list(&global_capture_opts.ifaces_err, &global_capture_opts.ifaces_err_info, update_cb); count = 0; for (if_entry = if_list; if_entry != NULL; if_entry = g_list_next(if_entry)) { memset(&device, 0, sizeof(device)); 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; memset(&temp, 0, sizeof(temp)); 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; temp.type = if_info->type; #ifdef HAVE_EXTCAP temp.extcap = g_strdup(if_info->extcap); #endif /* Is this interface hidden and, if so, should we include it anyway? */ descr = capture_dev_user_descr_find(if_info->name); device.display_name = get_iface_display_name(descr, if_info); g_free(descr); 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, 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) { address addr_str; char* temp_addr_str = NULL; temp_addr->ifat_type = addr->ifat_type; switch (addr->ifat_type) { case IF_AT_IPv4: temp_addr->addr.ip4_addr = addr->addr.ip4_addr; set_address(&addr_str, AT_IPv4, 4, &addr->addr.ip4_addr); temp_addr_str = address_to_str(NULL, &addr_str); g_string_append(ip_str, temp_addr_str); break; case IF_AT_IPv6: memcpy(temp_addr->addr.ip6_addr, addr->addr.ip6_addr, sizeof(addr->addr)); set_address(&addr_str, AT_IPv6, 16, addr->addr.ip6_addr); temp_addr_str = address_to_str(NULL, &addr_str); g_string_append(ip_str, temp_addr_str); break; default: /* In case we add non-IP addresses */ break; } wmem_free(NULL, temp_addr_str); } 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 /* * Process the list of link-layer header types. */ 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; 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++; } /* * Set the active DLT for the device appropriately. */ set_active_dlt(&device, global_capture_opts.default_options.linktype); } 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 (!capture_dev_user_pmode_find(if_info->name, &device.pmode)) { device.pmode = global_capture_opts.default_options.promisc_mode; } if (!capture_dev_user_snaplen_find(if_info->name, &device.has_snaplen, &device.snaplen)) { device.has_snaplen = global_capture_opts.default_options.has_snaplen; device.snaplen = global_capture_opts.default_options.snaplen; } device.cfilter = g_strdup(global_capture_opts.default_options.cfilter); #ifdef CAN_SET_CAPTURE_BUFFER_SIZE if ((device.buffer = capture_dev_user_buffersize_find(if_info->name)) == -1) { device.buffer = global_capture_opts.default_options.buffer_size; } #endif fill_from_ifaces(&device); #ifdef HAVE_EXTCAP /* Extcap devices start with no cached args */ device.external_cap_args_settings = NULL; #endif 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 */ memset(&device, 0, sizeof(device)); device.name = g_strdup(interface_opts.name); device.display_name = interface_opts.descr ? g_strdup_printf("%s: %s", device.name, interface_opts.descr) : g_strdup_printf("%s", device.name); device.hidden = FALSE; device.selected = TRUE; device.type = IF_PIPE; #ifdef CAN_SET_CAPTURE_BUFFER_SIZE 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; #ifdef HAVE_EXTCAP device.if_info.extcap = g_strdup(interface_opts.extcap); #endif g_array_append_val(global_capture_opts.all_ifaces, device); global_capture_opts.num_selected++; } } }
/* And now our feature presentation... [ fade to music ] */ int main(int argc, char *argv[]) { WiresharkApplication a(argc, argv); MainWindow *w; char *init_progfile_dir_error; char *s; int opt; gboolean arg_error = FALSE; extern int info_update_freq; /* Found in about_dlg.c. */ const gchar *filter; #ifdef _WIN32 WSADATA wsaData; #endif /* _WIN32 */ char *rf_path; int rf_open_errno; char *gdp_path, *dp_path; int err; #ifdef HAVE_LIBPCAP gboolean start_capture = FALSE; gboolean list_link_layer_types = FALSE; GList *if_list; gchar *err_str; #else gboolean capture_option_specified = FALSE; #ifdef _WIN32 #ifdef HAVE_AIRPCAP gchar *err_str; #endif #endif #endif gint pl_size = 280, tv_size = 95, bv_size = 75; gchar *rc_file, *cf_name = NULL, *rfilter = NULL, *jfilter = NULL; dfilter_t *rfcode = NULL; gboolean rfilter_parse_failed = FALSE; e_prefs *prefs_p; char badopt; //GtkWidget *splash_win = NULL; GLogLevelFlags log_flags; guint go_to_packet = 0; gboolean jump_backwards = FALSE; dfilter_t *jump_to_filter = NULL; int optind_initial; int status; //initialize language ! QString locale = QLocale::system().name(); g_log(NULL, G_LOG_LEVEL_DEBUG, "Translator %s", locale.toStdString().c_str()); QTranslator translator; translator.load(QString(":/i18n/qtshark_") + locale); a.installTranslator(&translator); // Hopefully we won't have to use QString::fromUtf8() in as many places. QTextCodec *utf8codec = QTextCodec::codecForName("UTF-8"); QTextCodec::setCodecForCStrings(utf8codec); QTextCodec::setCodecForTr(utf8codec); #ifdef HAVE_LIBPCAP #if defined(_WIN32) || defined(HAVE_PCAP_CREATE) #define OPTSTRING_B "B:" #else #define OPTSTRING_B "" #endif /* _WIN32 or HAVE_PCAP_CREATE */ #else /* HAVE_LIBPCAP */ #define OPTSTRING_B "" #endif /* HAVE_LIBPCAP */ #ifdef HAVE_PCAP_CREATE #define OPTSTRING_I "I" #else #define OPTSTRING_I "" #endif #define OPTSTRING "a:b:" OPTSTRING_B "c:C:Df:g:Hhi:" OPTSTRING_I "jJ:kK:lLm:nN:o:P:pQr:R:Ss:t:u:vw:X:y:z:" static const char optstring[] = OPTSTRING; /* * Get credential information for later use, and drop privileges * before doing anything else. * Let the user know if anything happened. */ init_process_policies(); relinquish_special_privs_perm(); /* * Attempt to get the pathname of the executable file. */ init_progfile_dir_error = init_progfile_dir(argv[0], main); g_log(NULL, G_LOG_LEVEL_DEBUG, "progfile_dir: %s", get_progfile_dir()); /* initialize the funnel mini-api */ // xxx qtshark //initialize_funnel_ops(); AirPDcapInitContext(&airpdcap_ctx); // xxx qtshark #ifdef _WIN32 /* Load wpcap if possible. Do this before collecting the run-time version information */ load_wpcap(); /* ... and also load the packet.dll from wpcap */ wpcap_packet_load(); #ifdef HAVE_AIRPCAP /* Load the airpcap.dll. This must also be done before collecting * run-time version information. */ airpcap_dll_ret_val = load_airpcap(); switch (airpcap_dll_ret_val) { case AIRPCAP_DLL_OK: /* load the airpcap interfaces */ airpcap_if_list = get_airpcap_interface_list(&err, &err_str); if (airpcap_if_list == NULL || g_list_length(airpcap_if_list) == 0){ if (err == CANT_GET_AIRPCAP_INTERFACE_LIST && err_str != NULL) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", "Failed to open Airpcap Adapters!"); g_free(err_str); } airpcap_if_active = NULL; } else { /* select the first ad default (THIS SHOULD BE CHANGED) */ airpcap_if_active = airpcap_get_default_if(airpcap_if_list); } break; #if 0 /* * XXX - Maybe we need to warn the user if one of the following happens??? */ case AIRPCAP_DLL_OLD: simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s","AIRPCAP_DLL_OLD\n"); break; case AIRPCAP_DLL_ERROR: simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s","AIRPCAP_DLL_ERROR\n"); break; case AIRPCAP_DLL_NOT_FOUND: simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s","AIRPCAP_DDL_NOT_FOUND\n"); break; #endif } #endif /* HAVE_AIRPCAP */ /* Start windows sockets */ WSAStartup( MAKEWORD( 1, 1 ), &wsaData ); #endif /* _WIN32 */ profile_store_persconffiles (TRUE); /* Assemble the compile-time version information string */ comp_info_str = g_string_new("Compiled "); // xxx qtshark get_compiled_version_info(comp_info_str, get_qt_compiled_info, get_gui_compiled_info); /* Assemble the run-time version information string */ runtime_info_str = g_string_new("Running "); // xxx qtshark get_runtime_version_info(runtime_info_str, get_gui_runtime_info); /* Read the profile independent recent file. We have to do this here so we can */ /* set the profile before it can be set from the command line parameterts */ // xxx qtshark //recent_read_static(&rf_path, &rf_open_errno); //if (rf_path != NULL && rf_open_errno != 0) { // simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, // "Could not open common recent file\n\"%s\": %s.", // rf_path, strerror(rf_open_errno)); //} /* "pre-scan" the command line parameters, if we have "console only" parameters. We do this so we don't start GTK+ if we're only showing command-line help or version information. XXX - this pre-scan is done before we start GTK+, so we haven't run gtk_init() on the arguments. That means that GTK+ arguments have not been removed from the argument list; those arguments begin with "--", and will be treated as an error by getopt(). We thus ignore errors - *and* set "opterr" to 0 to suppress the error messages. */ opterr = 0; optind_initial = optind; while ((opt = getopt(argc, argv, optstring)) != -1) { switch (opt) { case 'C': /* Configuration Profile */ if (profile_exists (optarg, FALSE)) { set_profile_name (optarg); } else { cmdarg_err("Configuration Profile \"%s\" does not exist", optarg); exit(1); } break; case 'D': /* Print a list of capture devices and exit */ #ifdef HAVE_LIBPCAP if_list = capture_interface_list(&err, &err_str); if (if_list == NULL) { switch (err) { case CANT_GET_INTERFACE_LIST: cmdarg_err("%s", err_str); g_free(err_str); break; case NO_INTERFACES_FOUND: cmdarg_err("There are no interfaces on which a capture can be done"); break; } exit(2); } capture_opts_print_interfaces(if_list); free_interface_list(if_list); exit(0); #else capture_option_specified = TRUE; arg_error = TRUE; #endif break; case 'h': /* Print help and exit */ print_usage(TRUE); exit(0); break; #ifdef _WIN32 case 'i': if (strcmp(optarg, "-") == 0) stdin_capture = TRUE; break; #endif case 'P': /* Path settings - change these before the Preferences and alike are processed */ status = filesystem_opt(opt, optarg); if(status != 0) { cmdarg_err("-P flag \"%s\" failed (hint: is it quoted and existing?)", optarg); exit(status); } break; case 'v': /* Show version and exit */ show_version(); exit(0); break; case 'X': /* * Extension command line options have to be processed before * we call epan_init() as they are supposed to be used by dissectors * or taps very early in the registration process. */ ex_opt_add(optarg); break; case '?': /* Ignore errors - the "real" scan will catch them. */ break; } } cf_callback_add(main_cf_callback, NULL); /* Arrange that if we have no console window, and a GLib message logging routine is called to log a message, we pop up a console window. We do that by inserting our own handler for all messages logged to the default domain; that handler pops up a console if necessary, and then calls the default handler. */ /* We might want to have component specific log levels later ... */ log_flags = (GLogLevelFlags) ( G_LOG_LEVEL_ERROR| G_LOG_LEVEL_CRITICAL| G_LOG_LEVEL_WARNING| G_LOG_LEVEL_MESSAGE| G_LOG_LEVEL_INFO| G_LOG_LEVEL_DEBUG| G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION ); g_log_set_handler(NULL, log_flags, console_log_handler, NULL /* user_data */); g_log_set_handler(LOG_DOMAIN_MAIN, log_flags, console_log_handler, NULL /* user_data */); #ifdef HAVE_LIBPCAP g_log_set_handler(LOG_DOMAIN_CAPTURE, log_flags, console_log_handler, NULL /* user_data */); g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD, log_flags, console_log_handler, NULL /* user_data */); /* Set the initial values in the capture options. This might be overwritten by preference settings and then again by the command line parameters. */ capture_opts_init(&global_capture_opts, &cfile); #endif /* Register all dissectors; we must do this before checking for the "-G" flag, as the "-G" flag dumps information registered by the dissectors, and we must do it before we read the preferences, in case any dissectors register preferences. */ epan_init(register_all_protocols,register_all_protocol_handoffs, NULL, NULL, // splash_update, (gpointer) splash_win, failure_alert_box,open_failure_alert_box,read_failure_alert_box, write_failure_alert_box ); // splash_update(RA_LISTENERS, NULL, (gpointer)splash_win); /* Register all tap listeners; we do this before we parse the arguments, as the "-z" argument can specify a registered tap. */ /* we register the plugin taps before the other taps because stats_tree taps plugins will be registered as tap listeners by stats_tree_stat.c and need to registered before that */ g_log(NULL, G_LOG_LEVEL_DEBUG, "plugin_dir: %s", get_plugin_dir()); #ifdef HAVE_PLUGINS register_all_plugin_tap_listeners(); #endif // register_all_tap_listeners(); // splash_update(RA_PREFERENCES, NULL, (gpointer)splash_win); prefs_p = read_configuration_files (&gdp_path, &dp_path); /* Removed thread code: * http://anonsvn.wireshark.org/viewvc/viewvc.cgi?view=rev&revision=35027 */ g_log(NULL, G_LOG_LEVEL_DEBUG, "FIX: timestamp types should be set elsewhere"); timestamp_set_type(TS_RELATIVE); timestamp_set_precision(TS_PREC_AUTO_USEC); timestamp_set_seconds_type(TS_SECONDS_DEFAULT); ///////// build_column_format_array(&cfile.cinfo, prefs_p->num_cols, TRUE); font_init(); //////// /* Read the dynamic part of the recent file, as we have the gui now ready for it. */ recent_read_dynamic(&rf_path, &rf_open_errno); if (rf_path != NULL && rf_open_errno != 0) { simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, "Could not open recent file\n\"%s\": %s.", rf_path, g_strerror(rf_open_errno)); } color_filters_enable(recent.packet_list_colorize); g_log(NULL, G_LOG_LEVEL_DEBUG, "FIX: fetch recent color settings"); color_filters_enable(TRUE); //////// switch (user_font_apply()) { case FA_SUCCESS: break; case FA_FONT_NOT_RESIZEABLE: /* "user_font_apply()" popped up an alert box. */ /* turn off zooming - font can't be resized */ case FA_FONT_NOT_AVAILABLE: /* XXX - did we successfully load the un-zoomed version earlier? If so, this *probably* means the font is available, but not at this particular zoom level, but perhaps some other failure occurred; I'm not sure you can determine which is the case, however. */ /* turn off zooming - zoom level is unavailable */ default: /* in any other case than FA_SUCCESS, turn off zooming */ // recent.gui_zoom_level = 0; /* XXX: would it be a good idea to disable zooming (insensitive GUI)? */ break; } //////// color_filters_init(); //////// w = new(MainWindow); w->show(); return a.exec(); }
GList * get_interface_list(int *err, char **err_str) { GList *il = NULL; gint nonloopback_pos = 0; struct ifreq *ifr, *last; struct ifconf ifc; struct ifreq ifrflags; int sock = socket(AF_INET, SOCK_DGRAM, 0); struct search_user_data user_data; pcap_t *pch; int len, lastlen; char *buf; if_info_t *if_info; char errbuf[PCAP_ERRBUF_SIZE]; gboolean loopback; if (sock < 0) { *err = CANT_GET_INTERFACE_LIST; if (err_str != NULL) { *err_str = g_strdup_printf( "Can't get list of interfaces: error opening socket: %s", g_strerror(errno)); } return NULL; } /* * This code came from: W. Richard Stevens: "UNIX Network Programming", * Networking APIs: Sockets and XTI, Vol 1, page 434. */ lastlen = 0; len = 100 * sizeof(struct ifreq); for ( ; ; ) { buf = (char *)g_malloc(len); ifc.ifc_len = len; ifc.ifc_buf = buf; memset (buf, 0, len); if (ioctl(sock, SIOCGIFCONF, &ifc) < 0) { if (errno != EINVAL || lastlen != 0) { if (err_str != NULL) { *err_str = g_strdup_printf( "Can't get list of interfaces: SIOCGIFCONF ioctl error: %s", g_strerror(errno)); } goto fail; } } else { if ((unsigned int) ifc.ifc_len < sizeof(struct ifreq)) { if (err_str != NULL) { *err_str = g_strdup( "Can't get list of interfaces: SIOCGIFCONF ioctl gave too small return buffer"); } goto fail; } if (ifc.ifc_len == lastlen) break; /* success, len has not changed */ lastlen = ifc.ifc_len; } len += 10 * sizeof(struct ifreq); /* increment */ g_free(buf); } ifr = (struct ifreq *) ifc.ifc_req; last = (struct ifreq *) ((char *) ifr + ifc.ifc_len); while (ifr < last) { /* * Skip entries that begin with "dummy", or that include * a ":" (the latter are Solaris virtuals). */ if (strncmp(ifr->ifr_name, "dummy", 5) == 0 || strchr(ifr->ifr_name, ':') != NULL) goto next; /* * If we already have this interface name on the list, * don't add it, but, if we don't already have an IP * address for it, add that address (SIOCGIFCONF returns, * at least on BSD-flavored systems, one entry per * interface *address*; if an interface has multiple * addresses, we get multiple entries for it). */ user_data.name = ifr->ifr_name; user_data.if_info = NULL; g_list_foreach(il, search_for_if_cb, &user_data); if (user_data.if_info != NULL) { if_info_add_address(user_data.if_info, &ifr->ifr_addr); if (user_data.if_info->addrs) { g_slist_reverse(user_data.if_info->addrs); } goto next; } /* * Get the interface flags. */ memset(&ifrflags, 0, sizeof ifrflags); g_strlcpy(ifrflags.ifr_name, ifr->ifr_name, sizeof ifrflags.ifr_name); if (ioctl(sock, SIOCGIFFLAGS, (char *)&ifrflags) < 0) { if (errno == ENXIO) goto next; if (err_str != NULL) { *err_str = g_strdup_printf( "Can't get list of interfaces: SIOCGIFFLAGS error getting flags for interface %s: %s", ifr->ifr_name, g_strerror(errno)); } goto fail; } /* * Skip interfaces that aren't up. */ if (!(ifrflags.ifr_flags & IFF_UP)) goto next; /* * Skip interfaces that we can't open with "libpcap". * Open with the minimum packet size - it appears that the * IRIX SIOCSNOOPLEN "ioctl" may fail if the capture length * supplied is too large, rather than just truncating it. */ pch = pcap_open_live(ifr->ifr_name, MIN_PACKET_SIZE, 0, 0, errbuf); if (pch == NULL) goto next; pcap_close(pch); /* * If it's a loopback interface, add it at the end of the * list, otherwise add it after the last non-loopback * interface, so all loopback interfaces go at the end - we * don't want a loopback interface to be the default capture * device unless there are no non-loopback devices. */ loopback = ((ifrflags.ifr_flags & IFF_LOOPBACK) || strncmp(ifr->ifr_name, "lo", 2) == 0); if_info = if_info_new(ifr->ifr_name, NULL, loopback); if_info_add_address(if_info, &ifr->ifr_addr); if (if_info->addrs) { g_slist_reverse(if_info->addrs); } if (loopback) il = g_list_append(il, if_info); else { il = g_list_insert(il, if_info, nonloopback_pos); /* * Insert the next non-loopback interface after this * one. */ nonloopback_pos++; } next: #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN ifr = (struct ifreq *) ((char *) ifr + (ifr->ifr_addr.sa_len > sizeof(ifr->ifr_addr) ? ifr->ifr_addr.sa_len : sizeof(ifr->ifr_addr)) + IFNAMSIZ); #else ifr = (struct ifreq *) ((char *) ifr + sizeof(struct ifreq)); #endif } #ifdef linux /* * OK, maybe we have support for the "any" device, to do a cooked * capture on all interfaces at once. * Try opening it and, if that succeeds, add it to the end of * the list of interfaces. */ pch = pcap_open_live("any", MIN_PACKET_SIZE, 0, 0, errbuf); if (pch != NULL) { /* * It worked; we can use the "any" device. */ if_info = if_info_new("any", "Pseudo-device that captures on all interfaces", FALSE); il = g_list_insert(il, if_info, -1); pcap_close(pch); } #endif g_free(ifc.ifc_buf); close(sock); if (il == NULL) { /* * No interfaces found. */ *err = 0; if (err_str != NULL) *err_str = NULL; } return il; fail: if (il != NULL) free_interface_list(il); g_free(ifc.ifc_buf); close(sock); *err = CANT_GET_INTERFACE_LIST; return NULL; }
void CaptureInterfacesDialog::UpdateInterfaces() { ui->cbPcap->setCurrentIndex(!prefs.capture_pcap_ng); ui->capturePromModeCheckBox->setChecked(prefs.capture_prom_mode); ui->cbStopCaptureAuto->setChecked(global_capture_opts.has_file_duration); ui->cbNewFileAuto->setChecked(global_capture_opts.multi_files_on); ui->cbUpdatePacketsRT->setChecked(global_capture_opts.real_time_mode); ui->cbAutoScroll->setChecked(true); ui->cbExtraCaptureInfo->setChecked(global_capture_opts.show_info); ui->cbResolveMacAddresses->setChecked(gbl_resolv_flags.mac_name); ui->cbResolveNetworkNames->setChecked(gbl_resolv_flags.network_name); ui->cbResolveTransportNames->setChecked(gbl_resolv_flags.transport_name); ui->tbInterfaces->setRowCount(0); GList *if_list; int err; gchar *err_str = NULL; GList *list; char *snaplen_string, *linkname; //guint i; link_row *linkr = NULL; //interface_t device; #if defined(_WIN32) || defined(HAVE_PCAP_CREATE) gint buffer; #endif gint snaplen; gboolean hassnap, pmode; if_list = capture_interface_list(&err, &err_str,main_window_update); if_list = g_list_sort(if_list, if_list_comparator_alph); // XXX Do we need to check for this? capture_interface_list returns an error if the length is 0. if (g_list_length(if_list) > 0) { interface_t device; //setDisabled(false); for (guint i = 0; i < global_capture_opts.all_ifaces->len; i++) { QList<int> *points; device = g_array_index(global_capture_opts.all_ifaces, interface_t, i); /* Continue if capture device is hidden */ if (device.hidden) { continue; } QString output; ui->tbInterfaces->setRowCount(ui->tbInterfaces->rowCount() + 1); QTableWidgetItem *cbSelected = new QTableWidgetItem(); cbSelected->setCheckState(device.selected ? Qt::Checked : Qt::Unchecked); ui->tbInterfaces->setItem(ui->tbInterfaces->rowCount()-1, CAPTURE, cbSelected); // traffic lines ui->tbInterfaces->setItemDelegateForColumn(TRAFFIC, new SparkLineDelegate()); points = new QList<int>(); QTableWidgetItem *ti = new QTableWidgetItem(); ti->setData(Qt::UserRole, qVariantFromValue(points)); ui->tbInterfaces->setItem(ui->tbInterfaces->rowCount()-1, TRAFFIC, ti); output = QString(device.display_name); ui->tbInterfaces->setItem(ui->tbInterfaces->rowCount()-1, INTERFACE, new QTableWidgetItem(output)); linkname = NULL; if(capture_dev_user_linktype_find(device.name) != -1) { device.active_dlt = capture_dev_user_linktype_find(device.name); } for (list = device.links; list != NULL; list = g_list_next(list)) { linkr = (link_row*)(list->data); if (linkr->dlt == device.active_dlt) { linkname = g_strdup(linkr->name); break; } } if (!linkname) linkname = g_strdup("unknown"); pmode = capture_dev_user_pmode_find(device.name); if (pmode != -1) { device.pmode = pmode; } hassnap = capture_dev_user_hassnap_find(device.name); snaplen = capture_dev_user_snaplen_find(device.name); if(snaplen != -1 && hassnap != -1) { /* Default snap lenght set in preferences */ device.snaplen = snaplen; device.has_snaplen = hassnap; } else { /* No preferences set yet, use default values */ device.snaplen = WTAP_MAX_PACKET_SIZE; device.has_snaplen = FALSE; } if (device.has_snaplen) { snaplen_string = g_strdup_printf("%d", device.snaplen); } else { snaplen_string = g_strdup("default"); } #if defined(_WIN32) || defined(HAVE_PCAP_CREATE) if (capture_dev_user_buffersize_find(device.name) != -1) { buffer = capture_dev_user_buffersize_find(device.name); device.buffer = buffer; } else { device.buffer = DEFAULT_CAPTURE_BUFFER_SIZE; } #endif output = QString(linkname); ui->tbInterfaces->setItem(ui->tbInterfaces->rowCount()-1, LINK, new QTableWidgetItem(output)); output = QString(device.pmode ? "true" : "false"); ui->tbInterfaces->setItem(ui->tbInterfaces->rowCount()-1, PMODE, new QTableWidgetItem(output)); output = QString(snaplen_string); ui->tbInterfaces->setItem(ui->tbInterfaces->rowCount()-1, SNAPLEN, new QTableWidgetItem(output)); output = QString().sprintf("%d", device.buffer); ui->tbInterfaces->setItem(ui->tbInterfaces->rowCount()-1, BUFFER, new QTableWidgetItem(output)); #if defined (HAVE_PCAP_CREATE) output = QString(device.monitor_mode_enabled ? "true" : "false"); ui->tbInterfaces->setItem(ui->tbInterfaces->rowCount()-1, MONITOR, new QTableWidgetItem(output)); #endif if (strstr(prefs.capture_device, device.name) != NULL) { device.selected = TRUE; global_capture_opts.num_selected++; global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i); g_array_insert_val(global_capture_opts.all_ifaces, i, device); } if (device.selected) { ui->tbInterfaces->item(ui->tbInterfaces->rowCount()-1, 0)->setSelected(true); } } } free_interface_list(if_list); resizeEvent(NULL); if (!stat_timer_) { updateStatistics(); stat_timer_ = new QTimer(this); connect(stat_timer_, SIGNAL(timeout()), this, SLOT(updateStatistics())); stat_timer_->start(stat_update_interval_); } }
InterfaceTree::InterfaceTree(QWidget *parent) : QTreeWidget(parent) { GList *if_list; QTreeWidgetItem *ti; int err; gchar *err_str = NULL; header()->setVisible(false); setRootIsDecorated(false); setUniformRowHeights(true); setColumnCount(2); setAccessibleName(tr("Welcome screen list")); stat_cache_ = NULL; stat_timer_ = new QTimer(this); connect(stat_timer_, SIGNAL(timeout()), this, SLOT(updateStatistics())); setItemDelegateForColumn(1, new SparkLineDelegate()); if_list = capture_interface_list(&err, &err_str); if_list = g_list_sort(if_list, if_list_comparator_alph); if (if_list == NULL) { setDisabled(true); ti = new QTreeWidgetItem(); ti->setText(0, QString(tr("No interfaces found\n%1")).arg(QString().fromUtf8(err_str))); g_free(err_str); addTopLevelItem(ti); return; } else if (err_str) { g_free(err_str); } // XXX Do we need to check for this? capture_interface_list returns an error if the length is 0. if (g_list_length(if_list) > 0) { if_info_t *if_info; GList *curr; setDisabled(false); for (curr = g_list_first(if_list); curr; curr = g_list_next(curr)) { QList<int> *points; QVariant v; if_info = (if_info_t *) curr->data; /* Continue if capture device is hidden */ if (prefs_is_capture_device_hidden(if_info->name)) { continue; } ti = new QTreeWidgetItem(); // XXX Using if_info->name is amazingly ugly under Windows but it's needed for // statistics updates // ti->setText(0, QString().fromUtf8(if_info->description ? if_info->description : if_info->name)); ti->setText(0, QString().fromUtf8(if_info->name)); points = new QList<int>(); v.setValue(points); ti->setData(1, Qt::UserRole, v); addTopLevelItem(ti); resizeColumnToContents(1); } } free_interface_list(if_list); }