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; }
static void clean_up_aps (NMDeviceWifi *self, gboolean in_dispose) { NMDeviceWifiPrivate *priv; GPtrArray *aps; int i; g_return_if_fail (NM_IS_DEVICE_WIFI (self)); priv = NM_DEVICE_WIFI_GET_PRIVATE (self); if (priv->active_ap) { g_object_unref (priv->active_ap); priv->active_ap = NULL; } aps = priv->aps; if (in_dispose) priv->aps = NULL; else { priv->aps = g_ptr_array_new (); for (i = 0; i < aps->len; i++) { NMAccessPoint *ap = NM_ACCESS_POINT (g_ptr_array_index (aps, i)); g_signal_emit (self, signals[ACCESS_POINT_REMOVED], 0, ap); } } g_ptr_array_unref (aps); }
static void clean_up_aps (NMDeviceWifi *self, gboolean notify) { NMDeviceWifiPrivate *priv; g_return_if_fail (NM_IS_DEVICE_WIFI (self)); priv = NM_DEVICE_WIFI_GET_PRIVATE (self); if (priv->active_ap) { g_object_unref (priv->active_ap); priv->active_ap = NULL; } if (priv->aps) { while (priv->aps->len) { NMAccessPoint *ap = NM_ACCESS_POINT (g_ptr_array_index (priv->aps, 0)); if (notify) g_signal_emit (self, signals[ACCESS_POINT_REMOVED], 0, ap); g_ptr_array_remove (priv->aps, ap); g_object_unref (ap); } g_ptr_array_free (priv->aps, TRUE); priv->aps = NULL; } }
static void access_point_added_proxy (DBusGProxy *proxy, char *path, gpointer user_data) { NMDeviceWifi *self = NM_DEVICE_WIFI (user_data); NMDeviceWifiPrivate *priv; GObject *ap; g_return_if_fail (self != NULL); ap = G_OBJECT (nm_device_wifi_get_access_point_by_path (self, path)); if (!ap) { DBusGConnection *connection = nm_object_get_connection (NM_OBJECT (self)); priv = NM_DEVICE_WIFI_GET_PRIVATE (self); ap = G_OBJECT (_nm_object_cache_get (path)); if (ap) { g_ptr_array_add (priv->aps, g_object_ref (ap)); } else { ap = G_OBJECT (nm_access_point_new (connection, path)); if (ap) g_ptr_array_add (priv->aps, ap); } } if (ap) g_signal_emit (self, signals[ACCESS_POINT_ADDED], 0, NM_ACCESS_POINT (ap)); }
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 constructed (GObject *object) { NMAccessPointPrivate *priv; G_OBJECT_CLASS (nm_access_point_parent_class)->constructed (object); priv = NM_ACCESS_POINT_GET_PRIVATE (object); priv->proxy = _nm_object_new_proxy (NM_OBJECT (object), NULL, NM_DBUS_INTERFACE_ACCESS_POINT); register_properties (NM_ACCESS_POINT (object)); }
static gboolean demarshal_active_ap (NMObject *object, GParamSpec *pspec, GValue *value, gpointer field) { NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (object); const char *path; NMAccessPoint *ap = NULL; DBusGConnection *connection; if (!G_VALUE_HOLDS (value, DBUS_TYPE_G_OBJECT_PATH)) return FALSE; priv->null_active_ap = FALSE; path = g_value_get_boxed (value); if (path) { if (!strcmp (path, "/")) priv->null_active_ap = TRUE; else { ap = NM_ACCESS_POINT (_nm_object_cache_get (path)); if (ap) ap = g_object_ref (ap); else { connection = nm_object_get_connection (object); ap = NM_ACCESS_POINT (nm_access_point_new (connection, path)); } } } if (priv->active_ap) { g_object_unref (priv->active_ap); priv->active_ap = NULL; } if (ap) priv->active_ap = ap; _nm_object_queue_notify (object, NM_DEVICE_WIFI_ACTIVE_ACCESS_POINT); return TRUE; }
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 set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { NMWifiItem *self = NM_WIFI_ITEM (object); switch (prop_id) { case PROP_AP: /* Construct only */ nm_wifi_item_add_ap (self, NM_ACCESS_POINT (g_value_dup_object (value))); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static void access_point_removed (NMObject *self_obj, NMObject *ap_obj) { NMDeviceWifi *self = NM_DEVICE_WIFI (self_obj); NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (self); NMAccessPoint *ap = NM_ACCESS_POINT (ap_obj); if (ap == priv->active_ap) { g_object_unref (priv->active_ap); priv->active_ap = NULL; _nm_object_queue_notify (NM_OBJECT (self), NM_DEVICE_WIFI_ACTIVE_ACCESS_POINT); priv->rate = 0; _nm_object_queue_notify (NM_OBJECT (self), NM_DEVICE_WIFI_BITRATE); } g_signal_emit (self, signals[ACCESS_POINT_REMOVED], 0, ap); }
static void dump_wireless (NMDeviceWifi *device) { const char *str; const GPtrArray *aps; int i; g_print ("Mode: %d\n", nm_device_wifi_get_mode (device)); g_print ("Bitrate: %d\n", nm_device_wifi_get_bitrate (device)); str = nm_device_wifi_get_hw_address (device); g_print ("MAC: %s\n", str); g_print ("AccessPoints:\n"); aps = nm_device_wifi_get_access_points (device); for (i = 0; aps && (i < aps->len); i++) { dump_access_point (NM_ACCESS_POINT (g_ptr_array_index (aps, i))); g_print ("\n"); } }
static void refresh_wireless_list (GisNetworkPage *page) { GisNetworkPagePrivate *priv = gis_network_page_get_instance_private (page); NMAccessPoint *active_ap = NULL; NMAccessPoint *ap; const GPtrArray *aps; GPtrArray *unique_aps; guint i; GList *children, *l; priv->refreshing = TRUE; g_assert (NM_IS_DEVICE_WIFI (priv->nm_device)); if (priv->refresh_timeout_id != 0) { g_source_remove (priv->refresh_timeout_id); priv->refresh_timeout_id = 0; } active_ap = nm_device_wifi_get_active_access_point (NM_DEVICE_WIFI (priv->nm_device)); children = gtk_container_get_children (GTK_CONTAINER (priv->network_list)); for (l = children; l; l = l->next) gtk_container_remove (GTK_CONTAINER (priv->network_list), l->data); g_list_free (children); aps = nm_device_wifi_get_access_points (NM_DEVICE_WIFI (priv->nm_device)); if (aps == NULL || aps->len == 0) { gboolean enabled, hw_enabled; enabled = nm_client_wireless_get_enabled (priv->nm_client); hw_enabled = nm_client_wireless_hardware_get_enabled (priv->nm_client); if (!enabled || !hw_enabled) { gtk_label_set_text (GTK_LABEL (priv->no_network_label), _("Wireless networking is disabled")); gtk_widget_show (priv->no_network_label); gtk_widget_hide (priv->no_network_spinner); gtk_widget_set_visible (priv->turn_on_label, hw_enabled); gtk_widget_set_visible (priv->turn_on_switch, hw_enabled); } else { gtk_label_set_text (GTK_LABEL (priv->no_network_label), _("Checking for available wireless networks")); gtk_widget_show (priv->no_network_spinner); gtk_widget_show (priv->no_network_label); gtk_widget_hide (priv->turn_on_label); gtk_widget_hide (priv->turn_on_switch); } gtk_widget_hide (priv->scrolled_window); priv->refresh_timeout_id = g_timeout_add_seconds (1, refresh_again, page); goto out; } else { gtk_widget_hide (priv->no_network_spinner); gtk_widget_hide (priv->no_network_label); gtk_widget_hide (priv->turn_on_label); gtk_widget_hide (priv->turn_on_switch); gtk_widget_show (priv->scrolled_window); } unique_aps = get_strongest_unique_aps (aps); for (i = 0; i < unique_aps->len; i++) { ap = NM_ACCESS_POINT (g_ptr_array_index (unique_aps, i)); add_access_point (page, ap, active_ap); } g_ptr_array_unref (unique_aps); add_access_point_other (page); out: priv->refreshing = FALSE; }