/** * nm_device_ethernet_get_permanent_hw_address: * @device: a #NMDeviceEthernet * * Gets the permanent hardware (MAC) address of the #NMDeviceEthernet * * Returns: the permanent hardware address. This is the internal string used by the * device, and must not be modified. **/ const char * nm_device_ethernet_get_permanent_hw_address (NMDeviceEthernet *device) { g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), NULL); return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->perm_hw_address; }
static void update_switches_visibility (NmnApplet *applet) { NmnAppletPrivate *priv = GET_PRIVATE (applet); GtkTable *table; gboolean visible; int ethernet; int wifi; int modem; int wimax; int bt; ethernet = wifi = modem = wimax = bt = 0; if (!nmn_model_offline_mode_get_active (priv->model)) { const GPtrArray *devices; int i; devices = nm_client_get_devices (nmn_model_get_client (priv->model)); for (i = 0; devices && i < devices->len; i++) { NMDevice *device = NM_DEVICE (g_ptr_array_index (devices, i)); if (NM_IS_DEVICE_ETHERNET (device)) ethernet++; else if (NM_IS_DEVICE_WIFI (device)) wifi++; else if (NM_IS_SERIAL_DEVICE (device)) modem++; else if (NM_IS_DEVICE_BT (device)) bt++; } } table = GTK_TABLE (priv->switches_table); visible = wifi > 0; gtk_table_set_row_spacing (table, SWITCHES_ROW_WIFI, visible ? 6 : 0); g_object_set (priv->enable_wifi_label, "visible", visible, NULL); g_object_set (priv->enable_wifi, "visible", visible, NULL); visible = ethernet > 0; gtk_table_set_row_spacing (table, SWITCHES_ROW_ETHERNET, visible ? 6 : 0); g_object_set (priv->enable_ethernet_label, "visible", visible, NULL); g_object_set (priv->enable_ethernet, "visible", visible, NULL); visible = modem > 0; gtk_table_set_row_spacing (table, SWITCHES_ROW_3G, visible ? 6 : 0); g_object_set (priv->enable_3g_label, "visible", visible, NULL); g_object_set (priv->enable_3g, "visible", visible, NULL); visible = wimax > 0; gtk_table_set_row_spacing (table, SWITCHES_ROW_WIMAX, visible ? 6 : 0); g_object_set (priv->enable_wimax_label, "visible", visible, NULL); g_object_set (priv->enable_wimax, "visible", visible, NULL); visible = bt > 0; gtk_table_set_row_spacing (table, SWITCHES_ROW_BT, visible ? 6 : 0); g_object_set (priv->enable_bt_label, "visible", visible, NULL); g_object_set (priv->enable_bt, "visible", visible, NULL); }
/** * nm_device_ethernet_get_speed: * @device: a #NMDeviceEthernet * * Gets the speed of the #NMDeviceEthernet. * * Returns: the speed of the device **/ guint32 nm_device_ethernet_get_speed (NMDeviceEthernet *device) { g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), 0); return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->speed; }
/** * nm_device_ethernet_get_carrier: * @device: a #NMDeviceEthernet * * Whether the device has carrier. * * Returns: %TRUE if the device has carrier **/ gboolean nm_device_ethernet_get_carrier (NMDeviceEthernet *device) { g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), FALSE); return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->carrier; }
static void show_device_type_specific_info (NMDevice * device) { g_return_if_fail (NM_IS_DEVICE (device)); if (NM_IS_DEVICE_ETHERNET (device)) { show_ethernet_specific_info (device); } else if (NM_IS_DEVICE_WIFI (device)) { show_wifi_specific_info (device); } else if (NM_IS_DEVICE_BT (device)) { show_bt_specific_info (device); } else if (NM_IS_GSM_DEVICE (device)) { show_gsm_specific_info (device); } else if (NM_IS_CDMA_DEVICE (device)) { show_cdma_specific_info (device); } else { g_printerr ("Unsupported device type: %s\n", g_type_name (G_TYPE_FROM_INSTANCE (device))); } }
static void dump_device (NMDevice *device) { const char *str; NMDeviceState state; str = nm_device_get_iface (device); g_print ("Interface: %s\n", str); str = nm_device_get_udi (device); g_print ("Udi: %s\n", str); str = nm_device_get_driver (device); g_print ("Driver: %s\n", str); str = nm_device_get_vendor (device); g_print ("Vendor: %s\n", str); str = nm_device_get_product (device); g_print ("Product: %s\n", str); state = nm_device_get_state (device); g_print ("State: %d\n", state); if (state == NM_DEVICE_STATE_ACTIVATED) dump_ip4_config (nm_device_get_ip4_config (device)); if (NM_IS_DEVICE_ETHERNET (device)) dump_wired (NM_DEVICE_ETHERNET (device)); else if (NM_IS_DEVICE_WIFI (device)) dump_wireless (NM_DEVICE_WIFI (device)); dump_dhcp4_config (nm_device_get_dhcp4_config (device)); }
/** * nm_device_ethernet_get_speed: * @device: a #NMDeviceEthernet * * Gets the speed of the #NMDeviceEthernet. * * Returns: the speed of the device **/ guint32 nm_device_ethernet_get_speed (NMDeviceEthernet *device) { g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), 0); _nm_object_ensure_inited (NM_OBJECT (device)); return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->speed; }
/** * nm_device_ethernet_get_carrier: * @device: a #NMDeviceEthernet * * Whether the device has carrier. * * Returns: %TRUE if the device has carrier **/ gboolean nm_device_ethernet_get_carrier (NMDeviceEthernet *device) { g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), FALSE); _nm_object_ensure_inited (NM_OBJECT (device)); return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->carrier; }
/** * nm_device_ethernet_get_hw_address: * @device: a #NMDeviceEthernet * * Gets the active hardware (MAC) address of the #NMDeviceEthernet * * Returns: the active hardware address. This is the internal string used by the * device, and must not be modified. **/ const char * nm_device_ethernet_get_hw_address (NMDeviceEthernet *device) { g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), NULL); _nm_object_ensure_inited (NM_OBJECT (device)); return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->hw_address; }
static gchar * device_status_to_localized_string (NMDevice *nm_device, const gchar *speed) { NMDeviceState state; GString *string; const gchar *state_str = NULL, *reason_str = NULL; string = g_string_new (NULL); state = nm_device_get_state (nm_device); if (state == NM_DEVICE_STATE_UNAVAILABLE) { if (nm_device_get_firmware_missing (nm_device)) { /* TRANSLATORS: device status */ state_str = _("Firmware missing"); } else if (NM_IS_DEVICE_ETHERNET (nm_device) && !nm_device_ethernet_get_carrier (NM_DEVICE_ETHERNET (nm_device))) { /* TRANSLATORS: device status */ state_str = _("Cable unplugged"); } else if (NM_IS_DEVICE_INFINIBAND (nm_device) && !nm_device_infiniband_get_carrier (NM_DEVICE_INFINIBAND (nm_device))) { state_str = _("Cable unplugged"); } } if (!state_str) state_str = device_state_to_localized_string (state); if (state_str) g_string_append (string, state_str); if (state > NM_DEVICE_STATE_UNAVAILABLE && speed) { if (string->len) g_string_append (string, " - "); g_string_append (string, speed); } else if (state == NM_DEVICE_STATE_UNAVAILABLE || state == NM_DEVICE_STATE_DISCONNECTED || state == NM_DEVICE_STATE_DEACTIVATING || state == NM_DEVICE_STATE_FAILED) { reason_str = device_state_reason_to_localized_string (nm_device); if (*reason_str) { if (string->len) g_string_append (string, " - "); g_string_append (string, reason_str); } } return g_string_free (string, FALSE); }
NMListItem * nm_ethernet_item_new (NMClient *client, NMDeviceEthernet *device, NMSettingsConnectionInterface *connection) { g_return_val_if_fail (NM_IS_CLIENT (client), NULL); g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), NULL); g_return_val_if_fail (NM_IS_SETTINGS_CONNECTION_INTERFACE (connection), NULL); return (NMListItem *) g_object_new (NM_TYPE_ETHERNET_ITEM, NM_LIST_ITEM_TYPE_NAME, _("wired"), NM_CONNECTION_ITEM_DELETE_ALLOWED, FALSE, NM_CONNECTION_ITEM_CLIENT, client, NM_CONNECTION_ITEM_CONNECTION, connection, NM_DEVICE_ITEM_DEVICE, device, NULL); }
static gboolean nm_device_is_connection_compatible (NMDevice *device, NMConnection *connection, GError **error) { g_return_val_if_fail (NM_IS_DEVICE (device), FALSE); g_return_val_if_fail (NM_IS_CONNECTION (connection), FALSE); if (NM_IS_DEVICE_ETHERNET (device)) return check_ethernet_compatible (NM_DEVICE_ETHERNET (device), connection, error); else if (NM_IS_DEVICE_WIFI (device)) return check_wifi_compatible (NM_DEVICE_WIFI (device), connection, error); else if (NM_IS_DEVICE_BT (device)) return check_bt_compatible (NM_DEVICE_BT (device), connection, error); // else if (NM_IS_DEVICE_OLPC_MESH (device)) // return check_olpc_mesh_compatible (NM_DEVICE_OLPC_MESH (device), connection, error); g_set_error (error, 0, 0, "unhandled device type '%s'", G_OBJECT_TYPE_NAME (device)); return FALSE; }
static void connection_activated (GtkListBox *list, GtkListBoxRow *row, NetDeviceEthernet *device) { NMClient *client; NMDevice *nm_device; NMConnection *connection; client = net_object_get_client (NET_OBJECT (device)); nm_device = net_device_get_nm_device (NET_DEVICE (device)); if (!NM_IS_DEVICE_ETHERNET (nm_device) || !nm_device_ethernet_get_carrier (NM_DEVICE_ETHERNET (nm_device))) return; connection = NM_CONNECTION (g_object_get_data (G_OBJECT (gtk_bin_get_child (GTK_BIN (row))), "connection")); nm_client_activate_connection (client, connection, nm_device, NULL, NULL, NULL); }
static GSList * get_vlan_devices (CEPageVlan *self) { const GPtrArray *devices_array; GSList *devices; NMDevice *device; int i; devices_array = nm_client_get_devices (CE_PAGE (self)->client); devices = NULL; for (i = 0; devices_array && (i < devices_array->len); i++) { device = devices_array->pdata[i]; /* FIXME: this supported-device-types logic belongs in NM somewhere. */ if (!NM_IS_DEVICE_ETHERNET (device)) continue; devices = g_slist_prepend (devices, device); } return devices; }
static void detail_device (gpointer data, gpointer user_data) { NMDevice *device = NM_DEVICE (data); struct cb_info *info = user_data; char *tmp; NMDeviceState state; guint32 caps; guint32 speed; const GArray *array; int j; gboolean is_default = FALSE; const char *id = NULL; state = nm_device_get_state (device); for (j = 0; info->active && (j < info->active->len); j++) { NMActiveConnection *candidate = g_ptr_array_index (info->active, j); const GPtrArray *devices = nm_active_connection_get_devices (candidate); NMDevice *candidate_dev; NMConnection *connection; NMSettingConnection *s_con; if (!devices || !devices->len) continue; candidate_dev = g_ptr_array_index (devices, 0); if (candidate_dev == device) { if (nm_active_connection_get_default (candidate)) is_default = TRUE; connection = get_connection_for_active (candidate); if (!connection) break; s_con = (NMSettingConnection *) nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION); if (s_con) id = nm_setting_connection_get_id (s_con); break; } } 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_GSM_DEVICE (device)) print_string ("Type", "Mobile Broadband (GSM)"); else if (NM_IS_CDMA_DEVICE (device)) print_string ("Type", "Mobile Broadband (CDMA)"); else if (NM_IS_DEVICE_BT (device)) print_string ("Type", "Bluetooth"); print_string ("Driver", nm_device_get_driver (device) ? nm_device_get_driver (device) : "(unknown)"); 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))); 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"); } /* IP Setup info */ if (state == NM_DEVICE_STATE_ACTIVATED) { NMIP4Config *cfg = nm_device_get_ip4_config (device); GSList *iter; printf ("\n IPv4 Settings:\n"); for (iter = (GSList *) nm_ip4_config_get_addresses (cfg); 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 (cfg); 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); } } } printf ("\n\n"); }
static void nm_device_update_description (NMDevice *device) { NMDevicePrivate *priv; const char *subsys[3] = { "net", "tty", NULL }; GUdevDevice *udev_device = NULL, *tmpdev; const char *ifname; guint32 count = 0; const char *vendor, *model; g_return_if_fail (NM_IS_DEVICE (device)); priv = NM_DEVICE_GET_PRIVATE (device); if (!priv->client) { priv->client = g_udev_client_new (subsys); if (!priv->client) return; } ifname = nm_device_get_iface (device); if (!ifname) return; if (NM_IS_DEVICE_ETHERNET (device) || NM_IS_DEVICE_WIFI (device)) udev_device = g_udev_client_query_by_subsystem_and_name (priv->client, "net", ifname); else if (NM_IS_GSM_DEVICE (device) || NM_IS_CDMA_DEVICE (device)) udev_device = g_udev_client_query_by_subsystem_and_name (priv->client, "tty", ifname); if (!udev_device) return; g_free (priv->product); priv->product = NULL; g_free (priv->vendor); priv->vendor = NULL; /* Walk up the chain of the device and its parents a few steps to grab * vendor and device ID information off it. */ tmpdev = udev_device; while ((count++ < 3) && tmpdev && (!priv->vendor || !priv->product)) { if (!priv->vendor) priv->vendor = get_decoded_property (tmpdev, "ID_VENDOR_ENC"); if (!priv->product) priv->product = get_decoded_property (tmpdev, "ID_MODEL_ENC"); tmpdev = g_udev_device_get_parent (tmpdev); } /* If we didn't get strings directly from the device, try database strings */ tmpdev = udev_device; count = 0; while ((count++ < 3) && tmpdev && (!priv->vendor || !priv->product)) { if (!priv->vendor) { vendor = g_udev_device_get_property (tmpdev, "ID_VENDOR_FROM_DATABASE"); if (vendor) priv->vendor = g_strdup (vendor); } if (!priv->product) { model = g_udev_device_get_property (tmpdev, "ID_MODEL_FROM_DATABASE"); if (model) priv->product = g_strdup (model); } tmpdev = g_udev_device_get_parent (tmpdev); } _nm_object_queue_notify (NM_OBJECT (device), NM_DEVICE_VENDOR); _nm_object_queue_notify (NM_OBJECT (device), NM_DEVICE_PRODUCT); }
static void info_dialog_add_page (GtkNotebook *notebook, NMConnection *connection, gboolean is_default, NMDevice *device) { GtkTable *table; guint32 speed = 0; char *str; const char *iface; NMIP4Config *ip4_config; const GArray *dns; NMIP4Address *def_addr = NULL; guint32 hostmask, network, bcast, netmask; int row = 0; SpeedInfo* info = NULL; GtkWidget* speed_label; const GSList *addresses; table = GTK_TABLE (gtk_table_new (12, 2, FALSE)); gtk_table_set_col_spacings (table, 12); gtk_table_set_row_spacings (table, 6); gtk_container_set_border_width (GTK_CONTAINER (table), 12); /* Interface */ iface = nm_device_get_iface (device); if (NM_IS_DEVICE_ETHERNET (device)) str = g_strdup_printf (_("Ethernet (%s)"), iface); else if (NM_IS_DEVICE_WIFI (device)) str = g_strdup_printf (_("802.11 WiFi (%s)"), iface); else if (NM_IS_GSM_DEVICE (device)) str = g_strdup_printf (_("GSM (%s)"), iface); else if (NM_IS_CDMA_DEVICE (device)) str = g_strdup_printf (_("CDMA (%s)"), iface); else str = g_strdup (iface); gtk_table_attach_defaults (table, create_info_label (_("Interface:"), FALSE), 0, 1, row, row + 1); gtk_table_attach_defaults (table, create_info_label (str, TRUE), 1, 2, row, row + 1); g_free (str); row++; /* Hardware address */ str = NULL; if (NM_IS_DEVICE_ETHERNET (device)) str = g_strdup (nm_device_ethernet_get_hw_address (NM_DEVICE_ETHERNET (device))); else if (NM_IS_DEVICE_WIFI (device)) str = g_strdup (nm_device_wifi_get_hw_address (NM_DEVICE_WIFI (device))); gtk_table_attach_defaults (table, create_info_label (_("Hardware Address:"), FALSE), 0, 1, row, row + 1); gtk_table_attach_defaults (table, create_info_label (str, TRUE), 1, 2, row, row + 1); g_free (str); row++; /* Driver */ gtk_table_attach_defaults (table, create_info_label (_("Driver:"), FALSE), 0, 1, row, row + 1); gtk_table_attach_defaults (table, create_info_label (nm_device_get_driver (device), TRUE), 1, 2, row, row + 1); row++; speed_label = create_info_label ("", TRUE); /* Speed */ str = NULL; if (NM_IS_DEVICE_ETHERNET (device)) { /* Wired speed in Mb/s */ speed = nm_device_ethernet_get_speed (NM_DEVICE_ETHERNET (device)); } else if (NM_IS_DEVICE_WIFI (device)) { /* Wireless speed in Kb/s */ speed = nm_device_wifi_get_bitrate (NM_DEVICE_WIFI (device)) / 1000; /* Listen for wifi speed changes */ info = g_malloc0 (sizeof (SpeedInfo)); info->device = device; info->label = speed_label; info->id = g_signal_connect (device, "notify::" NM_DEVICE_WIFI_BITRATE, G_CALLBACK (bitrate_changed_cb), speed_label); g_object_weak_ref (G_OBJECT(speed_label), label_destroyed, info); g_object_weak_ref (G_OBJECT(device), device_destroyed, info); } if (speed) str = g_strdup_printf (_("%u Mb/s"), speed); gtk_label_set_text (GTK_LABEL(speed_label), str ? str : _("Unknown")); g_free (str); gtk_table_attach_defaults (table, create_info_label (_("Speed:"), FALSE), 0, 1, row, row + 1); gtk_table_attach_defaults (table, speed_label, 1, 2, row, row + 1); row++; /* Security */ gtk_table_attach_defaults (table, create_info_label (_("Security:"), FALSE), 0, 1, row, row + 1); gtk_table_attach_defaults (table, create_info_label_security (connection), 1, 2, row, row + 1); row++; /* Empty line */ gtk_table_attach_defaults (table, gtk_label_new (""), 0, 2, row, row + 1); row++; /* IP4 */ ip4_config = nm_device_get_ip4_config (device); addresses = nm_ip4_config_get_addresses (ip4_config); if (g_slist_length ((GSList *) addresses)) def_addr = addresses->data; /* Address */ gtk_table_attach_defaults (table, create_info_label (_("IP Address:"), FALSE), 0, 1, row, row + 1); str = def_addr ? ip4_address_as_string (nm_ip4_address_get_address (def_addr)) : g_strdup (_("Unknown")); gtk_table_attach_defaults (table, create_info_label (str, TRUE), 1, 2, row, row + 1); g_free (str); row++; /* Broadcast */ if (def_addr) { netmask = nm_utils_ip4_prefix_to_netmask (nm_ip4_address_get_prefix (def_addr)); network = ntohl (nm_ip4_address_get_address (def_addr)) & ntohl (netmask); hostmask = ~ntohl (netmask); bcast = htonl (network | hostmask); } gtk_table_attach_defaults (table, create_info_label (_("Broadcast Address:"), FALSE), 0, 1, row, row + 1); str = def_addr ? ip4_address_as_string (bcast) : g_strdup (_("Unknown")); gtk_table_attach_defaults (table, create_info_label (str, TRUE), 1, 2, row, row + 1); g_free (str); row++; /* Prefix */ gtk_table_attach_defaults (table, create_info_label (_("Subnet Mask:"), FALSE), 0, 1, row, row + 1); str = def_addr ? ip4_address_as_string (netmask) : g_strdup (_("Unknown")); gtk_table_attach_defaults (table, create_info_label (str, TRUE), 1, 2, row, row + 1); g_free (str); row++; /* Gateway */ if (def_addr && nm_ip4_address_get_gateway (def_addr)) { gtk_table_attach_defaults (table, create_info_label (_("Default Route:"), FALSE), 0, 1, row, row + 1); str = ip4_address_as_string (nm_ip4_address_get_gateway (def_addr)); gtk_table_attach_defaults (table, create_info_label (str, TRUE), 1, 2, row, row + 1); g_free (str); row++; } /* DNS */ dns = def_addr ? nm_ip4_config_get_nameservers (ip4_config) : NULL; if (dns && dns->len) { gtk_table_attach_defaults (table, create_info_label (_("Primary DNS:"), FALSE), 0, 1, row, row + 1); str = ip4_address_as_string (g_array_index (dns, guint32, 0)); gtk_table_attach_defaults (table, create_info_label (str, TRUE), 1, 2, row, row + 1); g_free (str); row++; if (dns->len > 1) { gtk_table_attach_defaults (table, create_info_label (_("Secondary DNS:"), FALSE), 0, 1, row, row + 1); str = ip4_address_as_string (g_array_index (dns, guint32, 1)); gtk_table_attach_defaults (table, create_info_label (str, TRUE), 1, 2, row, row + 1); g_free (str); row++; } } gtk_notebook_append_page (notebook, GTK_WIDGET (table), create_info_notebook_label (connection, is_default)); gtk_widget_show_all (GTK_WIDGET (table)); }
static void build_vlan_parent_list (CEPageVlan *self, GSList *devices) { CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self); GSList *connections, *c_iter, *d_iter; GPtrArray *parents; VlanParent *parent; NMDevice *device; const char *iface, *mac, *id; int i; parents = g_ptr_array_new (); /* Devices with no L2 configuration can spawn VLANs directly. At the * moment, this means just Ethernet. */ for (d_iter = devices; d_iter; d_iter = d_iter->next) { device = d_iter->data; if (!NM_IS_DEVICE_ETHERNET (device)) continue; parent = g_slice_new (VlanParent); parent->device = device; parent->connection = NULL; iface = nm_device_get_iface (device); mac = nm_device_ethernet_get_permanent_hw_address (NM_DEVICE_ETHERNET (device)); parent->label = g_strdup_printf ("%s (%s)", iface, mac); g_ptr_array_add (parents, parent); } /* Otherwise, VLANs have to be built on top of configured connections */ connections = nm_remote_settings_list_connections (CE_PAGE (self)->settings); for (c_iter = connections; c_iter; c_iter = c_iter->next) { NMConnection *candidate = c_iter->data; NMSettingConnection *s_con = nm_connection_get_setting_connection (candidate); if (nm_setting_connection_get_master (s_con)) continue; for (d_iter = devices; d_iter; d_iter = d_iter->next) { device = d_iter->data; if (nm_device_connection_valid (device, candidate)) { parent = g_slice_new (VlanParent); parent->device = device; parent->connection = candidate; iface = nm_device_get_iface (device); id = nm_setting_connection_get_id (s_con); parent->label = g_strdup_printf ("%s (%s)", iface, id); g_ptr_array_add (parents, parent); /* no break here; the connection may apply to multiple devices */ } } } g_slist_free (connections); g_ptr_array_sort (parents, sort_parents); g_ptr_array_add (parents, NULL); priv->parent_labels = g_new (char *, parents->len); priv->parents = (VlanParent **)g_ptr_array_free (parents, FALSE); for (i = 0; priv->parents[i]; i++) priv->parent_labels[i] = priv->parents[i]->label; priv->parent_labels[i] = NULL; }
static void ui_to_setting (CEPageVlan *self) { CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self); NMConnection *connection = CE_PAGE (self)->connection; NMSettingConnection *s_con = nm_connection_get_setting_connection (connection); GByteArray *cloned_mac = NULL; VlanParent *parent = NULL; int parent_id, vid; const char *parent_iface = NULL, *parent_uuid = NULL; const char *slave_type; const char *iface; char *tmp_parent_iface = NULL; GType hwtype; gboolean mtu_set; int mtu; parent_id = gtk_combo_box_get_active (GTK_COMBO_BOX (priv->parent)); if (parent_id == -1) { parent_iface = gtk_entry_get_text (priv->parent_entry); tmp_parent_iface = g_strndup (parent_iface, strcspn (parent_iface, " ")); parent_iface = tmp_parent_iface; } else { parent = priv->parents[parent_id]; if (parent->connection) parent_uuid = nm_connection_get_uuid (parent->connection); if (parent->device) parent_iface = nm_device_get_iface (parent->device); } g_assert (parent_uuid != NULL || parent_iface != NULL); slave_type = nm_setting_connection_get_slave_type (s_con); if (parent_uuid) { /* Update NMSettingConnection:master if it's set, but don't * set it if it's not. */ if (!g_strcmp0 (slave_type, NM_SETTING_VLAN_SETTING_NAME)) { g_object_set (s_con, NM_SETTING_CONNECTION_MASTER, parent_uuid, NULL); } } else if (!g_strcmp0 (slave_type, NM_SETTING_VLAN_SETTING_NAME)) { g_object_set (s_con, NM_SETTING_CONNECTION_MASTER, NULL, NM_SETTING_CONNECTION_SLAVE_TYPE, NULL, NULL); } if (parent && NM_IS_DEVICE_ETHERNET (parent->device)) hwtype = NM_TYPE_SETTING_WIRED; else hwtype = G_TYPE_NONE; if (priv->s_hw && G_OBJECT_TYPE (priv->s_hw) != hwtype) { nm_connection_remove_setting (connection, G_OBJECT_TYPE (priv->s_hw)); priv->s_hw = NULL; } iface = gtk_entry_get_text (priv->name_entry); vid = gtk_spin_button_get_value_as_int (priv->id_entry); g_object_set (priv->setting, NM_SETTING_VLAN_PARENT, parent_uuid ? parent_uuid : parent_iface, NM_SETTING_VLAN_INTERFACE_NAME, iface, NM_SETTING_VLAN_ID, vid, NULL); if (hwtype != G_TYPE_NONE) { cloned_mac = ce_page_entry_to_mac (priv->cloned_mac, ARPHRD_ETHER, NULL); mtu_set = g_ascii_isdigit (*gtk_entry_get_text (GTK_ENTRY (priv->mtu))); mtu = gtk_spin_button_get_value_as_int (priv->mtu); if (cloned_mac || mtu_set) { if (!priv->s_hw) { priv->s_hw = g_object_new (hwtype, NULL); nm_connection_add_setting (connection, priv->s_hw); } g_object_set (priv->s_hw, NM_SETTING_WIRED_CLONED_MAC_ADDRESS, cloned_mac, NM_SETTING_WIRED_MTU, (guint32) mtu, NULL); if (cloned_mac) g_byte_array_free (cloned_mac, TRUE); } else if (priv->s_hw) { nm_connection_remove_setting (connection, G_OBJECT_TYPE (priv->s_hw)); priv->s_hw = NULL; } } g_free (tmp_parent_iface); }
static void populate_ui (CEPageVlan *self) { CEPageVlanPrivate *priv = CE_PAGE_VLAN_GET_PRIVATE (self); GSList *devices, *d_iter; NMConnection *parent_connection = NULL; NMDevice *device, *parent_device = NULL; const char *parent, *iface, *current_parent; int i, mtu_def, mtu_val; devices = get_vlan_devices (self); /* Parent */ build_vlan_parent_list (self, devices); parent = nm_setting_vlan_get_parent (priv->setting); if (parent) { /* UUID? */ parent_connection = (NMConnection *)nm_remote_settings_get_connection_by_uuid (CE_PAGE (self)->settings, parent); if (!parent_connection) { /* Interface name? */ for (d_iter = devices; d_iter; d_iter = d_iter->next) { device = d_iter->data; if (!g_strcmp0 (parent, nm_device_get_iface (device))) { parent_device = device; break; } } } } /* If NMSettingVlan:parent didn't indicate a device, but we have a * wired setting, figure out the device from that. */ if (priv->s_hw && !parent_device) { const GByteArray *mac; const char *device_mac_str; char *mac_str; if (NM_IS_SETTING_WIRED (priv->s_hw)) mac = nm_setting_wired_get_mac_address (NM_SETTING_WIRED (priv->s_hw)); else mac = NULL; if (mac) { mac_str = nm_utils_hwaddr_ntoa (mac->data, ARPHRD_ETHER); for (d_iter = devices; d_iter; d_iter = d_iter->next) { device = d_iter->data; if (NM_IS_DEVICE_ETHERNET (device)) device_mac_str = nm_device_ethernet_get_permanent_hw_address (NM_DEVICE_ETHERNET (device)); else device_mac_str = NULL; if (!g_strcmp0 (mac_str, device_mac_str)) { parent_device = device; break; } } } } current_parent = parent; if (parent_device || parent_connection) { for (i = 0; priv->parents[i]; i++) { if (parent_device && parent_device != priv->parents[i]->device) continue; if (parent_connection != priv->parents[i]->connection) continue; current_parent = priv->parents[i]->label; break; } } ce_page_setup_mac_combo (CE_PAGE (self), priv->parent, current_parent, priv->parent_labels); g_signal_connect (priv->parent, "changed", G_CALLBACK (parent_changed), self); if (current_parent) priv->last_parent = g_strndup (current_parent, strcspn (current_parent, " ")); /* Name */ iface = nm_setting_vlan_get_interface_name (priv->setting); if (iface) gtk_entry_set_text (priv->name_entry, iface); g_signal_connect (priv->name_entry, "changed", G_CALLBACK (name_changed), self); /* ID */ priv->last_id = nm_setting_vlan_get_id (priv->setting); gtk_spin_button_set_value (priv->id_entry, priv->last_id); g_signal_connect (priv->id_entry, "value-changed", G_CALLBACK (id_changed), self); /* Cloned MAC address */ if (NM_IS_SETTING_WIRED (priv->s_hw)) { ce_page_mac_to_entry (nm_setting_wired_get_cloned_mac_address (NM_SETTING_WIRED (priv->s_hw)), ARPHRD_ETHER, priv->cloned_mac); } g_signal_connect (priv->cloned_mac, "changed", G_CALLBACK (stuff_changed), self); /* MTU */ if (NM_IS_SETTING_WIRED (priv->s_hw)) { mtu_def = ce_get_property_default (priv->s_hw, NM_SETTING_WIRED_MTU); mtu_val = nm_setting_wired_get_mtu (NM_SETTING_WIRED (priv->s_hw)); } else { mtu_def = mtu_val = 1500; } g_signal_connect (priv->mtu, "output", G_CALLBACK (ce_spin_output_with_default), GINT_TO_POINTER (mtu_def)); gtk_spin_button_set_value (priv->mtu, (gdouble) mtu_val); g_signal_connect (priv->mtu, "value-changed", G_CALLBACK (stuff_changed), self); g_slist_free (devices); }
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 connect_details_page (CEPageDetails *page) { guint speed; guint strength; NMDeviceState state; NMAccessPoint *active_ap; const gchar *str; gboolean device_is_active; if (NM_IS_DEVICE_WIFI (page->device)) active_ap = nm_device_wifi_get_active_access_point (NM_DEVICE_WIFI (page->device)); else active_ap = NULL; state = page->device ? nm_device_get_state (page->device) : NM_DEVICE_STATE_DISCONNECTED; device_is_active = FALSE; speed = 0; if (active_ap && page->ap == active_ap && state != NM_DEVICE_STATE_UNAVAILABLE) { device_is_active = TRUE; if (NM_IS_DEVICE_WIFI (page->device)) speed = nm_device_wifi_get_bitrate (NM_DEVICE_WIFI (page->device)) / 1000; } else if (page->device) { NMActiveConnection *ac; const gchar *p1, *p2; ac = nm_device_get_active_connection (page->device); p1 = ac ? nm_active_connection_get_connection (ac) : NULL; p2 = nm_connection_get_path (CE_PAGE (page)->connection); if (g_strcmp0 (p1, p2) == 0) { device_is_active = TRUE; if (NM_IS_DEVICE_WIFI (page->device)) speed = nm_device_wifi_get_bitrate (NM_DEVICE_WIFI (page->device)) / 1000; else if (NM_IS_DEVICE_ETHERNET (page->device)) speed = nm_device_ethernet_get_speed (NM_DEVICE_ETHERNET (page->device)); } } if (speed > 0) str = g_strdup_printf (_("%d Mb/s"), speed); else str = NULL; panel_set_device_widget_details (CE_PAGE (page)->builder, "speed", str); g_clear_pointer (&str, g_free); if (NM_IS_DEVICE_WIFI (page->device)) str = nm_device_wifi_get_hw_address (NM_DEVICE_WIFI (page->device)); else if (NM_IS_DEVICE_ETHERNET (page->device)) str = nm_device_ethernet_get_hw_address (NM_DEVICE_ETHERNET (page->device)); panel_set_device_widget_details (CE_PAGE (page)->builder, "mac", str); str = NULL; if (device_is_active && active_ap) str = get_ap_security_string (active_ap); panel_set_device_widget_details (CE_PAGE (page)->builder, "security", str); g_clear_pointer (&str, g_free); strength = 0; if (page->ap != NULL) strength = nm_access_point_get_strength (page->ap); if (strength <= 0) str = NULL; else if (strength < 20) str = C_("Signal strength", "None"); else if (strength < 40) str = C_("Signal strength", "Weak"); else if (strength < 50) str = C_("Signal strength", "Ok"); else if (strength < 80) str = C_("Signal strength", "Good"); else str = C_("Signal strength", "Excellent"); panel_set_device_widget_details (CE_PAGE (page)->builder, "strength", str); /* set IP entries */ if (device_is_active) panel_set_device_widgets (CE_PAGE (page)->builder, page->device); else panel_unset_device_widgets (CE_PAGE (page)->builder); if (!device_is_active && CE_PAGE (page)->connection) update_last_used (page, CE_PAGE (page)->connection); else panel_set_device_widget_details (CE_PAGE (page)->builder, "last_used", NULL); }