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); } } } }