/** * panel_device_to_sortable_string: * * Try to return order of approximate connection speed. **/ const gchar * panel_device_to_sortable_string (NMDevice *device) { const gchar *value = NULL; NMDeviceModemCapabilities caps; switch (nm_device_get_device_type (device)) { case NM_DEVICE_TYPE_ETHERNET: value = "1"; break; case NM_DEVICE_TYPE_WIFI: value = "2"; break; case NM_DEVICE_TYPE_MODEM: caps = nm_device_modem_get_current_capabilities (NM_DEVICE_MODEM (device)); if ((caps & NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS) || (caps & NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO)) { value = "3"; } break; case NM_DEVICE_TYPE_BT: value = "4"; break; case NM_DEVICE_TYPE_OLPC_MESH: value = "5"; break; default: value = "6"; break; } return value; }
/** * panel_device_to_icon_name: **/ const gchar * panel_device_to_icon_name (NMDevice *device) { const gchar *value = NULL; NMDeviceState state; NMDeviceModemCapabilities caps; switch (nm_device_get_device_type (device)) { case NM_DEVICE_TYPE_ETHERNET: state = nm_device_get_state (device); if (state == NM_DEVICE_STATE_UNAVAILABLE) { value = "network-wired-disconnected"; } else { value = "network-wired"; } break; case NM_DEVICE_TYPE_WIFI: case NM_DEVICE_TYPE_BT: case NM_DEVICE_TYPE_OLPC_MESH: value = "network-wireless"; break; case NM_DEVICE_TYPE_MODEM: caps = nm_device_modem_get_current_capabilities (NM_DEVICE_MODEM (device)); if ((caps & NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS) || (caps & NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO)) { value = "network-wireless"; } break; default: break; } return value; }
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); }
/** * panel_device_to_localized_string: **/ const gchar * panel_device_to_localized_string (NMDevice *device) { const gchar *value = NULL; NMDeviceModemCapabilities caps; switch (nm_device_get_device_type (device)) { case NM_DEVICE_TYPE_UNKNOWN: /* TRANSLATORS: device type */ value = _("Unknown"); break; case NM_DEVICE_TYPE_ETHERNET: /* TRANSLATORS: device type */ value = _("Wired"); break; case NM_DEVICE_TYPE_WIFI: /* TRANSLATORS: device type */ value = _("Wireless"); break; case NM_DEVICE_TYPE_MODEM: caps = nm_device_modem_get_current_capabilities (NM_DEVICE_MODEM (device)); if ((caps & NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS) || (caps & NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO)) { /* TRANSLATORS: device type */ value = _("Mobile broadband"); } break; case NM_DEVICE_TYPE_BT: /* TRANSLATORS: device type */ value = _("Bluetooth"); break; case NM_DEVICE_TYPE_OLPC_MESH: /* TRANSLATORS: device type */ value = _("Mesh"); break; default: break; } return value; }
/** * panel_device_to_icon_name: **/ const gchar * panel_device_to_icon_name (NMDevice *device, gboolean symbolic) { const gchar *value = NULL; NMDeviceState state; NMDeviceModemCapabilities caps; switch (nm_device_get_device_type (device)) { case NM_DEVICE_TYPE_ETHERNET: state = nm_device_get_state (device); if (state <= NM_DEVICE_STATE_DISCONNECTED) { value = symbolic ? "network-wired-disconnected-symbolic" : "network-wired-disconnected"; } else { value = symbolic ? "network-wired-symbolic" : "network-wired"; } break; case NM_DEVICE_TYPE_WIFI: case NM_DEVICE_TYPE_BT: case NM_DEVICE_TYPE_OLPC_MESH: value = symbolic ? "network-wireless-signal-excellent-symbolic" : "network-wireless"; break; case NM_DEVICE_TYPE_MODEM: caps = nm_device_modem_get_current_capabilities (NM_DEVICE_MODEM (device)); if ((caps & NM_DEVICE_MODEM_CAPABILITY_GSM_UMTS) || (caps & NM_DEVICE_MODEM_CAPABILITY_CDMA_EVDO)) { value = symbolic ? "network-cellular-signal-excellent-symbolic" : "network-cellular"; break; } /* fall thru */ default: value = symbolic ? "network-idle-symbolic" : "network-idle"; break; } return value; }
/* return value must not be freed! */ static const gchar * get_mac_address_of_device (NMDevice *device) { const gchar *mac = NULL; switch (nm_device_get_device_type (device)) { case NM_DEVICE_TYPE_WIFI: { NMDeviceWifi *device_wifi = NM_DEVICE_WIFI (device); mac = nm_device_wifi_get_hw_address (device_wifi); break; } case NM_DEVICE_TYPE_ETHERNET: { NMDeviceEthernet *device_ethernet = NM_DEVICE_ETHERNET (device); mac = nm_device_ethernet_get_hw_address (device_ethernet); break; } case NM_DEVICE_TYPE_WIMAX: { NMDeviceWimax *device_wimax = NM_DEVICE_WIMAX (device); mac = nm_device_wimax_get_hw_address (device_wimax); break; } case NM_DEVICE_TYPE_INFINIBAND: { NMDeviceInfiniband *device_infiniband = NM_DEVICE_INFINIBAND (device); mac = nm_device_infiniband_get_hw_address (device_infiniband); break; } default: break; } /* no MAC address found */ return mac; }
/** * panel_device_state_to_localized_string: **/ const gchar * panel_device_state_to_localized_string (NMDevice *device) { NMDeviceType type; NMDeviceState state; type = nm_device_get_device_type (device); state = nm_device_get_state (device); const gchar *value = NULL; switch (state) { case NM_DEVICE_STATE_UNKNOWN: /* TRANSLATORS: device status */ value = _("Status unknown"); break; case NM_DEVICE_STATE_UNMANAGED: /* TRANSLATORS: device status */ value = _("Unmanaged"); break; case NM_DEVICE_STATE_UNAVAILABLE: /* TRANSLATORS: device status */ if (nm_device_get_firmware_missing (device)) value = _("Firmware missing"); else if (type == NM_DEVICE_TYPE_ETHERNET && !nm_device_ethernet_get_carrier (NM_DEVICE_ETHERNET (device))) value = _("Cable unplugged"); else value = _("Unavailable"); break; case NM_DEVICE_STATE_DISCONNECTED: /* TRANSLATORS: device status */ value = _("Disconnected"); break; case NM_DEVICE_STATE_PREPARE: case NM_DEVICE_STATE_CONFIG: case NM_DEVICE_STATE_IP_CONFIG: case NM_DEVICE_STATE_IP_CHECK: /* TRANSLATORS: device status */ value = _("Connecting"); break; case NM_DEVICE_STATE_NEED_AUTH: /* TRANSLATORS: device status */ value = _("Authentication required"); break; case NM_DEVICE_STATE_ACTIVATED: /* TRANSLATORS: device status */ value = _("Connected"); break; case NM_DEVICE_STATE_DEACTIVATING: /* TRANSLATORS: device status */ value = _("Disconnecting"); break; case NM_DEVICE_STATE_FAILED: /* TRANSLATORS: device status */ value = _("Connection failed"); break; default: /* TRANSLATORS: device status */ value = _("Status unknown (missing)"); break; } return value; }
static GObject* constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { GObject *object; NMDeviceWiredPrivate *priv; NMDevice *self; guint32 caps; object = G_OBJECT_CLASS (nm_device_wired_parent_class)->constructor (type, n_construct_params, construct_params); if (!object) return NULL; self = NM_DEVICE (object); priv = NM_DEVICE_WIRED_GET_PRIVATE (self); nm_log_dbg (LOGD_HW | NM_DEVICE_WIRED_LOG_LEVEL (NM_DEVICE (self)), "(%s): kernel ifindex %d", nm_device_get_iface (NM_DEVICE (self)), nm_device_get_ifindex (NM_DEVICE (self))); if (nm_device_get_device_type (self) == NM_DEVICE_TYPE_ETHERNET) { priv->hw_addr_type = ARPHRD_ETHER; priv->hw_addr_len = ETH_ALEN; } else if (nm_device_get_device_type (self) == NM_DEVICE_TYPE_INFINIBAND) { priv->hw_addr_type = ARPHRD_INFINIBAND; priv->hw_addr_len = INFINIBAND_ALEN; } else if (nm_device_get_device_type (self) == NM_DEVICE_TYPE_BOND) { /* We may not know the hardware address type until a slave is added */ priv->hw_addr_type = ARPHRD_ETHER; priv->hw_addr_len = ETH_ALEN; } else g_assert_not_reached (); caps = nm_device_get_capabilities (self); if (caps & NM_DEVICE_CAP_CARRIER_DETECT) { /* Only listen to netlink for cards that support carrier detect */ priv->monitor = nm_netlink_monitor_get (); priv->link_connected_id = g_signal_connect (priv->monitor, "carrier-on", G_CALLBACK (carrier_on), self); priv->link_disconnected_id = g_signal_connect (priv->monitor, "carrier-off", G_CALLBACK (carrier_off), self); priv->carrier = get_carrier_sync (NM_DEVICE_WIRED (self)); nm_log_info (LOGD_HW | NM_DEVICE_WIRED_LOG_LEVEL (NM_DEVICE (self)), "(%s): carrier is %s", nm_device_get_iface (NM_DEVICE (self)), priv->carrier ? "ON" : "OFF"); /* Request link state again just in case an error occurred getting the * initial link state. */ nm_netlink_monitor_request_status (priv->monitor); } else { nm_log_info (LOGD_HW | NM_DEVICE_WIRED_LOG_LEVEL (NM_DEVICE (self)), "(%s): driver '%s' does not support carrier detection.", nm_device_get_iface (self), nm_device_get_driver (self)); priv->carrier = TRUE; } return object; }
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 gis_network_page_constructed (GObject *object) { GisNetworkPage *page = GIS_NETWORK_PAGE (object); GisNetworkPagePrivate *priv = gis_network_page_get_instance_private (page); const GPtrArray *devices; NMDevice *device; guint i; gboolean visible = FALSE; G_OBJECT_CLASS (gis_network_page_parent_class)->constructed (object); priv->icons = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); priv->nm_client = nm_client_new (); g_object_bind_property (priv->nm_client, "wireless-enabled", priv->turn_on_switch, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); devices = nm_client_get_devices (priv->nm_client); if (devices) { for (i = 0; i < devices->len; i++) { device = g_ptr_array_index (devices, i); if (!nm_device_get_managed (device)) continue; if (nm_device_get_device_type (device) == NM_DEVICE_TYPE_WIFI) { /* FIXME deal with multiple, dynamic devices */ priv->nm_device = g_object_ref (device); break; } } } if (priv->nm_device == NULL) { g_debug ("No network device found, hiding network page"); goto out; } if (nm_device_get_state (priv->nm_device) == NM_DEVICE_STATE_ACTIVATED) { g_debug ("Activated network device found, hiding network page"); goto out; } visible = TRUE; priv->nm_settings = nm_remote_settings_new (NULL); g_signal_connect (priv->nm_device, "notify::state", G_CALLBACK (device_state_changed), page); g_signal_connect (priv->nm_client, "notify::active-connections", G_CALLBACK (active_connections_changed), page); gtk_list_box_set_selection_mode (GTK_LIST_BOX (priv->network_list), GTK_SELECTION_NONE); gtk_list_box_set_header_func (GTK_LIST_BOX (priv->network_list), update_header_func, NULL, NULL); gtk_list_box_set_sort_func (GTK_LIST_BOX (priv->network_list), ap_sort, NULL, NULL); g_signal_connect (priv->network_list, "row-activated", G_CALLBACK (row_activated), page); refresh_wireless_list (page); sync_complete (page); gis_page_set_skippable (GIS_PAGE (page), TRUE); out: gtk_widget_set_visible (GTK_WIDGET (page), visible); }