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
add_connections_for_aps (NmtConnectDevice *nmtdev,
const GPtrArray *connections)
{
NmtConnectConnection *nmtconn;
NMConnection *conn;
NMAccessPoint *ap;
const GPtrArray *aps;
GHashTable *seen_ssids;
GBytes *ssid;
char *ap_hash;
int i, c;
aps = nm_device_wifi_get_access_points (NM_DEVICE_WIFI (nmtdev->device));
if (!aps->len)
return;
seen_ssids = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
for (i = 0; i < aps->len; i++) {
ap = aps->pdata[i];
if (!nm_access_point_get_ssid (ap))
continue;
ap_hash = hash_ap (ap);
if (g_hash_table_contains (seen_ssids, ap_hash)) {
g_free (ap_hash);
continue;
}
g_hash_table_add (seen_ssids, ap_hash);
nmtconn = g_slice_new0 (NmtConnectConnection);
nmtconn->device = nmtdev->device;
nmtconn->ap = g_object_ref (ap);
ssid = nm_access_point_get_ssid (ap);
if (ssid)
nmtconn->ssid = nm_utils_ssid_to_utf8 (g_bytes_get_data (ssid, NULL),
g_bytes_get_size (ssid));
for (c = 0; c < connections->len; c++) {
conn = connections->pdata[c];
if ( nm_device_connection_valid (nmtdev->device, conn)
&& nm_access_point_connection_valid (ap, conn)) {
nmtconn->name = nm_connection_get_id (conn);
nmtconn->conn = g_object_ref (conn);
break;
}
}
if (!nmtconn->name)
nmtconn->name = nmtconn->ssid ? nmtconn->ssid : "<unknown>";
nmtdev->conns = g_slist_prepend (nmtdev->conns, nmtconn);
}
g_hash_table_unref (seen_ssids);
}
static void
add_connections_for_aps (NmtConnectDevice *nmtdev,
GSList *connections)
{
NmtConnectConnection *nmtconn;
NMConnection *conn;
NMAccessPoint *ap;
const GPtrArray *aps;
GHashTable *seen_ssids;
char *ap_hash;
GSList *iter;
int i;
aps = nm_device_wifi_get_access_points (NM_DEVICE_WIFI (nmtdev->device));
if (!aps)
return;
seen_ssids = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
for (i = 0; i < aps->len; i++) {
ap = aps->pdata[i];
if (!nm_access_point_get_ssid (ap))
continue;
ap_hash = hash_ap (ap);
if (g_hash_table_contains (seen_ssids, ap_hash)) {
g_free (ap_hash);
continue;
}
g_hash_table_add (seen_ssids, ap_hash);
nmtconn = g_slice_new0 (NmtConnectConnection);
nmtconn->device = nmtdev->device;
nmtconn->ap = g_object_ref (ap);
nmtconn->ssid = nm_utils_ssid_to_utf8 (nm_access_point_get_ssid (ap));
for (iter = connections; iter; iter = iter->next) {
conn = iter->data;
if ( nm_device_connection_valid (nmtdev->device, conn)
&& nm_access_point_connection_valid (ap, conn)) {
nmtconn->name = nm_connection_get_id (conn);
nmtconn->conn = g_object_ref (conn);
break;
}
}
if (!iter)
nmtconn->name = nmtconn->ssid;
nmtdev->conns = g_slist_prepend (nmtdev->conns, nmtconn);
}
g_hash_table_unref (seen_ssids);
}
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
constructed (GObject *object)
{
NMWifiItemPrivate *priv = GET_PRIVATE (object);
const GByteArray *ssid;
char *str;
guint32 flags;
guint32 wpa_flags;
guint32 rsn_flags;
if (G_OBJECT_CLASS (nm_wifi_item_parent_class)->constructed)
G_OBJECT_CLASS (nm_wifi_item_parent_class)->constructed (object);
ssid = nm_access_point_get_ssid (priv->current_ap);
str = nm_utils_ssid_to_utf8 ((char *) ssid->data, ssid->len);
g_object_set (object, NM_LIST_ITEM_NAME, str, NULL);
g_free (str);
flags = nm_access_point_get_flags (priv->current_ap);
wpa_flags = nm_access_point_get_wpa_flags (priv->current_ap);
rsn_flags = nm_access_point_get_rsn_flags (priv->current_ap);
if (rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_PSK ||
wpa_flags & NM_802_11_AP_SEC_KEY_MGMT_PSK ||
rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X ||
wpa_flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X)
str = "WPA encrypted";
else if (flags & NM_802_11_AP_FLAGS_PRIVACY)
str = "WEP encrypted";
else
str = NULL;
if (str)
g_object_set (object, NM_LIST_ITEM_SECURITY, str, NULL);
}
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;
}
}
/* stolen from nm-applet */
static char *
hash_ap (NMAccessPoint *ap)
{
unsigned char input[66];
GBytes *ssid;
NM80211Mode mode;
guint32 flags;
guint32 wpa_flags;
guint32 rsn_flags;
memset (&input[0], 0, sizeof (input));
ssid = nm_access_point_get_ssid (ap);
if (ssid)
memcpy (input, g_bytes_get_data (ssid, NULL), g_bytes_get_size (ssid));
mode = nm_access_point_get_mode (ap);
if (mode == NM_802_11_MODE_INFRA)
input[32] |= (1 << 0);
else if (mode == NM_802_11_MODE_ADHOC)
input[32] |= (1 << 1);
else
input[32] |= (1 << 2);
/* Separate out no encryption, WEP-only, and WPA-capable */
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 ( !(flags & NM_802_11_AP_FLAGS_PRIVACY)
&& (wpa_flags == NM_802_11_AP_SEC_NONE)
&& (rsn_flags == NM_802_11_AP_SEC_NONE))
input[32] |= (1 << 3);
else if ( (flags & NM_802_11_AP_FLAGS_PRIVACY)
&& (wpa_flags == NM_802_11_AP_SEC_NONE)
&& (rsn_flags == NM_802_11_AP_SEC_NONE))
input[32] |= (1 << 4);
else if ( !(flags & NM_802_11_AP_FLAGS_PRIVACY)
&& (wpa_flags != NM_802_11_AP_SEC_NONE)
&& (rsn_flags != NM_802_11_AP_SEC_NONE))
input[32] |= (1 << 5);
else
input[32] |= (1 << 6);
/* duplicate it */
memcpy (&input[33], &input[0], 32);
return g_compute_checksum_for_data (G_CHECKSUM_MD5, input, sizeof (input));
}
static void
select_and_scroll_to_ap (GisNetworkPage *page, NMAccessPoint *ap)
{
GisNetworkPagePrivate *priv = page->priv;
GtkTreeModel *model;
GtkTreeView *tv;
GtkTreeViewColumn *col;
GtkTreeSelection *selection;
GtkTreeIter iter;
GtkTreePath *path;
gchar *ssid_target;
const GByteArray *ssid;
const gchar *ssid_text;
model = (GtkTreeModel *)priv->ap_list;
if (!gtk_tree_model_get_iter_first (model, &iter))
return;
tv = OBJ(GtkTreeView*, "network-list");
col = OBJ(GtkTreeViewColumn*, "network-list-column");
selection = OBJ(GtkTreeSelection*, "network-list-selection");
ssid = nm_access_point_get_ssid (ap);
ssid_text = nm_utils_escape_ssid (ssid->data, ssid->len);
do {
gtk_tree_model_get (model, &iter,
PANEL_WIRELESS_COLUMN_TITLE, &ssid_target,
-1);
if (g_strcmp0 (ssid_target, ssid_text) == 0) {
g_free (ssid_target);
gtk_tree_selection_select_iter (selection, &iter);
path = gtk_tree_model_get_path (model, &iter);
gtk_tree_view_scroll_to_cell (tv, path, col, FALSE, 0, 0);
gtk_tree_path_free (path);
break;
}
g_free (ssid_target);
} while (gtk_tree_model_iter_next (model, &iter));
}
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
show_wifi_device_info (NMDevice *device)
{
NMAccessPoint *active_ap = NULL;
const GPtrArray *aps;
const char *iface;
const char *driver;
guint32 speed;
const GByteArray *active_ssid;
char *active_ssid_str = NULL;
int i;
/* Get active AP */
if (nm_device_get_state (device) == NM_DEVICE_STATE_ACTIVATED) {
if ((active_ap = nm_device_wifi_get_active_access_point (NM_DEVICE_WIFI (device)))) {
active_ssid = nm_access_point_get_ssid (active_ap);
active_ssid_str = nm_utils_ssid_to_utf8 (active_ssid);
}
}
iface = nm_device_get_iface (device);
driver = nm_device_get_driver (device);
speed = nm_device_wifi_get_bitrate (NM_DEVICE_WIFI (device));
speed /= 1000;
printf ("Device: %s ---- Driver: %s ---- Speed: %d MB/s ---- Active AP: %s\n",
iface, driver, speed, active_ssid_str ? active_ssid_str : "none");
printf ("=================================================================================\n");
g_free (active_ssid_str);
/* Get all APs of the Wi-Fi device */
aps = nm_device_wifi_get_access_points (NM_DEVICE_WIFI (device));
/* Print AP details */
for (i = 0; aps && (i < aps->len); i++) {
NMAccessPoint *ap = g_ptr_array_index (aps, i);
show_access_point_info (ap);
}
}
static NMConnection *
create_connection (NMConnectionItem *item)
{
NMConnection *connection;
NMDeviceWifi *device;
NMAccessPoint *ap;
NMSetting *s_con;
NMSetting *s_wireless;
NMSettingWirelessSecurity *s_wireless_sec;
NMSetting8021x *s_8021x = NULL;
const GByteArray *ap_ssid;
char *id;
char buf[33];
int buf_len;
NM80211Mode mode;
guint32 dev_caps;
gboolean supported = TRUE;
device = NM_DEVICE_WIFI (nm_device_item_get_device (NM_DEVICE_ITEM (item)));
ap = nm_wifi_item_get_ap (NM_WIFI_ITEM (item));
dev_caps = nm_device_wifi_get_capabilities (device);
s_wireless_sec = get_security_for_ap (ap, dev_caps, &supported, &s_8021x);
if (!supported)
return NULL;
if (NM_CONNECTION_ITEM_CLASS (nm_wifi_item_parent_class)->create_connection)
connection = NM_CONNECTION_ITEM_CLASS (nm_wifi_item_parent_class)->create_connection (item);
if (!connection)
return NULL;
s_wireless = nm_setting_wireless_new ();
ap_ssid = nm_access_point_get_ssid (ap);
g_object_set (s_wireless, NM_SETTING_WIRELESS_SSID, ap_ssid, NULL);
mode = nm_access_point_get_mode (ap);
if (mode == NM_802_11_MODE_ADHOC)
g_object_set (s_wireless, NM_SETTING_WIRELESS_MODE, "adhoc", NULL);
else if (mode == NM_802_11_MODE_INFRA)
g_object_set (s_wireless, NM_SETTING_WIRELESS_MODE, "infrastructure", NULL);
else
g_assert_not_reached ();
nm_connection_add_setting (connection, s_wireless);
if (s_wireless_sec) {
g_object_set (s_wireless, NM_SETTING_WIRELESS_SEC, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NULL);
nm_connection_add_setting (connection, NM_SETTING (s_wireless_sec));
}
if (s_8021x)
nm_connection_add_setting (connection, NM_SETTING (s_8021x));
s_con = nm_connection_get_setting (connection, NM_TYPE_SETTING_CONNECTION);
g_object_set (s_con,
NM_SETTING_CONNECTION_TYPE, nm_setting_get_name (s_wireless),
NM_SETTING_CONNECTION_AUTOCONNECT, !is_manufacturer_default_ssid (ap_ssid),
NULL);
memset (buf, 0, sizeof (buf));
buf_len = MIN (ap_ssid->len, sizeof (buf) - 1);
memcpy (buf, ap_ssid->data, buf_len);
id = nm_utils_ssid_to_utf8 (buf, buf_len);
g_object_set (s_con, NM_SETTING_CONNECTION_ID, id, NULL);
g_free (id);
return connection;
}
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");
}
/**
* nm_access_point_connection_valid:
* @ap: an #NMAccessPoint to validate @connection against
* @connection: an #NMConnection to validate against @ap
*
* Validates a given connection against a given Wi-Fi access point to ensure that
* the connection may be activated with that AP. The connection must match the
* @ap's SSID, (if given) BSSID, and other attributes like security settings,
* channel, band, etc.
*
* Returns: %TRUE if the connection may be activated with this Wi-Fi AP,
* %FALSE if it cannot be.
**/
gboolean
nm_access_point_connection_valid (NMAccessPoint *ap, NMConnection *connection)
{
NMSettingConnection *s_con;
NMSettingWireless *s_wifi;
NMSettingWirelessSecurity *s_wsec;
const char *ctype, *ap_bssid_str;
const GByteArray *setting_ssid;
const GByteArray *ap_ssid;
const GByteArray *setting_bssid;
struct ether_addr *ap_bssid;
const char *setting_mode;
NM80211Mode ap_mode;
const char *setting_band;
guint32 ap_freq, setting_chan, ap_chan;
s_con = nm_connection_get_setting_connection (connection);
g_assert (s_con);
ctype = nm_setting_connection_get_connection_type (s_con);
if (strcmp (ctype, NM_SETTING_WIRELESS_SETTING_NAME) != 0)
return FALSE;
s_wifi = nm_connection_get_setting_wireless (connection);
if (!s_wifi)
return FALSE;
/* SSID checks */
ap_ssid = nm_access_point_get_ssid (ap);
g_warn_if_fail (ap_ssid != NULL);
setting_ssid = nm_setting_wireless_get_ssid (s_wifi);
if (!setting_ssid || !ap_ssid || (setting_ssid->len != ap_ssid->len))
return FALSE;
if (memcmp (setting_ssid->data, ap_ssid->data, ap_ssid->len) != 0)
return FALSE;
/* BSSID checks */
ap_bssid_str = nm_access_point_get_bssid (ap);
g_warn_if_fail (ap_bssid_str);
setting_bssid = nm_setting_wireless_get_bssid (s_wifi);
if (setting_bssid && ap_bssid_str) {
g_assert (setting_bssid->len == ETH_ALEN);
ap_bssid = ether_aton (ap_bssid_str);
g_warn_if_fail (ap_bssid);
if (ap_bssid) {
if (memcmp (ap_bssid->ether_addr_octet, setting_bssid->data, ETH_ALEN) != 0)
return FALSE;
}
}
/* Mode */
ap_mode = nm_access_point_get_mode (ap);
g_warn_if_fail (ap_mode != NM_802_11_MODE_UNKNOWN);
setting_mode = nm_setting_wireless_get_mode (s_wifi);
if (setting_mode && ap_mode) {
if (!strcmp (setting_mode, "infrastructure") && (ap_mode != NM_802_11_MODE_INFRA))
return FALSE;
if (!strcmp (setting_mode, "adhoc") && (ap_mode != NM_802_11_MODE_ADHOC))
return FALSE;
/* Hotspot never matches against APs as it's a device-specific mode. */
if (!strcmp (setting_mode, "ap"))
return FALSE;
}
/* Band and Channel/Frequency */
ap_freq = nm_access_point_get_frequency (ap);
if (ap_freq) {
setting_band = nm_setting_wireless_get_band (s_wifi);
if (g_strcmp0 (setting_band, "a") == 0) {
if (ap_freq < 4915 || ap_freq > 5825)
return FALSE;
} else if (g_strcmp0 (setting_band, "bg") == 0) {
if (ap_freq < 2412 || ap_freq > 2484)
return FALSE;
}
setting_chan = nm_setting_wireless_get_channel (s_wifi);
if (setting_chan) {
ap_chan = nm_utils_wifi_freq_to_channel (ap_freq);
if (setting_chan != ap_chan)
return FALSE;
}
}
s_wsec = nm_connection_get_setting_wireless_security (connection);
if (!nm_setting_wireless_ap_security_compatible (s_wifi,
s_wsec,
nm_access_point_get_flags (ap),
nm_access_point_get_wpa_flags (ap),
nm_access_point_get_rsn_flags (ap),
ap_mode))
return FALSE;
return TRUE;
}
void
cc_network_panel_connect_to_8021x_network (CcNetworkPanel *panel,
NMClient *client,
NMRemoteSettings *settings,
NMDevice *device,
const gchar *arg_access_point)
{
NMConnection *connection;
NMSettingConnection *s_con;
NMSettingWireless *s_wifi;
NMSettingWirelessSecurity *s_wsec;
NMSetting8021x *s_8021x;
NM80211ApSecurityFlags wpa_flags, rsn_flags;
GtkWidget *dialog;
char *uuid;
NMAccessPoint *ap;
g_debug ("connect to 8021x wifi");
ap = nm_device_wifi_get_access_point_by_path (NM_DEVICE_WIFI (device), arg_access_point);
if (ap == NULL) {
g_warning ("didn't find access point with path %s", arg_access_point);
return;
}
/* If the AP is WPA[2]-Enterprise then we need to set up a minimal 802.1x
* setting and ask the user for more information.
*/
rsn_flags = nm_access_point_get_rsn_flags (ap);
wpa_flags = nm_access_point_get_wpa_flags (ap);
if (!(rsn_flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X)
&& !(wpa_flags & NM_802_11_AP_SEC_KEY_MGMT_802_1X)) {
g_warning ("Network panel loaded with connect-8021x-wifi but the "
"access point does not support 802.1x");
return;
}
connection = nm_connection_new ();
/* Need a UUID for the "always ask" stuff in the Dialog of Doom */
s_con = (NMSettingConnection *) nm_setting_connection_new ();
uuid = nm_utils_uuid_generate ();
g_object_set (s_con, NM_SETTING_CONNECTION_UUID, uuid, NULL);
g_free (uuid);
nm_connection_add_setting (connection, NM_SETTING (s_con));
s_wifi = (NMSettingWireless *) nm_setting_wireless_new ();
nm_connection_add_setting (connection, NM_SETTING (s_wifi));
g_object_set (s_wifi,
NM_SETTING_WIRELESS_SSID, nm_access_point_get_ssid (ap),
NM_SETTING_WIRELESS_SEC, NM_SETTING_WIRELESS_SECURITY_SETTING_NAME,
NULL);
s_wsec = (NMSettingWirelessSecurity *) nm_setting_wireless_security_new ();
g_object_set (s_wsec, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "wpa-eap", NULL);
nm_connection_add_setting (connection, NM_SETTING (s_wsec));
s_8021x = (NMSetting8021x *) nm_setting_802_1x_new ();
nm_setting_802_1x_add_eap_method (s_8021x, "ttls");
g_object_set (s_8021x, NM_SETTING_802_1X_PHASE2_AUTH, "mschapv2", NULL);
nm_connection_add_setting (connection, NM_SETTING (s_8021x));
dialog = nma_wireless_dialog_new (client, settings, connection, device, ap, FALSE);
show_wireless_dialog (panel, client, settings, dialog);
}
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
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);
}
void WifiStatusNM::setConnectedAccessPoint(WifiAccessPoint *ap, String psk) {
ScopedPointer<StringArray> cmd;
for (const auto& listener : listeners)
listener->handleWifiBusy();
// disconnect if no ap provided
if (ap == nullptr) {
NMActiveConnection *conn = nm_device_get_active_connection(nmdevice);
removeNMConnection(nmdevice, conn);
return;
}
// try to connect to ap, dispatch events on success and failure
else {
NMConnection *connection = NULL;
NMSettingWireless *s_wifi = NULL;
NMSettingWirelessSecurity *s_wsec = NULL;
const char *nm_ap_path = NULL;
const GPtrArray *ap_list;
NMAccessPoint *candidate_ap;
//FIXME: expand WifiAccessPoint struct to know which NMAccessPoint it is
ap_list = nm_device_wifi_get_access_points(NM_DEVICE_WIFI(nmdevice));
if (ap_list == NULL)
return;
for (int i = 0; i < ap_list->len; i++) {
const char *candidate_hash;
candidate_ap = (NMAccessPoint *) g_ptr_array_index(ap_list, i);
candidate_hash = utils_hash_ap(nm_access_point_get_ssid(candidate_ap),
nm_access_point_get_mode(candidate_ap),
nm_access_point_get_flags(candidate_ap),
nm_access_point_get_wpa_flags(candidate_ap),
nm_access_point_get_rsn_flags(candidate_ap));
if (ap->hash == candidate_hash) {
nm_ap_path = nm_object_get_path(NM_OBJECT(candidate_ap));
break;
}
}
if (!nm_ap_path)
return;
connecting = true;
connection = nm_connection_new();
s_wifi = (NMSettingWireless *) nm_setting_wireless_new();
nm_connection_add_setting(connection, NM_SETTING(s_wifi));
g_object_set(s_wifi,
NM_SETTING_WIRELESS_SSID, nm_access_point_get_ssid(candidate_ap),
NM_SETTING_WIRELESS_HIDDEN, false,
NULL);
if (!psk.isEmpty()) {
s_wsec = (NMSettingWirelessSecurity *) nm_setting_wireless_security_new();
nm_connection_add_setting(connection, NM_SETTING(s_wsec));
if (nm_access_point_get_wpa_flags(candidate_ap) == NM_802_11_AP_SEC_NONE &&
nm_access_point_get_rsn_flags(candidate_ap) == NM_802_11_AP_SEC_NONE) {
/* WEP */
nm_setting_wireless_security_set_wep_key(s_wsec, 0, psk.toRawUTF8());
if (isValidWEPKeyFormat(psk))
g_object_set(G_OBJECT(s_wsec), NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE,
NM_WEP_KEY_TYPE_KEY, NULL);
else if (isValidWEPPassphraseFormat(psk))
g_object_set(G_OBJECT(s_wsec), NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE,
NM_WEP_KEY_TYPE_PASSPHRASE, NULL);
else
DBG("User input invalid WEP Key type, psk.length() = " << psk.length()
<< ", not in [5,10,13,26]");
} else {
g_object_set(s_wsec, NM_SETTING_WIRELESS_SECURITY_PSK, psk.toRawUTF8(), NULL);
}
}
nm_client_add_and_activate_connection(nmclient,
connection,
nmdevice,
nm_ap_path,
handle_add_and_activate_finish,
this);
}
}
