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