static int sort_connections (gconstpointer a, gconstpointer b) { NmtConnectConnection *nmta = (NmtConnectConnection *)a; NmtConnectConnection *nmtb = (NmtConnectConnection *)b; /* If nmta and nmtb both have NMConnections, sort them by timestamp */ if (nmta->conn && nmtb->conn) { NMSettingConnection *s_con_a, *s_con_b; guint64 time_a, time_b; s_con_a = nm_connection_get_setting_connection (nmta->conn); s_con_b = nm_connection_get_setting_connection (nmtb->conn); time_a = nm_setting_connection_get_timestamp (s_con_a); time_b = nm_setting_connection_get_timestamp (s_con_b); return (int) (time_b - time_a); } /* If one is an NMConnection and the other is an NMAccessPoint, the * connection comes first. */ if (nmta->conn) return -1; else if (nmtb->conn) return 1; g_return_val_if_fail (nmta->ap && nmtb->ap, 0); /* If both are access points, then sort by strength */ return nm_access_point_get_strength (nmtb->ap) - nm_access_point_get_strength (nmta->ap); }
static gint compare_aps (gconstpointer a, gconstpointer b, gpointer user_data) { const char *bssid1, *bssid2; guint8 strength1, strength2; NMAccessPoint * ap1 = NM_ACCESS_POINT (* ((gconstpointer *) a)); NMAccessPoint * ap2 = NM_ACCESS_POINT (* ((gconstpointer *) b)); NMAccessPoint * active_ap; /* sort by signal strength, but put active ap first */ if (user_data) { active_ap = NM_ACCESS_POINT (user_data); bssid1 = nm_access_point_get_hw_address (ap1); bssid2 = nm_access_point_get_hw_address (active_ap); if (!g_strcmp0 (bssid1, bssid2)) return -1; bssid1 = nm_access_point_get_hw_address (ap2); if (!g_strcmp0 (bssid1, bssid2)) return 1; } strength1 = nm_access_point_get_strength(ap1); strength2 = nm_access_point_get_strength(ap2); if (strength1 < strength2) return 1; else if (strength1 == strength2) return 0; else return -1; }
static GPtrArray * get_strongest_unique_aps (const GPtrArray *aps) { const GByteArray *ssid; const GByteArray *ssid_tmp; GPtrArray *unique = NULL; gboolean add_ap; guint i; guint j; NMAccessPoint *ap; NMAccessPoint *ap_tmp; /* we will have multiple entries for typical hotspots, * just keep the one with the strongest signal */ unique = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); if (aps == NULL) goto out; for (i = 0; i < aps->len; i++) { ap = NM_ACCESS_POINT (g_ptr_array_index (aps, i)); ssid = nm_access_point_get_ssid (ap); add_ap = TRUE; /* get already added list */ for (j = 0; j < unique->len; j++) { ap_tmp = NM_ACCESS_POINT (g_ptr_array_index (unique, j)); ssid_tmp = nm_access_point_get_ssid (ap_tmp); /* is this the same type and data? */ if (nm_utils_same_ssid (ssid, ssid_tmp, TRUE)) { /* the new access point is stronger */ if (nm_access_point_get_strength (ap) > nm_access_point_get_strength (ap_tmp)) { g_ptr_array_remove (unique, ap_tmp); add_ap = TRUE; } else { add_ap = FALSE; } break; } } if (add_ap) { g_ptr_array_add (unique, g_object_ref (ap)); } } out: return unique; }
WifiAccessPoint *createNMWifiAccessPoint(NMAccessPoint *ap) { const GByteArray *ssid = nm_access_point_get_ssid(ap); //GBytes *ssid = nm_access_point_get_ssid(ap); char *ssid_str = NULL, *ssid_hex_str = NULL; bool security = resolveAPSecurity(ap); /* Convert to strings */ if (ssid) { const guint8 *ssid_data = ssid->data; gsize ssid_len = ssid->len; //ssid_data = (const guint8 *) g_bytes_get_data(ssid, &ssid_len); ssid_str = nm_utils_ssid_to_utf8(ssid); } if (!ssid_str || !ssid) DBG("libnm conversion of ssid to utf8 failed, using empty string"); return new WifiAccessPoint { !ssid_str ? "" : ssid_str, nm_access_point_get_strength(ap), security, utils_hash_ap(nm_access_point_get_ssid(ap), nm_access_point_get_mode(ap), nm_access_point_get_flags(ap), nm_access_point_get_wpa_flags(ap), nm_access_point_get_rsn_flags(ap)), }; }
static void update_current_ap (NMWifiItem *self) { NMWifiItemPrivate *priv = GET_PRIVATE (self); GSList *iter; /* FIXME: If device is activated, use activation AP only */ for (iter = priv->ap_list; iter; iter = iter->next) { NMAccessPoint *ap = (NMAccessPoint *) iter->data; if (!priv->current_ap || nm_access_point_get_strength (priv->current_ap) < nm_access_point_get_strength (ap)) priv->current_ap = ap; } update_icon (self); }
static void detail_access_point (gpointer data, gpointer user_data) { NMAccessPoint *ap = NM_ACCESS_POINT (data); const char *active_bssid = (const char *) user_data; GString *str; gboolean active = FALSE; guint32 flags, wpa_flags, rsn_flags; const GByteArray * ssid; char *tmp; flags = nm_access_point_get_flags (ap); wpa_flags = nm_access_point_get_wpa_flags (ap); rsn_flags = nm_access_point_get_rsn_flags (ap); if (active_bssid) { const char *current_bssid = nm_access_point_get_hw_address (ap); if (current_bssid && !strcmp (current_bssid, active_bssid)) active = TRUE; } str = g_string_new (NULL); g_string_append_printf (str, "%s, %s, Freq %d MHz, Rate %d Mb/s, Strength %d", (nm_access_point_get_mode (ap) == NM_802_11_MODE_INFRA) ? "Infra" : "Ad-Hoc", nm_access_point_get_hw_address (ap), nm_access_point_get_frequency (ap), nm_access_point_get_max_bitrate (ap) / 1000, nm_access_point_get_strength (ap)); if ( !(flags & NM_802_11_AP_FLAGS_PRIVACY) && (wpa_flags != NM_802_11_AP_SEC_NONE) && (rsn_flags != NM_802_11_AP_SEC_NONE)) g_string_append (str, ", Encrypted: "); if ( (flags & NM_802_11_AP_FLAGS_PRIVACY) && (wpa_flags == NM_802_11_AP_SEC_NONE) && (rsn_flags == NM_802_11_AP_SEC_NONE)) g_string_append (str, " WEP"); if (wpa_flags != NM_802_11_AP_SEC_NONE) g_string_append (str, " WPA"); if (rsn_flags != NM_802_11_AP_SEC_NONE) g_string_append (str, " WPA2"); if ( (wpa_flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X) || (rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X)) g_string_append (str, " Enterprise"); /* FIXME: broadcast/hidden */ ssid = nm_access_point_get_ssid (ap); tmp = g_strdup_printf (" %s%s", active ? "*" : "", ssid ? nm_utils_escape_ssid (ssid->data, ssid->len) : "(none)"); print_string (tmp, str->str); g_string_free (str, TRUE); g_free (tmp); }
static void get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { NMAccessPoint *ap = NM_ACCESS_POINT (object); _nm_object_ensure_inited (NM_OBJECT (object)); switch (prop_id) { case PROP_FLAGS: g_value_set_uint (value, nm_access_point_get_flags (ap)); break; case PROP_WPA_FLAGS: g_value_set_uint (value, nm_access_point_get_wpa_flags (ap)); break; case PROP_RSN_FLAGS: g_value_set_uint (value, nm_access_point_get_rsn_flags (ap)); break; case PROP_SSID: g_value_set_boxed (value, nm_access_point_get_ssid (ap)); break; case PROP_FREQUENCY: g_value_set_uint (value, nm_access_point_get_frequency (ap)); break; case PROP_HW_ADDRESS: g_value_set_string (value, nm_access_point_get_bssid (ap)); break; case PROP_BSSID: g_value_set_string (value, nm_access_point_get_bssid (ap)); break; case PROP_MODE: g_value_set_uint (value, nm_access_point_get_mode (ap)); break; case PROP_MAX_BITRATE: g_value_set_uint (value, nm_access_point_get_max_bitrate (ap)); break; case PROP_STRENGTH: g_value_set_uchar (value, nm_access_point_get_strength (ap)); break; case PROP_LAST_SEEN: g_value_set_int (value, nm_access_point_get_last_seen (ap)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void update_icon (NMWifiItem *self) { NMWifiItemPrivate *priv = GET_PRIVATE (self); const char *icon; guint strength; strength = CLAMP (nm_access_point_get_strength (priv->current_ap), 0, 100); if (strength > 80) icon = "nm-signal-100-active"; else if (strength > 55) icon = "nm-signal-75-active"; else if (strength > 30) icon = "nm-signal-50-active"; else if (strength > 5) icon = "nm-signal-25-active"; else icon = "nm-signal-00-active"; if (icon) g_object_set (self, NM_LIST_ITEM_ICON, icon, NULL); }
static void dump_access_point (NMAccessPoint *ap) { const GByteArray * ssid; const char * str; ssid = nm_access_point_get_ssid (ap); g_print ("\tSsid: %s\n", ssid ? nm_utils_escape_ssid (ssid->data, ssid->len) : "(none)"); str = nm_access_point_get_hw_address (ap); g_print ("\tMAC Address: %s\n", str); g_print ("\tFlags: 0x%X\n", nm_access_point_get_flags (ap)); g_print ("\tWPA Flags: 0x%X\n", nm_access_point_get_wpa_flags (ap)); g_print ("\tRSN Flags: 0x%X\n", nm_access_point_get_rsn_flags (ap)); g_print ("\tFrequency: %u\n", nm_access_point_get_frequency (ap)); g_print ("\tMode: %d\n", nm_access_point_get_mode (ap)); g_print ("\tRate: %d\n", nm_access_point_get_max_bitrate (ap)); g_print ("\tStrength: %d\n", nm_access_point_get_strength (ap)); }
static void add_access_point (GisNetworkPage *page, NMAccessPoint *ap, NMAccessPoint *active) { GisNetworkPagePrivate *priv = page->priv; const GByteArray *ssid; const gchar *ssid_text; const gchar *object_path; GtkTreeIter iter; gboolean activated, activating; ssid = nm_access_point_get_ssid (ap); object_path = nm_object_get_path (NM_OBJECT (ap)); if (ssid == NULL) return; ssid_text = nm_utils_escape_ssid (ssid->data, ssid->len); if (active && nm_utils_same_ssid (ssid, nm_access_point_get_ssid (active), TRUE)) { switch (nm_device_get_state (priv->nm_device)) { case NM_DEVICE_STATE_PREPARE: case NM_DEVICE_STATE_CONFIG: case NM_DEVICE_STATE_NEED_AUTH: case NM_DEVICE_STATE_IP_CONFIG: case NM_DEVICE_STATE_SECONDARIES: activated = FALSE; activating = TRUE; break; case NM_DEVICE_STATE_ACTIVATED: activated = TRUE; activating = FALSE; break; default: activated = FALSE; activating = FALSE; break; } } else { activated = FALSE; activating = FALSE; } gtk_list_store_append (priv->ap_list, &iter); gtk_list_store_set (priv->ap_list, &iter, PANEL_WIRELESS_COLUMN_ID, object_path, PANEL_WIRELESS_COLUMN_TITLE, ssid_text, PANEL_WIRELESS_COLUMN_STRENGTH, nm_access_point_get_strength (ap), PANEL_WIRELESS_COLUMN_MODE, nm_access_point_get_mode (ap), PANEL_WIRELESS_COLUMN_SECURITY, get_access_point_security (ap), PANEL_WIRELESS_COLUMN_ACTIVATING, activating, PANEL_WIRELESS_COLUMN_ACTIVE, activated, PANEL_WIRELESS_COLUMN_PULSE, priv->pulse, -1); if (activating) { GtkTreePath *path; GtkTreeModel *model; model = (GtkTreeModel*)priv->ap_list; path = gtk_tree_model_get_path (model, &iter); priv->row = gtk_tree_row_reference_new (model, path); gtk_tree_path_free (path); g_timeout_add (160, bump_pulse, page); } }
static void add_access_point (GisNetworkPage *page, NMAccessPoint *ap, NMAccessPoint *active) { GisNetworkPagePrivate *priv = gis_network_page_get_instance_private (page); const GByteArray *ssid; gchar *ssid_text; const gchar *object_path; gboolean activated, activating; guint security; guint strength; const gchar *icon_name; GtkWidget *row; GtkWidget *widget; GtkWidget *box; ssid = nm_access_point_get_ssid (ap); object_path = nm_object_get_path (NM_OBJECT (ap)); if (ssid == NULL) return; ssid_text = nm_utils_ssid_to_utf8 (ssid); if (active && nm_utils_same_ssid (ssid, nm_access_point_get_ssid (active), TRUE)) { switch (nm_device_get_state (priv->nm_device)) { case NM_DEVICE_STATE_PREPARE: case NM_DEVICE_STATE_CONFIG: case NM_DEVICE_STATE_NEED_AUTH: case NM_DEVICE_STATE_IP_CONFIG: case NM_DEVICE_STATE_SECONDARIES: activated = FALSE; activating = TRUE; break; case NM_DEVICE_STATE_ACTIVATED: activated = TRUE; activating = FALSE; break; default: activated = FALSE; activating = FALSE; break; } } else { activated = FALSE; activating = FALSE; } security = get_access_point_security (ap); strength = nm_access_point_get_strength (ap); row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_widget_set_margin_start (row, 12); gtk_widget_set_margin_end (row, 12); widget = gtk_label_new (ssid_text); gtk_widget_set_margin_top (widget, 12); gtk_widget_set_margin_bottom (widget, 12); gtk_box_pack_start (GTK_BOX (row), widget, FALSE, FALSE, 0); if (activated) { widget = gtk_image_new_from_icon_name ("object-select-symbolic", GTK_ICON_SIZE_MENU); gtk_widget_set_halign (widget, GTK_ALIGN_CENTER); gtk_widget_set_valign (widget, GTK_ALIGN_CENTER); gtk_box_pack_start (GTK_BOX (row), widget, FALSE, FALSE, 0); } widget = gtk_spinner_new (); gtk_widget_set_no_show_all (widget, TRUE); if (activating) { gtk_widget_show (widget); gtk_spinner_start (GTK_SPINNER (widget)); } gtk_widget_set_halign (widget, GTK_ALIGN_CENTER); gtk_widget_set_valign (widget, GTK_ALIGN_CENTER); gtk_box_pack_start (GTK_BOX (row), widget, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (row), gtk_label_new (""), TRUE, FALSE, 0); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_set_homogeneous (GTK_BOX (box), TRUE); gtk_size_group_add_widget (priv->icons, box); gtk_box_pack_start (GTK_BOX (row), box, FALSE, FALSE, 0); if (security != NM_AP_SEC_UNKNOWN && security != NM_AP_SEC_NONE) { widget = gtk_image_new_from_icon_name ("network-wireless-encrypted-symbolic", GTK_ICON_SIZE_MENU); } else { widget = gtk_label_new (""); } gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 0); if (strength < 20) icon_name = "network-wireless-signal-none-symbolic"; else if (strength < 40) icon_name = "network-wireless-signal-weak-symbolic"; else if (strength < 50) icon_name = "network-wireless-signal-ok-symbolic"; else if (strength < 80) icon_name = "network-wireless-signal-good-symbolic"; else icon_name = "network-wireless-signal-excellent-symbolic"; widget = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU); gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 0); gtk_widget_show_all (row); g_object_set_data (G_OBJECT (row), "object-path", (gpointer) object_path); g_object_set_data (G_OBJECT (row), "ssid", (gpointer) ssid); g_object_set_data (G_OBJECT (row), "strength", GUINT_TO_POINTER (strength)); gtk_container_add (GTK_CONTAINER (priv->network_list), row); }
static void nmt_connect_connection_list_rebuild (NmtConnectConnectionList *list) { NmtConnectConnectionListPrivate *priv = NMT_CONNECT_CONNECTION_LIST_GET_PRIVATE (list); NmtNewtListbox *listbox = NMT_NEWT_LISTBOX (list); const GPtrArray *devices, *acs, *connections; int max_width; char **names, *row, active_col; const char *strength_col; GSList *nmt_devices, *diter, *citer; NmtConnectDevice *nmtdev; NmtConnectConnection *nmtconn; g_slist_free_full (priv->nmt_devices, (GDestroyNotify) nmt_connect_device_free); priv->nmt_devices = NULL; nmt_newt_listbox_clear (listbox); devices = nm_client_get_devices (nm_client); acs = nm_client_get_active_connections (nm_client); connections = nm_client_get_connections (nm_client); nmt_devices = NULL; names = nm_device_disambiguate_names ((NMDevice **) devices->pdata, devices->len); nmt_devices = append_nmt_devices_for_devices (nmt_devices, devices, names, connections); g_strfreev (names); nmt_devices = append_nmt_devices_for_virtual_devices (nmt_devices, connections); nmt_devices = append_nmt_devices_for_vpns (nmt_devices, connections); nmt_devices = g_slist_sort (nmt_devices, sort_nmt_devices); max_width = 0; for (diter = nmt_devices; diter; diter = diter->next) { nmtdev = diter->data; for (citer = nmtdev->conns; citer; citer = citer->next) { nmtconn = citer->data; max_width = MAX (max_width, nmt_newt_text_width (nmtconn->name)); } } for (diter = nmt_devices; diter; diter = diter->next) { nmtdev = diter->data; if (diter != nmt_devices) nmt_newt_listbox_append (listbox, "", NULL); nmt_newt_listbox_append (listbox, nmtdev->name, NULL); for (citer = nmtdev->conns; citer; citer = citer->next) { nmtconn = citer->data; if (nmtconn->conn) nmtconn->active = connection_find_ac (nmtconn->conn, acs); if (nmtconn->active) { g_object_ref (nmtconn->active); active_col = '*'; } else active_col = ' '; if (nmtconn->ap) { guint8 strength = nm_access_point_get_strength (nmtconn->ap); strength_col = nm_utils_wifi_strength_bars (strength); } else strength_col = NULL; row = g_strdup_printf ("%c %s%-*s%s%s", active_col, nmtconn->name, (int)(max_width - nmt_newt_text_width (nmtconn->name)), "", strength_col ? " " : "", strength_col ? strength_col : ""); nmt_newt_listbox_append (listbox, row, nmtconn); g_free (row); } } priv->nmt_devices = nmt_devices; g_object_notify (G_OBJECT (listbox), "active"); g_object_notify (G_OBJECT (listbox), "active-key"); }
static void print_access_point_info (NMAccessPoint * ap, gboolean active, guint32 device_capas) { const char * bssid; const GByteArray * ssid; NM80211Mode mode; guint32 frequency; guint32 max_bitrate; guint32 signal_strength; guint32 ap_flags; guint32 wpa_flags; guint32 rsn_flags; char *ssid_str; gboolean is_adhoc; gchar * sec_opts[5]; /* Currently five security options is defined */ gint sec_opts_num, i; g_return_if_fail (NM_IS_ACCESS_POINT (ap)); mode = nm_access_point_get_mode (ap); ap_flags = nm_access_point_get_flags (ap); wpa_flags = nm_access_point_get_wpa_flags (ap); rsn_flags = nm_access_point_get_rsn_flags (ap); is_adhoc = (mode == NM_802_11_MODE_ADHOC); /* Skip access point not compatible with device's capabilities */ if ( !nm_utils_security_valid (NMU_SEC_NONE, device_capas, TRUE, is_adhoc, ap_flags, wpa_flags, rsn_flags) && !nm_utils_security_valid (NMU_SEC_STATIC_WEP, device_capas, TRUE, is_adhoc, ap_flags, wpa_flags, rsn_flags) && !nm_utils_security_valid (NMU_SEC_LEAP, device_capas, TRUE, is_adhoc, ap_flags, wpa_flags, rsn_flags) && !nm_utils_security_valid (NMU_SEC_DYNAMIC_WEP, device_capas, TRUE, is_adhoc, ap_flags, wpa_flags, rsn_flags) && !nm_utils_security_valid (NMU_SEC_WPA_PSK, device_capas, TRUE, is_adhoc, ap_flags, wpa_flags, rsn_flags) && !nm_utils_security_valid (NMU_SEC_WPA2_PSK, device_capas, TRUE, is_adhoc, ap_flags, wpa_flags, rsn_flags) && !nm_utils_security_valid (NMU_SEC_WPA_ENTERPRISE, device_capas,TRUE, is_adhoc, ap_flags, wpa_flags, rsn_flags) && !nm_utils_security_valid (NMU_SEC_WPA2_ENTERPRISE, device_capas, TRUE, is_adhoc, ap_flags, wpa_flags, rsn_flags)) return; bssid = nm_access_point_get_hw_address (ap); ssid = nm_access_point_get_ssid (ap); frequency = nm_access_point_get_frequency (ap); max_bitrate = nm_access_point_get_max_bitrate (ap); signal_strength = nm_access_point_get_strength (ap); ssid_str = nm_utils_ssid_to_utf8 ((const char *) ssid->data, ssid->len); sec_opts_num = 0; if ((ap_flags & NM_802_11_AP_FLAGS_PRIVACY) && !wpa_flags && !rsn_flags) sec_opts[sec_opts_num++] = "wep"; if (!is_adhoc) { if (wpa_flags & NM_802_11_AP_SEC_KEY_MGMT_PSK) sec_opts[sec_opts_num++] = "wpa-psk"; if (rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_PSK) sec_opts[sec_opts_num++] = "wpa2-psk"; if (wpa_flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X) sec_opts[sec_opts_num++] = "wpa-eap"; if (rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X) sec_opts[sec_opts_num++] = "wpa2-eap"; } g_print ("%-9s BSSID:%s Frequency:%dMHz", "", bssid, frequency); if (active) g_print (" <-- ACTIVE"); g_print ("\n"); g_print ("%-15s SSID:%s Mode:%s\n", "", ssid_str, wifi_mode_to_string(mode)); g_print ("%-15s Signal:%d MaxBitrate:%.1fMb/s Security:", "", signal_strength, max_bitrate/1000.0); if (sec_opts_num == 0) { g_print ("none"); } else { for (i = 0; i < sec_opts_num; i++) { g_print ("%s", sec_opts[i]); if (i != sec_opts_num - 1) g_print (" "); } } g_print ("\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); }
static void show_access_point_info (NMAccessPoint *ap) { guint32 flags, wpa_flags, rsn_flags, freq, bitrate; guint8 strength; const GByteArray *ssid; const char *hwaddr; NM80211Mode mode; char *freq_str, *ssid_str, *bitrate_str, *strength_str, *wpa_flags_str, *rsn_flags_str; GString *security_str; /* Get AP properties */ flags = nm_access_point_get_flags (ap); wpa_flags = nm_access_point_get_wpa_flags (ap); rsn_flags = nm_access_point_get_rsn_flags (ap); ssid = nm_access_point_get_ssid (ap); hwaddr = nm_access_point_get_hw_address (ap); freq = nm_access_point_get_frequency (ap); mode = nm_access_point_get_mode (ap); bitrate = nm_access_point_get_max_bitrate (ap); strength = nm_access_point_get_strength (ap); /* Convert to strings */ ssid_str = nm_utils_ssid_to_utf8 (ssid); freq_str = g_strdup_printf ("%u MHz", freq); bitrate_str = g_strdup_printf ("%u MB/s", bitrate/1000); strength_str = g_strdup_printf ("%u", strength); wpa_flags_str = ap_wpa_rsn_flags_to_string (wpa_flags); rsn_flags_str = ap_wpa_rsn_flags_to_string (rsn_flags); security_str = g_string_new (NULL); if ( !(flags & NM_802_11_AP_FLAGS_PRIVACY) && (wpa_flags != NM_802_11_AP_SEC_NONE) && (rsn_flags != NM_802_11_AP_SEC_NONE)) g_string_append (security_str, "Encrypted: "); if ( (flags & NM_802_11_AP_FLAGS_PRIVACY) && (wpa_flags == NM_802_11_AP_SEC_NONE) && (rsn_flags == NM_802_11_AP_SEC_NONE)) g_string_append (security_str, "WEP "); if (wpa_flags != NM_802_11_AP_SEC_NONE) g_string_append (security_str, "WPA "); if (rsn_flags != NM_802_11_AP_SEC_NONE) g_string_append (security_str, "WPA2 "); if ( (wpa_flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X) || (rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X)) g_string_append (security_str, "Enterprise "); if (security_str->len > 0) g_string_truncate (security_str, security_str->len-1); /* Chop off last space */ printf ("SSID: %s\n", ssid_str); printf ("BSSID: %s\n", hwaddr); printf ("Mode: %s\n", mode == NM_802_11_MODE_ADHOC ? "Ad-Hoc" : mode == NM_802_11_MODE_INFRA ? "Infrastructure" : "Unknown"); printf ("Freq: %s\n", freq_str); printf ("Bitrate: %s\n", bitrate_str); printf ("Strength: %s\n", strength_str); printf ("Security: %s\n", security_str->str); printf ("WPA flags: %s\n", wpa_flags_str); printf ("RSN flags: %s\n", rsn_flags_str); printf ("D-Bus path: %s\n\n", nm_object_get_path (NM_OBJECT (ap))); g_free (ssid_str); g_free (freq_str); g_free (bitrate_str); g_free (strength_str); g_free (wpa_flags_str); g_free (rsn_flags_str); g_string_free (security_str, TRUE); }