static void
add_details (GtkWidget *details, NMDevice *device, NMConnection *connection)
{
NMIP4Config *ip4_config = NULL;
NMIP6Config *ip6_config = NULL;
gchar *ip4_address = NULL;
gchar *ip4_route = NULL;
gchar *ip4_dns = NULL;
gchar *ip6_address = NULL;
gint i = 0;
ip4_config = nm_device_get_ip4_config (device);
if (ip4_config) {
ip4_address = panel_get_ip4_address_as_string (ip4_config, "address");
ip4_route = panel_get_ip4_address_as_string (ip4_config, "gateway");
ip4_dns = panel_get_ip4_dns_as_string (ip4_config);
}
ip6_config = nm_device_get_ip6_config (device);
if (ip6_config) {
ip6_address = panel_get_ip6_address_as_string (ip6_config);
}
if (ip4_address && ip6_address) {
add_details_row (details, i++, _("IPv4 Address"), ip4_address);
add_details_row (details, i++, _("IPv6 Address"), ip6_address);
} else if (ip4_address) {
add_details_row (details, i++, _("IP Address"), ip4_address);
} else if (ip6_address) {
add_details_row (details, i++, _("IPv6 Address"), ip6_address);
}
add_details_row (details, i++, _("Hardware Address"),
nm_device_ethernet_get_hw_address (NM_DEVICE_ETHERNET (device)));
if (ip4_route)
add_details_row (details, i++, _("Default Route"), ip4_route);
if (ip4_dns)
add_details_row (details, i++, _("DNS"), ip4_dns);
if (nm_device_get_state (device) != NM_DEVICE_STATE_ACTIVATED) {
gchar *last_used;
last_used = get_last_used_string (connection);
add_details_row (details, i++, _("Last used"), last_used);
g_free (last_used);
}
g_free (ip4_address);
g_free (ip4_route);
g_free (ip4_dns);
g_free (ip6_address);
}
static void
fill_device_props (NMDevice *device,
GVariantBuilder *dev_builder,
GVariantBuilder *proxy_builder,
GVariantBuilder *ip4_builder,
GVariantBuilder *ip6_builder,
GVariant **dhcp4_props,
GVariant **dhcp6_props)
{
NMProxyConfig *proxy_config;
NMIP4Config *ip4_config;
NMIP6Config *ip6_config;
NMDhcp4Config *dhcp4_config;
NMDhcp6Config *dhcp6_config;
/* If the action is for a VPN, send the VPN's IP interface instead of the device's */
g_variant_builder_add (dev_builder, "{sv}", NMD_DEVICE_PROPS_IP_INTERFACE,
g_variant_new_string (nm_device_get_ip_iface (device)));
g_variant_builder_add (dev_builder, "{sv}", NMD_DEVICE_PROPS_INTERFACE,
g_variant_new_string (nm_device_get_iface (device)));
g_variant_builder_add (dev_builder, "{sv}", NMD_DEVICE_PROPS_TYPE,
g_variant_new_uint32 (nm_device_get_device_type (device)));
g_variant_builder_add (dev_builder, "{sv}", NMD_DEVICE_PROPS_STATE,
g_variant_new_uint32 (nm_device_get_state (device)));
if (nm_exported_object_is_exported (NM_EXPORTED_OBJECT (device)))
g_variant_builder_add (dev_builder, "{sv}", NMD_DEVICE_PROPS_PATH,
g_variant_new_object_path (nm_exported_object_get_path (NM_EXPORTED_OBJECT (device))));
proxy_config = nm_device_get_proxy_config (device);
if (proxy_config)
dump_proxy_to_props (proxy_config, proxy_builder);
ip4_config = nm_device_get_ip4_config (device);
if (ip4_config)
dump_ip4_to_props (ip4_config, ip4_builder);
ip6_config = nm_device_get_ip6_config (device);
if (ip6_config)
dump_ip6_to_props (ip6_config, ip6_builder);
dhcp4_config = nm_device_get_dhcp4_config (device);
if (dhcp4_config)
*dhcp4_props = nm_dhcp4_config_get_options (dhcp4_config);
dhcp6_config = nm_device_get_dhcp6_config (device);
if (dhcp6_config)
*dhcp6_props = nm_dhcp6_config_get_options (dhcp6_config);
}
static void
get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
NMDevice *device = NM_DEVICE (object);
switch (prop_id) {
case PROP_UDI:
g_value_set_string (value, nm_device_get_udi (device));
break;
case PROP_INTERFACE:
g_value_set_string (value, nm_device_get_iface (device));
break;
case PROP_DRIVER:
g_value_set_string (value, nm_device_get_driver (device));
break;
case PROP_CAPABILITIES:
g_value_set_uint (value, nm_device_get_capabilities (device));
break;
case PROP_MANAGED:
g_value_set_boolean (value, nm_device_get_managed (device));
break;
case PROP_IP4_CONFIG:
g_value_set_object (value, nm_device_get_ip4_config (device));
break;
case PROP_DHCP4_CONFIG:
g_value_set_object (value, nm_device_get_dhcp4_config (device));
break;
case PROP_IP6_CONFIG:
g_value_set_object (value, nm_device_get_ip6_config (device));
break;
case PROP_STATE:
g_value_set_uint (value, nm_device_get_state (device));
break;
case PROP_PRODUCT:
g_value_set_string (value, nm_device_get_product (device));
break;
case PROP_VENDOR:
g_value_set_string (value, nm_device_get_vendor (device));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
show_generic_info (NMDevice * device)
{
const char *ifname, *uid, *driver;
gboolean managed;
NMDeviceState state;
NMIP4Config * ip4;
NMIP6Config * ip6;
g_return_if_fail (NM_IS_DEVICE (device));
ifname = nm_device_get_iface (device);
managed = nm_device_get_managed (device);
if (managed) {
state = nm_device_get_state (device);
ip4 = nm_device_get_ip4_config (device);
ip6 = nm_device_get_ip6_config (device);
driver = nm_device_get_driver (device);
uid = nm_device_get_udi (device);
//TODO: show active connection name
g_print("%-9s State:%s Connection:%s\n", ifname, device_state_to_string(state), "Not implemented");
print_ip4_info (ip4);
print_ip6_info (ip6);
if (driver || uid) {
g_print("%-9s ", "");
if (driver)
g_print("Driver:%s ", driver);
if (uid)
g_print("UID:%s", uid);
g_print ("\n");
}
}
else {
g_print("%-9s Device is not managed by NetworkManager\n", ifname);
}
}
static void
detail_device (gpointer data, gpointer user_data)
{
NMDevice *device = NM_DEVICE (data);
char *tmp;
NMDeviceState state;
guint32 caps;
guint32 speed;
const GArray *array;
gboolean is_default = FALSE;
const char *id = NULL;
NMActiveConnection *active;
active = nm_device_get_active_connection (device);
if (active) {
NMConnection *connection;
NMSettingConnection *s_con;
is_default = nm_active_connection_get_default (active);
connection = get_connection_for_active (active);
if (connection) {
s_con = nm_connection_get_setting_connection (connection);
if (s_con)
id = nm_setting_connection_get_id (s_con);
}
}
print_header ("Device", nm_device_get_iface (device), id);
/* General information */
if (NM_IS_DEVICE_ETHERNET (device))
print_string ("Type", "Wired");
else if (NM_IS_DEVICE_WIFI (device))
print_string ("Type", "802.11 WiFi");
else if (NM_IS_DEVICE_MODEM (device)) {
NMDeviceModemCapabilities modem_caps;
modem_caps = nm_device_modem_get_current_capabilities (NM_DEVICE_MODEM (device));
if (modem_caps & NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS)
print_string ("Type", "Mobile Broadband (GSM)");
else if (modem_caps & NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO)
print_string ("Type", "Mobile Broadband (CDMA)");
else
print_string ("Type", "Mobile Broadband (unknown)");
} else if (NM_IS_DEVICE_BT (device))
print_string ("Type", "Bluetooth");
else if (NM_IS_DEVICE_WIMAX (device))
print_string ("Type", "WiMAX");
print_string ("Driver", nm_device_get_driver (device) ? nm_device_get_driver (device) : "(unknown)");
state = nm_device_get_state (device);
print_string ("State", get_dev_state_string (state));
if (is_default)
print_string ("Default", "yes");
else
print_string ("Default", "no");
tmp = NULL;
if (NM_IS_DEVICE_ETHERNET (device))
tmp = g_strdup (nm_device_ethernet_get_hw_address (NM_DEVICE_ETHERNET (device)));
else if (NM_IS_DEVICE_WIFI (device))
tmp = g_strdup (nm_device_wifi_get_hw_address (NM_DEVICE_WIFI (device)));
else if (NM_IS_DEVICE_WIMAX (device))
tmp = g_strdup (nm_device_wimax_get_hw_address (NM_DEVICE_WIMAX (device)));
if (tmp) {
print_string ("HW Address", tmp);
g_free (tmp);
}
/* Capabilities */
caps = nm_device_get_capabilities (device);
printf ("\n Capabilities:\n");
if (caps & NM_DEVICE_CAP_CARRIER_DETECT)
print_string (" Carrier Detect", "yes");
speed = 0;
if (NM_IS_DEVICE_ETHERNET (device)) {
/* Speed in Mb/s */
speed = nm_device_ethernet_get_speed (NM_DEVICE_ETHERNET (device));
} else if (NM_IS_DEVICE_WIFI (device)) {
/* Speed in b/s */
speed = nm_device_wifi_get_bitrate (NM_DEVICE_WIFI (device));
speed /= 1000;
}
if (speed) {
char *speed_string;
speed_string = g_strdup_printf ("%u Mb/s", speed);
print_string (" Speed", speed_string);
g_free (speed_string);
}
/* Wireless specific information */
if ((NM_IS_DEVICE_WIFI (device))) {
guint32 wcaps;
NMAccessPoint *active_ap = NULL;
const char *active_bssid = NULL;
const GPtrArray *aps;
printf ("\n Wireless Properties\n");
wcaps = nm_device_wifi_get_capabilities (NM_DEVICE_WIFI (device));
if (wcaps & (NM_WIFI_DEVICE_CAP_CIPHER_WEP40 | NM_WIFI_DEVICE_CAP_CIPHER_WEP104))
print_string (" WEP Encryption", "yes");
if (wcaps & NM_WIFI_DEVICE_CAP_WPA)
print_string (" WPA Encryption", "yes");
if (wcaps & NM_WIFI_DEVICE_CAP_RSN)
print_string (" WPA2 Encryption", "yes");
if (nm_device_get_state (device) == NM_DEVICE_STATE_ACTIVATED) {
active_ap = nm_device_wifi_get_active_access_point (NM_DEVICE_WIFI (device));
active_bssid = active_ap ? nm_access_point_get_hw_address (active_ap) : NULL;
}
printf ("\n Wireless Access Points %s\n", active_ap ? "(* = current AP)" : "");
aps = nm_device_wifi_get_access_points (NM_DEVICE_WIFI (device));
if (aps && aps->len)
g_ptr_array_foreach ((GPtrArray *) aps, detail_access_point, (gpointer) active_bssid);
} else if (NM_IS_DEVICE_ETHERNET (device)) {
printf ("\n Wired Properties\n");
if (nm_device_ethernet_get_carrier (NM_DEVICE_ETHERNET (device)))
print_string (" Carrier", "on");
else
print_string (" Carrier", "off");
} else if (NM_IS_DEVICE_WIMAX (device)) {
NMDeviceWimax *wimax = NM_DEVICE_WIMAX (device);
NMWimaxNsp *active_nsp = NULL;
const char *active_name = NULL;
const GPtrArray *nsps;
if (nm_device_get_state (device) == NM_DEVICE_STATE_ACTIVATED) {
guint tmp_uint;
gint tmp_int;
const char *tmp_str;
active_nsp = nm_device_wimax_get_active_nsp (wimax);
active_name = active_nsp ? nm_wimax_nsp_get_name (active_nsp) : NULL;
printf ("\n Link Status\n");
tmp_uint = nm_device_wimax_get_center_frequency (wimax);
if (tmp_uint)
tmp = g_strdup_printf ("%'.1f MHz", (double) tmp_uint / 1000.0);
else
tmp = g_strdup ("(unknown)");
print_string (" Center Freq.", tmp);
g_free (tmp);
tmp_int = nm_device_wimax_get_rssi (wimax);
if (tmp_int)
tmp = g_strdup_printf ("%d dBm", tmp_int);
else
tmp = g_strdup ("(unknown)");
print_string (" RSSI", tmp);
g_free (tmp);
tmp_int = nm_device_wimax_get_cinr (wimax);
if (tmp_int)
tmp = g_strdup_printf ("%d dB", tmp_int);
else
tmp = g_strdup ("(unknown)");
print_string (" CINR", tmp);
g_free (tmp);
tmp_int = nm_device_wimax_get_tx_power (wimax);
if (tmp_int)
tmp = g_strdup_printf ("%'.2f dBm", (float) tmp_int / 2.0);
else
tmp = g_strdup ("(unknown)");
print_string (" TX Power", tmp);
g_free (tmp);
tmp_str = nm_device_wimax_get_bsid (wimax);
if (tmp_str)
print_string (" BSID", tmp_str);
else
print_string (" BSID", "(unknown)");
}
printf ("\n WiMAX NSPs %s\n", active_nsp ? "(* current NSP)" : "");
nsps = nm_device_wimax_get_nsps (NM_DEVICE_WIMAX (device));
if (nsps && nsps->len)
g_ptr_array_foreach ((GPtrArray *) nsps, detail_nsp, (gpointer) active_name);
}
/* IP Setup info */
if (state == NM_DEVICE_STATE_ACTIVATED) {
NMIP4Config *cfg4 = nm_device_get_ip4_config (device);
NMIP6Config *cfg6 = nm_device_get_ip6_config (device);
GSList *iter;
if (cfg4) {
printf ("\n IPv4 Settings:\n");
for (iter = (GSList *) nm_ip4_config_get_addresses (cfg4); iter; iter = g_slist_next (iter)) {
NMIP4Address *addr = (NMIP4Address *) iter->data;
guint32 prefix = nm_ip4_address_get_prefix (addr);
char *tmp2;
tmp = ip4_address_as_string (nm_ip4_address_get_address (addr));
print_string (" Address", tmp);
g_free (tmp);
tmp2 = ip4_address_as_string (nm_utils_ip4_prefix_to_netmask (prefix));
tmp = g_strdup_printf ("%d (%s)", prefix, tmp2);
g_free (tmp2);
print_string (" Prefix", tmp);
g_free (tmp);
tmp = ip4_address_as_string (nm_ip4_address_get_gateway (addr));
print_string (" Gateway", tmp);
g_free (tmp);
printf ("\n");
}
array = nm_ip4_config_get_nameservers (cfg4);
if (array) {
int i;
for (i = 0; i < array->len; i++) {
tmp = ip4_address_as_string (g_array_index (array, guint32, i));
print_string (" DNS", tmp);
g_free (tmp);
}
}
}
if (cfg6) {
printf ("\n IPv6 Settings:\n");
for (iter = (GSList *) nm_ip6_config_get_addresses (cfg6); iter; iter = g_slist_next (iter)) {
NMIP6Address *addr = (NMIP6Address *) iter->data;
guint32 prefix = nm_ip6_address_get_prefix (addr);
tmp = ip6_address_as_string (nm_ip6_address_get_address (addr));
print_string (" Address", tmp);
g_free (tmp);
tmp = g_strdup_printf ("%d", prefix);
print_string (" Prefix", tmp);
g_free (tmp);
tmp = ip6_address_as_string (nm_ip6_address_get_gateway (addr));
print_string (" Gateway", tmp);
g_free (tmp);
printf ("\n");
}
for (iter = (GSList *) nm_ip6_config_get_nameservers (cfg6); iter; iter = g_slist_next (iter)) {
tmp = ip6_address_as_string (iter->data);
print_string (" DNS", tmp);
g_free (tmp);
}
}
}
printf ("\n\n");
}
static void
update_ip6_routing_and_dns (NMPolicy *policy, gboolean force_update)
{
NMDnsIPConfigType dns_type = NM_DNS_IP_CONFIG_TYPE_BEST_DEVICE;
NMDevice *best = NULL;
NMActRequest *best_req = NULL;
NMDnsManager *dns_mgr;
GSList *devices = NULL, *iter;
#if NOT_YET
GSList *vpns;
#endif
NMIP6Config *ip6_config = NULL;
NMIP6Address *addr;
const char *ip_iface = NULL;
NMConnection *connection = NULL;
NMSettingConnection *s_con = NULL;
const char *connection_id;
best = get_best_ip6_device (policy->manager, &best_req);
if (!best)
goto out;
if (!force_update && (best == policy->default_device6))
goto out;
#if NOT_YET
/* If a VPN connection is active, it is preferred */
vpns = nm_vpn_manager_get_active_connections (policy->vpn_manager);
for (iter = vpns; iter; iter = g_slist_next (iter)) {
NMVPNConnection *candidate = NM_VPN_CONNECTION (iter->data);
NMConnection *vpn_connection;
NMSettingIP6Config *s_ip6;
gboolean can_default = TRUE;
NMVPNConnectionState vpn_state;
/* If it's marked 'never-default', don't make it default */
vpn_connection = nm_vpn_connection_get_connection (candidate);
g_assert (vpn_connection);
s_ip6 = (NMSettingIP6Config *) nm_connection_get_setting (vpn_connection, NM_TYPE_SETTING_IP6_CONFIG);
if (s_ip6 && nm_setting_ip6_config_get_never_default (s_ip6))
can_default = FALSE;
vpn_state = nm_vpn_connection_get_vpn_state (candidate);
if (can_default && (vpn_state == NM_VPN_CONNECTION_STATE_ACTIVATED)) {
NMIP6Config *parent_ip6;
NMDevice *parent;
ip_iface = nm_vpn_connection_get_ip_iface (candidate);
connection = nm_vpn_connection_get_connection (candidate);
ip6_config = nm_vpn_connection_get_ip6_config (candidate);
addr = nm_ip6_config_get_address (ip6_config, 0);
parent = nm_vpn_connection_get_parent_device (candidate);
parent_ip6 = nm_device_get_ip6_config (parent);
nm_system_replace_default_ip6_route_vpn (ip_iface,
nm_ip6_address_get_gateway (addr),
nm_vpn_connection_get_ip4_internal_gateway (candidate),
nm_ip6_config_get_mss (ip4_config),
nm_device_get_ip_iface (parent),
nm_ip6_config_get_mss (parent_ip4));
dns_type = NM_DNS_IP_CONFIG_TYPE_VPN;
}
g_object_unref (candidate);
}
g_slist_free (vpns);
#endif
/* The best device gets the default route if a VPN connection didn't */
if (!ip_iface || !ip6_config) {
connection = nm_act_request_get_connection (best_req);
ip_iface = nm_device_get_ip_iface (best);
ip6_config = nm_device_get_ip6_config (best);
g_assert (ip6_config);
addr = nm_ip6_config_get_address (ip6_config, 0);
nm_system_replace_default_ip6_route (ip_iface, nm_ip6_address_get_gateway (addr));
dns_type = NM_DNS_IP_CONFIG_TYPE_BEST_DEVICE;
}
if (!ip_iface || !ip6_config) {
nm_log_warn (LOGD_CORE, "couldn't determine IP interface (%p) or IPv6 config (%p)!",
ip_iface, ip6_config);
goto out;
}
/* Update the default active connection. Only mark the new default
* active connection after setting default = FALSE on all other connections
* first. The order is important, we don't want two connections marked
* default at the same time ever.
*/
devices = nm_manager_get_devices (policy->manager);
for (iter = devices; iter; iter = g_slist_next (iter)) {
NMDevice *dev = NM_DEVICE (iter->data);
NMActRequest *req;
req = nm_device_get_act_request (dev);
if (req && (req != best_req))
nm_act_request_set_default6 (req, FALSE);
}
dns_mgr = nm_dns_manager_get (NULL);
nm_dns_manager_add_ip6_config (dns_mgr, ip_iface, ip6_config, dns_type);
g_object_unref (dns_mgr);
/* Now set new default active connection _after_ updating DNS info, so that
* if the connection is shared dnsmasq picks up the right stuff.
*/
if (best_req)
nm_act_request_set_default6 (best_req, TRUE);
if (connection)
s_con = (NMSettingConnection *) nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION);
connection_id = s_con ? nm_setting_connection_get_id (s_con) : NULL;
if (connection_id) {
nm_log_info (LOGD_CORE, "Policy set '%s' (%s) as default for IPv6 routing and DNS.", connection_id, ip_iface);
} else {
nm_log_info (LOGD_CORE, "Policy set (%s) as default for IPv6 routing and DNS.", ip_iface);
}
out:
policy->default_device6 = best;
}
static void
update_system_hostname (NMPolicy *policy, NMDevice *best4, NMDevice *best6)
{
char *configured_hostname = NULL;
NMActRequest *best_req4 = NULL;
NMActRequest *best_req6 = NULL;
const char *dhcp_hostname, *p;
g_return_if_fail (policy != NULL);
if (policy->lookup) {
hostname_thread_kill (policy->lookup);
policy->lookup = NULL;
}
/* Hostname precedence order:
*
* 1) a configured hostname (from system-settings)
* 2) automatic hostname from the default device's config (DHCP, VPN, etc)
* 3) the original hostname when NM started
* 4) reverse-DNS of the best device's IPv4 address
*
*/
/* Try a persistent hostname first */
g_object_get (G_OBJECT (policy->manager), NM_MANAGER_HOSTNAME, &configured_hostname, NULL);
if (configured_hostname) {
_set_hostname (policy, TRUE, configured_hostname, "from system configuration");
g_free (configured_hostname);
return;
}
/* Try automatically determined hostname from the best device's IP config */
if (!best4)
best4 = get_best_ip4_device (policy->manager, &best_req4);
if (!best6)
best6 = get_best_ip6_device (policy->manager, &best_req6);
if (!best4 && !best6) {
/* No best device; fall back to original hostname or if there wasn't
* one, 'localhost.localdomain'
*/
_set_hostname (policy, TRUE, policy->orig_hostname, "no default device");
return;
}
if (best4) {
NMDHCP4Config *dhcp4_config;
/* Grab a hostname out of the device's DHCP4 config */
dhcp4_config = nm_device_get_dhcp4_config (best4);
if (dhcp4_config) {
p = dhcp_hostname = nm_dhcp4_config_get_option (dhcp4_config, "host_name");
if (dhcp_hostname && strlen (dhcp_hostname)) {
/* Sanity check; strip leading spaces */
while (*p) {
if (!isblank (*p++)) {
_set_hostname (policy, TRUE, dhcp_hostname, "from DHCPv4");
return;
}
}
nm_log_warn (LOGD_DNS, "DHCPv4-provided hostname '%s' looks invalid; ignoring it",
dhcp_hostname);
}
}
} else if (best6) {
NMDHCP6Config *dhcp6_config;
/* Grab a hostname out of the device's DHCP4 config */
dhcp6_config = nm_device_get_dhcp6_config (best6);
if (dhcp6_config) {
p = dhcp_hostname = nm_dhcp6_config_get_option (dhcp6_config, "host_name");
if (dhcp_hostname && strlen (dhcp_hostname)) {
/* Sanity check; strip leading spaces */
while (*p) {
if (!isblank (*p++)) {
_set_hostname (policy, TRUE, dhcp_hostname, "from DHCPv6");
return;
}
}
nm_log_warn (LOGD_DNS, "DHCPv6-provided hostname '%s' looks invalid; ignoring it",
dhcp_hostname);
}
}
}
/* If no automatically-configured hostname, try using the hostname from
* when NM started up.
*/
if (policy->orig_hostname) {
_set_hostname (policy, TRUE, policy->orig_hostname, "from system startup");
return;
}
/* No configured hostname, no automatically determined hostname, and no
* bootup hostname. Start reverse DNS of the current IPv4 or IPv6 address.
*/
if (best4) {
NMIP4Config *ip4_config;
NMIP4Address *addr4;
ip4_config = nm_device_get_ip4_config (best4);
if ( !ip4_config
|| (nm_ip4_config_get_num_nameservers (ip4_config) == 0)
|| (nm_ip4_config_get_num_addresses (ip4_config) == 0)) {
/* No valid IP4 config (!!); fall back to localhost.localdomain */
_set_hostname (policy, TRUE, NULL, "no IPv4 config");
return;
}
addr4 = nm_ip4_config_get_address (ip4_config, 0);
g_assert (addr4); /* checked for > 1 address above */
/* Start the hostname lookup thread */
policy->lookup = hostname4_thread_new (nm_ip4_address_get_address (addr4), lookup_callback, policy);
} else if (best6) {
NMIP6Config *ip6_config;
NMIP6Address *addr6;
ip6_config = nm_device_get_ip6_config (best6);
if ( !ip6_config
|| (nm_ip6_config_get_num_nameservers (ip6_config) == 0)
|| (nm_ip6_config_get_num_addresses (ip6_config) == 0)) {
/* No valid IP6 config (!!); fall back to localhost.localdomain */
_set_hostname (policy, TRUE, NULL, "no IPv6 config");
return;
}
addr6 = nm_ip6_config_get_address (ip6_config, 0);
g_assert (addr6); /* checked for > 1 address above */
/* Start the hostname lookup thread */
policy->lookup = hostname6_thread_new (nm_ip6_address_get_address (addr6), lookup_callback, policy);
}
if (!policy->lookup) {
/* Fall back to 'localhost.localdomain' */
_set_hostname (policy, TRUE, NULL, "error starting hostname thread");
}
}
static NMDevice *
get_best_ip6_device (NMManager *manager, NMActRequest **out_req)
{
GSList *devices, *iter;
NMDevice *best = NULL;
int best_prio = G_MAXINT;
g_return_val_if_fail (manager != NULL, NULL);
g_return_val_if_fail (NM_IS_MANAGER (manager), NULL);
g_return_val_if_fail (out_req != NULL, NULL);
g_return_val_if_fail (*out_req == NULL, NULL);
devices = nm_manager_get_devices (manager);
for (iter = devices; iter; iter = g_slist_next (iter)) {
NMDevice *dev = NM_DEVICE (iter->data);
NMActRequest *req;
NMConnection *connection;
NMIP6Config *ip6_config;
NMSettingIP6Config *s_ip6;
int prio;
guint i;
gboolean can_default = FALSE;
const char *method = NULL;
if (nm_device_get_state (dev) != NM_DEVICE_STATE_ACTIVATED)
continue;
ip6_config = nm_device_get_ip6_config (dev);
if (!ip6_config)
continue;
req = nm_device_get_act_request (dev);
g_assert (req);
connection = nm_act_request_get_connection (req);
g_assert (connection);
/* Never set the default route through an IPv4LL-addressed device */
s_ip6 = (NMSettingIP6Config *) nm_connection_get_setting (connection, NM_TYPE_SETTING_IP6_CONFIG);
if (s_ip6)
method = nm_setting_ip6_config_get_method (s_ip6);
if (method && !strcmp (method, NM_SETTING_IP6_CONFIG_METHOD_LINK_LOCAL))
continue;
/* Make sure at least one of this device's IP addresses has a gateway */
for (i = 0; i < nm_ip6_config_get_num_addresses (ip6_config); i++) {
NMIP6Address *addr;
addr = nm_ip6_config_get_address (ip6_config, i);
if (nm_ip6_address_get_gateway (addr)) {
can_default = TRUE;
break;
}
}
if (!can_default && !NM_IS_DEVICE_MODEM (dev))
continue;
/* 'never-default' devices can't ever be the default */
if (s_ip6 && nm_setting_ip6_config_get_never_default (s_ip6))
continue;
prio = nm_device_get_priority (dev);
if (prio > 0 && prio < best_prio) {
best = dev;
best_prio = prio;
*out_req = req;
}
}
return best;
}
void
panel_set_device_widgets (GtkBuilder *builder, NMDevice *device)
{
NMIP4Config *ip4_config = NULL;
NMIP6Config *ip6_config = NULL;
gboolean has_ip4;
gboolean has_ip6;
gchar *str_tmp;
/* get IPv4 parameters */
ip4_config = nm_device_get_ip4_config (device);
if (ip4_config != NULL) {
/* IPv4 address */
str_tmp = panel_get_ip4_address_as_string (ip4_config, "address");
panel_set_device_widget_details (builder,
"ipv4",
str_tmp);
has_ip4 = str_tmp != NULL;
g_free (str_tmp);
/* IPv4 DNS */
str_tmp = panel_get_ip4_dns_as_string (ip4_config);
panel_set_device_widget_details (builder,
"dns",
str_tmp);
g_free (str_tmp);
/* IPv4 route */
str_tmp = panel_get_ip4_address_as_string (ip4_config, "gateway");
panel_set_device_widget_details (builder,
"route",
str_tmp);
g_free (str_tmp);
} else {
/* IPv4 address */
panel_set_device_widget_details (builder,
"ipv4",
NULL);
has_ip4 = FALSE;
/* IPv4 DNS */
panel_set_device_widget_details (builder,
"dns",
NULL);
/* IPv4 route */
panel_set_device_widget_details (builder,
"route",
NULL);
}
/* get IPv6 parameters */
ip6_config = nm_device_get_ip6_config (device);
if (ip6_config != NULL) {
str_tmp = panel_get_ip6_address_as_string (ip6_config);
panel_set_device_widget_details (builder, "ipv6", str_tmp);
has_ip6 = str_tmp != NULL;
g_free (str_tmp);
} else {
panel_set_device_widget_details (builder, "ipv6", NULL);
has_ip6 = FALSE;
}
if (has_ip4 && has_ip6) {
panel_set_device_widget_header (builder, "ipv4", _("IPv4 Address"));
panel_set_device_widget_header (builder, "ipv6", _("IPv6 Address"));
} else if (has_ip4) {
panel_set_device_widget_header (builder, "ipv4", _("IP Address"));
} else if (has_ip6) {
panel_set_device_widget_header (builder, "ipv6", _("IP Address"));
}
}
static void
synchronize_device (Network *self,
NMDevice *device)
{
const char *iface_name = nm_device_get_iface (device);
Netinterface *iface;
NMIP4Config *ip4config;
NMIP6Config *ip6config;
iface = g_hash_table_lookup (self->ifname_to_netinterface,
iface_name);
g_assert (iface);
cockpit_network_netinterface_set_name (COCKPIT_NETWORK_NETINTERFACE (iface), iface_name);
ip4config = nm_device_get_ip4_config (device);
if (ip4config)
{
const GSList *addresses = nm_ip4_config_get_addresses (ip4config);
const GSList *iter;
GVariantBuilder builder;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a(yyyyu)"));
for (iter = addresses; iter; iter = iter->next)
{
NMIP4Address *ip4addr = iter->data;
guint32 ipaddr = ntohl (nm_ip4_address_get_address (ip4addr));
guint32 prefix = nm_ip4_address_get_prefix (ip4addr);
g_variant_builder_add_value (&builder, ip4_addr_variant_new (ipaddr, prefix));
}
cockpit_network_netinterface_set_ip4_addresses (COCKPIT_NETWORK_NETINTERFACE (iface), g_variant_builder_end (&builder));
}
ip6config = nm_device_get_ip6_config (device);
if (ip6config)
{
const GSList *addresses = nm_ip6_config_get_addresses (ip6config);
const GSList *iter;
GVariantBuilder builder;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a(yyyyyyyyyyyyyyyyu)"));
for (iter = addresses; iter; iter = iter->next)
{
NMIP6Address *ip6addr = iter->data;
g_variant_builder_add_value (&builder, ip6_addr_variant_new (nm_ip6_address_get_address (ip6addr),
nm_ip6_address_get_prefix (ip6addr)));
}
cockpit_network_netinterface_set_ip6_addresses (COCKPIT_NETWORK_NETINTERFACE (iface), g_variant_builder_end (&builder));
}
synchronize_device_config (self, iface, device);
switch (nm_device_get_device_type (device))
{
case NM_DEVICE_TYPE_ETHERNET:
synchronize_device_ethernet (self, iface, NM_DEVICE_ETHERNET (device));
break;
case NM_DEVICE_TYPE_WIFI:
synchronize_device_wifi (self, iface, NM_DEVICE_WIFI (device));
break;
default:
break;
}
}
static void
get_devices (NAApplication *application)
{
int i;
NMClient *nm_client = nm_client_new ();
const GPtrArray *nm_connections = nm_client_get_active_connections (nm_client);
for (i = 0; i < nm_connections->len; i++)
{
NMActiveConnection *active_conn = NM_ACTIVE_CONNECTION (g_ptr_array_index (nm_connections, i));
g_debug ("Active connection: %s", nm_active_connection_get_connection (active_conn));
}
const GPtrArray *nm_devices = nm_client_get_devices (nm_client);
for (i = 0; i < nm_devices->len; i++)
{
NMDevice *nm_device = NM_DEVICE (g_ptr_array_index (nm_devices, i));
if (nm_device_get_state (nm_device) == NM_DEVICE_STATE_ACTIVATED)
{
const char *iface = nm_device_get_iface (nm_device);
const char *ip_iface = nm_device_get_ip_iface (nm_device);
g_debug ("Active device found: %s with ip iface %s", iface, ip_iface);
NMIP4Config *ip4_config = nm_device_get_ip4_config (nm_device);
if (ip4_config != NULL)
{
const GSList *ip4_addresses = nm_ip4_config_get_addresses (ip4_config);
const GSList *iter = ip4_addresses;
while (iter != NULL)
{
guint32 address = nm_ip4_address_get_address ((NMIP4Address *)iter->data);
struct in_addr addr = { address, };
char *str_addr = g_new (char, INET_ADDRSTRLEN);
inet_ntop (AF_INET, &addr, str_addr, INET_ADDRSTRLEN);
add_local_address (str_addr);
g_debug ("Adding local IP4 address %s", str_addr);
iter = iter->next;
}
}
NMIP6Config *ip6_config = nm_device_get_ip6_config (nm_device);
if (ip6_config != NULL)
{
const GSList *ip6_addresses = nm_ip6_config_get_addresses (ip6_config);
const GSList *iter = ip6_addresses;
while (iter != NULL)
{
const struct in6_addr *address = nm_ip6_address_get_address ((NMIP6Address *)iter->data);
char *str_addr = g_new (char, INET6_ADDRSTRLEN);
inet_ntop (AF_INET6, address, str_addr, INET6_ADDRSTRLEN);
add_local_address (str_addr);
g_debug ("Adding local IP6 address %s", str_addr);
iter = iter->next;
}
}
GError *error = NULL;
NAPCapHandle *handle = na_pcap_open (iface, &error);
if (handle != NULL)
{
application->priv->iface_handles = g_slist_append (application->priv->iface_handles, handle);
}
else
{
g_debug ("Error opening handler for interface %s: %s\n", iface, error->message);
g_error_free (error);
}
}
}
}
