mirror of
https://gitlab.freedesktop.org/NetworkManager/NetworkManager
synced 2024-07-05 17:19:00 +00:00
8bace23beb
- All internal source files (except "examples", which are not internal) should include "config.h" first. As also all internal source files should include "nm-default.h", let "config.h" be included by "nm-default.h" and include "nm-default.h" as first in every source file. We already wanted to include "nm-default.h" before other headers because it might contains some fixes (like "nm-glib.h" compatibility) that is required first. - After including "nm-default.h", we optinally allow for including the corresponding header file for the source file at hand. The idea is to ensure that each header file is self contained. - Don't include "config.h" or "nm-default.h" in any header file (except "nm-sd-adapt.h"). Public headers anyway must not include these headers, and internal headers are never included after "nm-default.h", as of the first previous point. - Include all internal headers with quotes instead of angle brackets. In practice it doesn't matter, because in our public headers we must include other headers with angle brackets. As we use our public headers also to compile our interal source files, effectively the result must be the same. Still do it for consistency. - Except for <config.h> itself. Include it with angle brackets as suggested by https://www.gnu.org/software/autoconf/manual/autoconf.html#Configuration-Headers
1554 lines
52 KiB
C
1554 lines
52 KiB
C
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
|
|
|
|
/*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301 USA.
|
|
*
|
|
* Copyright 2007 - 2014 Red Hat, Inc.
|
|
* Copyright 2007 - 2008 Novell, Inc.
|
|
*/
|
|
|
|
#include "nm-default.h"
|
|
|
|
#include <string.h>
|
|
#include <dbus/dbus-glib.h>
|
|
|
|
#include "nm-setting-wireless-security.h"
|
|
#include "nm-setting-8021x.h"
|
|
#include "nm-param-spec-specialized.h"
|
|
#include "nm-utils.h"
|
|
#include "nm-dbus-glib-types.h"
|
|
#include "nm-utils-private.h"
|
|
#include "nm-setting-private.h"
|
|
|
|
/**
|
|
* SECTION:nm-setting-wireless-security
|
|
* @short_description: Describes connection properties for Wi-Fi networks that
|
|
* use WEP, LEAP, WPA or WPA2/RSN security
|
|
* @include: nm-setting-wireless-security.h
|
|
*
|
|
* The #NMSettingWirelessSecurity object is a #NMSetting subclass that describes
|
|
* properties necessary for connection to encrypted Wi-Fi networks.
|
|
*
|
|
* It's a good idea to read up on wpa_supplicant configuration before using this
|
|
* setting extensively, since most of the options here correspond closely with
|
|
* the relevant wpa_supplicant configuration options. To get a better overview
|
|
* of how Wi-Fi security works, you may want to get copies of the following books.
|
|
*
|
|
* 802.11 Wireless Networks: The Definitive Guide, Second Edition
|
|
* Author: Matthew Gast
|
|
* ISBN: 978-0596100520
|
|
*
|
|
* Cisco Wireless LAN Security
|
|
* Authors: Krishna Sankar, Sri Sundaralingam, Darrin Miller, and Andrew Balinsky
|
|
* ISBN: 978-1587051548
|
|
**/
|
|
|
|
/**
|
|
* nm_setting_wireless_security_error_quark:
|
|
*
|
|
* Registers an error quark for #NMSettingWired if necessary.
|
|
*
|
|
* Returns: the error quark used for #NMSettingWired errors.
|
|
**/
|
|
GQuark
|
|
nm_setting_wireless_security_error_quark (void)
|
|
{
|
|
static GQuark quark;
|
|
|
|
if (G_UNLIKELY (!quark))
|
|
quark = g_quark_from_static_string ("nm-setting-wireless-security-error-quark");
|
|
return quark;
|
|
}
|
|
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (NMSettingWirelessSecurity, nm_setting_wireless_security, NM_TYPE_SETTING,
|
|
_nm_register_setting (NM_SETTING_WIRELESS_SECURITY_SETTING_NAME,
|
|
g_define_type_id,
|
|
2,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR))
|
|
NM_SETTING_REGISTER_TYPE (NM_TYPE_SETTING_WIRELESS_SECURITY)
|
|
|
|
#define NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_SETTING_WIRELESS_SECURITY, NMSettingWirelessSecurityPrivate))
|
|
|
|
typedef struct {
|
|
char *key_mgmt;
|
|
char *auth_alg;
|
|
GSList *proto; /* GSList of strings */
|
|
GSList *pairwise; /* GSList of strings */
|
|
GSList *group; /* GSList of strings */
|
|
|
|
/* LEAP */
|
|
char *leap_username;
|
|
char *leap_password;
|
|
NMSettingSecretFlags leap_password_flags;
|
|
|
|
/* WEP */
|
|
char *wep_key0;
|
|
char *wep_key1;
|
|
char *wep_key2;
|
|
char *wep_key3;
|
|
NMSettingSecretFlags wep_key_flags;
|
|
NMWepKeyType wep_key_type;
|
|
guint32 wep_tx_keyidx;
|
|
|
|
/* WPA-PSK */
|
|
char *psk;
|
|
NMSettingSecretFlags psk_flags;
|
|
} NMSettingWirelessSecurityPrivate;
|
|
|
|
enum {
|
|
PROP_0,
|
|
PROP_KEY_MGMT,
|
|
PROP_WEP_TX_KEYIDX,
|
|
PROP_AUTH_ALG,
|
|
PROP_PROTO,
|
|
PROP_PAIRWISE,
|
|
PROP_GROUP,
|
|
PROP_LEAP_USERNAME,
|
|
PROP_WEP_KEY0,
|
|
PROP_WEP_KEY1,
|
|
PROP_WEP_KEY2,
|
|
PROP_WEP_KEY3,
|
|
PROP_WEP_KEY_FLAGS,
|
|
PROP_WEP_KEY_TYPE,
|
|
PROP_PSK,
|
|
PROP_PSK_FLAGS,
|
|
PROP_LEAP_PASSWORD,
|
|
PROP_LEAP_PASSWORD_FLAGS,
|
|
|
|
LAST_PROP
|
|
};
|
|
|
|
/**
|
|
* nm_setting_wireless_security_new:
|
|
*
|
|
* Creates a new #NMSettingWirelessSecurity object with default values.
|
|
*
|
|
* Returns: (transfer full): the new empty #NMSettingWirelessSecurity object
|
|
**/
|
|
NMSetting *
|
|
nm_setting_wireless_security_new (void)
|
|
{
|
|
return (NMSetting *) g_object_new (NM_TYPE_SETTING_WIRELESS_SECURITY, NULL);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_key_mgmt:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Returns: the #NMSettingWirelessSecurity:key-mgmt property of the setting
|
|
**/
|
|
const char *
|
|
nm_setting_wireless_security_get_key_mgmt (NMSettingWirelessSecurity *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), NULL);
|
|
|
|
return NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting)->key_mgmt;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_num_protos:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Returns: the number of security protocols this connection allows when
|
|
* connecting to secure Wi-Fi networks
|
|
**/
|
|
guint32
|
|
nm_setting_wireless_security_get_num_protos (NMSettingWirelessSecurity *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), 0);
|
|
|
|
return g_slist_length (NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting)->proto);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_proto:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
* @i: an index into the protocol list
|
|
*
|
|
* Returns: the protocol at index @i
|
|
**/
|
|
const char *
|
|
nm_setting_wireless_security_get_proto (NMSettingWirelessSecurity *setting, guint32 i)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), NULL);
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
g_return_val_if_fail (i <= g_slist_length (priv->proto), NULL);
|
|
|
|
return (const char *) g_slist_nth_data (priv->proto, i);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_add_proto:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
* @proto: the protocol to add, one of "wpa" or "rsn"
|
|
*
|
|
* Adds a Wi-Fi security protocol (one of "wpa" or "rsn") to the allowed list;
|
|
* only protocols in this list will be used when finding and connecting to
|
|
* the Wi-Fi network specified by this connection. For example, if the
|
|
* protocol list contains only "wpa" but the access point for the SSID specified
|
|
* by this connection only supports WPA2/RSN, the connection cannot be used
|
|
* with the access point.
|
|
*
|
|
* Returns: %TRUE if the protocol was new and and was added to the allowed
|
|
* protocol list, or %FALSE if it was already in the list
|
|
**/
|
|
gboolean
|
|
nm_setting_wireless_security_add_proto (NMSettingWirelessSecurity *setting, const char *proto)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
GSList *iter;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), FALSE);
|
|
g_return_val_if_fail (proto != NULL, FALSE);
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
for (iter = priv->proto; iter; iter = g_slist_next (iter)) {
|
|
if (strcasecmp (proto, (char *) iter->data) == 0)
|
|
return FALSE;
|
|
}
|
|
|
|
priv->proto = g_slist_append (priv->proto, g_ascii_strdown (proto, -1));
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_PROTO);
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_remove_proto:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
* @i: index of the protocol to remove
|
|
*
|
|
* Removes a protocol from the allowed protocol list.
|
|
**/
|
|
void
|
|
nm_setting_wireless_security_remove_proto (NMSettingWirelessSecurity *setting, guint32 i)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
GSList *elt;
|
|
|
|
g_return_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting));
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
elt = g_slist_nth (priv->proto, i);
|
|
g_return_if_fail (elt != NULL);
|
|
|
|
g_free (elt->data);
|
|
priv->proto = g_slist_delete_link (priv->proto, elt);
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_PROTO);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_remove_proto_by_value:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
* @proto: the protocol to remove, one of "wpa" or "rsn"
|
|
*
|
|
* Removes a protocol from the allowed protocol list.
|
|
*
|
|
* Returns: %TRUE if the protocol was found and removed; %FALSE it it was not.
|
|
*
|
|
* Since: 0.9.10
|
|
**/
|
|
gboolean
|
|
nm_setting_wireless_security_remove_proto_by_value (NMSettingWirelessSecurity *setting,
|
|
const char *proto)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
GSList *iter;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), FALSE);
|
|
g_return_val_if_fail (proto != NULL, FALSE);
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
for (iter = priv->proto; iter; iter = g_slist_next (iter)) {
|
|
if (strcasecmp (proto, (char *) iter->data) == 0) {
|
|
priv->proto = g_slist_delete_link (priv->proto, iter);
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_PROTO);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_clear_protos:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Removes all protocols from the allowed list. If there are no protocols
|
|
* specified then all protocols are allowed.
|
|
**/
|
|
void
|
|
nm_setting_wireless_security_clear_protos (NMSettingWirelessSecurity *setting)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
|
|
g_return_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting));
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
g_slist_free_full (priv->proto, g_free);
|
|
priv->proto = NULL;
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_PROTO);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_num_pairwise:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Returns: the number of pairwise encryption algorithms in the allowed list
|
|
**/
|
|
guint32
|
|
nm_setting_wireless_security_get_num_pairwise (NMSettingWirelessSecurity *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), 0);
|
|
|
|
return g_slist_length (NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting)->pairwise);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_pairwise:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
* @i: index of an item in the allowed pairwise encryption algorithm list
|
|
*
|
|
* Returns the allowed pairwise encryption algorithm from allowed algorithm
|
|
* list.
|
|
*
|
|
* Returns: the pairwise encryption algorithm at index @i
|
|
**/
|
|
const char *
|
|
nm_setting_wireless_security_get_pairwise (NMSettingWirelessSecurity *setting, guint32 i)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), NULL);
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
g_return_val_if_fail (i <= g_slist_length (priv->pairwise), NULL);
|
|
|
|
return (const char *) g_slist_nth_data (priv->pairwise, i);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_add_pairwise:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
* @pairwise: the encryption algorithm to add, one of "tkip" or "ccmp"
|
|
*
|
|
* Adds an encryption algorithm to the list of allowed pairwise encryption
|
|
* algorithms. If the list is not empty, then only access points that support
|
|
* one or more of the encryption algorithms in the list will be considered
|
|
* compatible with this connection.
|
|
*
|
|
* Returns: %TRUE if the algorithm was added to the list, %FALSE if it was
|
|
* already in the list
|
|
**/
|
|
gboolean
|
|
nm_setting_wireless_security_add_pairwise (NMSettingWirelessSecurity *setting, const char *pairwise)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
GSList *iter;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), FALSE);
|
|
g_return_val_if_fail (pairwise != NULL, FALSE);
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
for (iter = priv->pairwise; iter; iter = g_slist_next (iter)) {
|
|
if (strcasecmp (pairwise, (char *) iter->data) == 0)
|
|
return FALSE;
|
|
}
|
|
|
|
priv->pairwise = g_slist_append (priv->pairwise, g_ascii_strdown (pairwise, -1));
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_PAIRWISE);
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_remove_pairwise:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
* @i: the index of an item in the allowed pairwise encryption algorithm list
|
|
*
|
|
* Removes an encryption algorithm from the allowed pairwise encryption
|
|
* algorithm list.
|
|
**/
|
|
void
|
|
nm_setting_wireless_security_remove_pairwise (NMSettingWirelessSecurity *setting, guint32 i)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
GSList *elt;
|
|
|
|
g_return_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting));
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
elt = g_slist_nth (priv->pairwise, i);
|
|
g_return_if_fail (elt != NULL);
|
|
|
|
g_free (elt->data);
|
|
priv->pairwise = g_slist_delete_link (priv->pairwise, elt);
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_PAIRWISE);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_remove_pairwise_by_value:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
* @pairwise: the encryption algorithm to remove, one of "tkip" or "ccmp"
|
|
*
|
|
* Removes an encryption algorithm from the allowed pairwise encryption
|
|
* algorithm list.
|
|
*
|
|
* Returns: %TRUE if the encryption algorith was found and removed; %FALSE it it was not.
|
|
*
|
|
* Since: 0.9.10
|
|
**/
|
|
gboolean
|
|
nm_setting_wireless_security_remove_pairwise_by_value (NMSettingWirelessSecurity *setting,
|
|
const char *pairwise)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
GSList *iter;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), FALSE);
|
|
g_return_val_if_fail (pairwise != NULL, FALSE);
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
for (iter = priv->pairwise; iter; iter = g_slist_next (iter)) {
|
|
if (strcasecmp (pairwise, (char *) iter->data) == 0) {
|
|
priv->pairwise = g_slist_delete_link (priv->pairwise, iter);
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_PAIRWISE);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_clear_pairwise:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Removes all algorithms from the allowed list. If there are no algorithms
|
|
* specified then all pairwise encryption algorithms are allowed.
|
|
**/
|
|
void
|
|
nm_setting_wireless_security_clear_pairwise (NMSettingWirelessSecurity *setting)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
|
|
g_return_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting));
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
g_slist_free_full (priv->pairwise, g_free);
|
|
priv->pairwise = NULL;
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_PAIRWISE);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_num_groups:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Returns: the number of groupwise encryption algorithms in the allowed list
|
|
**/
|
|
guint32
|
|
nm_setting_wireless_security_get_num_groups (NMSettingWirelessSecurity *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), 0);
|
|
|
|
return g_slist_length (NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting)->group);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_group:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
* @i: index of an item in the allowed groupwise encryption algorithm list
|
|
*
|
|
* Returns the allowed groupwise encryption algorithm from allowed algorithm
|
|
* list.
|
|
*
|
|
* Returns: the groupwise encryption algorithm at index @i
|
|
**/
|
|
const char *
|
|
nm_setting_wireless_security_get_group (NMSettingWirelessSecurity *setting, guint32 i)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), NULL);
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
g_return_val_if_fail (i <= g_slist_length (priv->group), NULL);
|
|
|
|
return (const char *) g_slist_nth_data (priv->group, i);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_add_group:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
* @group: the encryption algorithm to add, one of "wep40", "wep104",
|
|
* "tkip", or "ccmp"
|
|
*
|
|
* Adds an encryption algorithm to the list of allowed groupwise encryption
|
|
* algorithms. If the list is not empty, then only access points that support
|
|
* one or more of the encryption algorithms in the list will be considered
|
|
* compatible with this connection.
|
|
*
|
|
* Returns: %TRUE if the algorithm was added to the list, %FALSE if it was
|
|
* already in the list
|
|
**/
|
|
gboolean
|
|
nm_setting_wireless_security_add_group (NMSettingWirelessSecurity *setting, const char *group)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
GSList *iter;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), FALSE);
|
|
g_return_val_if_fail (group != NULL, FALSE);
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
for (iter = priv->group; iter; iter = g_slist_next (iter)) {
|
|
if (strcasecmp (group, (char *) iter->data) == 0)
|
|
return FALSE;
|
|
}
|
|
|
|
priv->group = g_slist_append (priv->group, g_ascii_strdown (group, -1));
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_GROUP);
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_remove_group:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
* @i: the index of an item in the allowed groupwise encryption algorithm list
|
|
*
|
|
* Removes an encryption algorithm from the allowed groupwise encryption
|
|
* algorithm list.
|
|
**/
|
|
void
|
|
nm_setting_wireless_security_remove_group (NMSettingWirelessSecurity *setting, guint32 i)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
GSList *elt;
|
|
|
|
g_return_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting));
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
elt = g_slist_nth (priv->group, i);
|
|
g_return_if_fail (elt != NULL);
|
|
|
|
g_free (elt->data);
|
|
priv->group = g_slist_delete_link (priv->group, elt);
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_GROUP);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_remove_group_by_value:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
* @group: the encryption algorithm to remove, one of "wep40", "wep104",
|
|
* "tkip", or "ccmp"
|
|
*
|
|
* Removes an encryption algorithm from the allowed groupwise encryption
|
|
* algorithm list.
|
|
*
|
|
* Returns: %TRUE if the algorithm was found and removed; %FALSE it it was not.
|
|
*
|
|
* Since: 0.9.10
|
|
**/
|
|
gboolean
|
|
nm_setting_wireless_security_remove_group_by_value (NMSettingWirelessSecurity *setting,
|
|
const char *group)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
GSList *iter;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), FALSE);
|
|
g_return_val_if_fail (group != NULL, FALSE);
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
for (iter = priv->group; iter; iter = g_slist_next (iter)) {
|
|
if (strcasecmp (group, (char *) iter->data) == 0) {
|
|
priv->group = g_slist_delete_link (priv->group, iter);
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_GROUP);
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_clear_groups:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Removes all algorithms from the allowed list. If there are no algorithms
|
|
* specified then all groupwise encryption algorithms are allowed.
|
|
**/
|
|
void
|
|
nm_setting_wireless_security_clear_groups (NMSettingWirelessSecurity *setting)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
|
|
g_return_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting));
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
g_slist_free_full (priv->group, g_free);
|
|
priv->group = NULL;
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_GROUP);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_psk:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Returns: the #NMSettingWirelessSecurity:psk property of the setting
|
|
**/
|
|
const char *
|
|
nm_setting_wireless_security_get_psk (NMSettingWirelessSecurity *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), NULL);
|
|
|
|
return NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting)->psk;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_psk_flags:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Returns: the #NMSettingSecretFlags pertaining to the
|
|
* #NMSettingWirelessSecurity:psk
|
|
**/
|
|
NMSettingSecretFlags
|
|
nm_setting_wireless_security_get_psk_flags (NMSettingWirelessSecurity *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), NM_SETTING_SECRET_FLAG_NONE);
|
|
|
|
return NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting)->psk_flags;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_leap_username:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Returns: the #NMSettingWirelessSecurity:leap-username property of the setting
|
|
**/
|
|
const char *
|
|
nm_setting_wireless_security_get_leap_username (NMSettingWirelessSecurity *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), NULL);
|
|
|
|
return NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting)->leap_username;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_leap_password:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Returns: the #NMSettingWirelessSecurity:leap-password property of the setting
|
|
**/
|
|
const char *
|
|
nm_setting_wireless_security_get_leap_password (NMSettingWirelessSecurity *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), NULL);
|
|
|
|
return NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting)->leap_password;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_leap_password_flags:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Returns: the #NMSettingSecretFlags pertaining to the
|
|
* #NMSettingWirelessSecurity:leap-password
|
|
**/
|
|
NMSettingSecretFlags
|
|
nm_setting_wireless_security_get_leap_password_flags (NMSettingWirelessSecurity *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), NM_SETTING_SECRET_FLAG_NONE);
|
|
|
|
return NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting)->leap_password_flags;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_wep_key:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
* @idx: the WEP key index (0..3 inclusive)
|
|
*
|
|
* Returns: the WEP key at the given index
|
|
**/
|
|
const char *
|
|
nm_setting_wireless_security_get_wep_key (NMSettingWirelessSecurity *setting, guint32 idx)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), NULL);
|
|
g_return_val_if_fail (idx < 4, NULL);
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
if (idx == 0)
|
|
return priv->wep_key0;
|
|
else if (idx == 1)
|
|
return priv->wep_key1;
|
|
else if (idx == 2)
|
|
return priv->wep_key2;
|
|
else if (idx == 3)
|
|
return priv->wep_key3;
|
|
|
|
g_assert_not_reached ();
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_set_wep_key:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
* @idx: the index of the key (0..3 inclusive)
|
|
* @key: the WEP key as a string, in either hexadecimal, ASCII, or passphrase
|
|
* form as determiend by the value of the #NMSettingWirelessSecurity:wep-key-type
|
|
* property.
|
|
*
|
|
* Sets a WEP key in the given index.
|
|
**/
|
|
void
|
|
nm_setting_wireless_security_set_wep_key (NMSettingWirelessSecurity *setting, guint32 idx, const char *key)
|
|
{
|
|
NMSettingWirelessSecurityPrivate *priv;
|
|
|
|
g_return_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting));
|
|
g_return_if_fail (idx < 4);
|
|
|
|
priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
switch (idx) {
|
|
case 0:
|
|
g_free (priv->wep_key0);
|
|
priv->wep_key0 = g_strdup (key);
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_WEP_KEY0);
|
|
break;
|
|
case 1:
|
|
g_free (priv->wep_key1);
|
|
priv->wep_key1 = g_strdup (key);
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_WEP_KEY1);
|
|
break;
|
|
case 2:
|
|
g_free (priv->wep_key2);
|
|
priv->wep_key2 = g_strdup (key);
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_WEP_KEY2);
|
|
break;
|
|
case 3:
|
|
g_free (priv->wep_key3);
|
|
priv->wep_key3 = g_strdup (key);
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_WIRELESS_SECURITY_WEP_KEY3);
|
|
break;
|
|
default:
|
|
g_assert_not_reached ();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_wep_tx_keyidx:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Returns: the #NMSettingWirelessSecurity:wep-tx-keyidx property of the setting
|
|
**/
|
|
guint32
|
|
nm_setting_wireless_security_get_wep_tx_keyidx (NMSettingWirelessSecurity *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), 0);
|
|
|
|
return NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting)->wep_tx_keyidx;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_auth_alg:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Returns: the #NMSettingWirelessSecurity:auth-alg property of the setting
|
|
**/
|
|
const char *
|
|
nm_setting_wireless_security_get_auth_alg (NMSettingWirelessSecurity *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), NULL);
|
|
|
|
return NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting)->auth_alg;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_wep_key_flags:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Returns: the #NMSettingSecretFlags pertaining to the all WEP keys
|
|
**/
|
|
NMSettingSecretFlags
|
|
nm_setting_wireless_security_get_wep_key_flags (NMSettingWirelessSecurity *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), NM_SETTING_SECRET_FLAG_NONE);
|
|
|
|
return NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting)->wep_key_flags;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_wireless_security_get_wep_key_type:
|
|
* @setting: the #NMSettingWirelessSecurity
|
|
*
|
|
* Returns: the #NMSettingWirelessSecurity:wep-key-type property of the setting
|
|
**/
|
|
NMWepKeyType
|
|
nm_setting_wireless_security_get_wep_key_type (NMSettingWirelessSecurity *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_WIRELESS_SECURITY (setting), 0);
|
|
|
|
return NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting)->wep_key_type;
|
|
}
|
|
|
|
static GPtrArray *
|
|
need_secrets (NMSetting *setting)
|
|
{
|
|
NMSettingWirelessSecurity *self = NM_SETTING_WIRELESS_SECURITY (setting);
|
|
NMSettingWirelessSecurityPrivate *priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (self);
|
|
GPtrArray *secrets;
|
|
|
|
secrets = g_ptr_array_sized_new (4);
|
|
|
|
g_assert (priv->key_mgmt);
|
|
|
|
/* Static WEP */
|
|
if (strcmp (priv->key_mgmt, "none") == 0) {
|
|
if ((priv->wep_tx_keyidx == 0) && !nm_utils_wep_key_valid (priv->wep_key0, priv->wep_key_type)) {
|
|
g_ptr_array_add (secrets, NM_SETTING_WIRELESS_SECURITY_WEP_KEY0);
|
|
return secrets;
|
|
}
|
|
if ((priv->wep_tx_keyidx == 1) && !nm_utils_wep_key_valid (priv->wep_key1, priv->wep_key_type)) {
|
|
g_ptr_array_add (secrets, NM_SETTING_WIRELESS_SECURITY_WEP_KEY1);
|
|
return secrets;
|
|
}
|
|
if ((priv->wep_tx_keyidx == 2) && !nm_utils_wep_key_valid (priv->wep_key2, priv->wep_key_type)) {
|
|
g_ptr_array_add (secrets, NM_SETTING_WIRELESS_SECURITY_WEP_KEY2);
|
|
return secrets;
|
|
}
|
|
if ((priv->wep_tx_keyidx == 3) && !nm_utils_wep_key_valid (priv->wep_key3, priv->wep_key_type)) {
|
|
g_ptr_array_add (secrets, NM_SETTING_WIRELESS_SECURITY_WEP_KEY3);
|
|
return secrets;
|
|
}
|
|
goto no_secrets;
|
|
}
|
|
|
|
/* WPA-PSK infrastructure and adhoc */
|
|
if ( (strcmp (priv->key_mgmt, "wpa-none") == 0)
|
|
|| (strcmp (priv->key_mgmt, "wpa-psk") == 0)) {
|
|
if (!nm_utils_wpa_psk_valid (priv->psk)) {
|
|
g_ptr_array_add (secrets, NM_SETTING_WIRELESS_SECURITY_PSK);
|
|
return secrets;
|
|
}
|
|
goto no_secrets;
|
|
}
|
|
|
|
/* LEAP */
|
|
if ( priv->auth_alg
|
|
&& !strcmp (priv->auth_alg, "leap")
|
|
&& !strcmp (priv->key_mgmt, "ieee8021x")) {
|
|
if (!priv->leap_password || !*priv->leap_password) {
|
|
g_ptr_array_add (secrets, NM_SETTING_WIRELESS_SECURITY_LEAP_PASSWORD);
|
|
return secrets;
|
|
}
|
|
goto no_secrets;
|
|
}
|
|
|
|
if ( (strcmp (priv->key_mgmt, "ieee8021x") == 0)
|
|
|| (strcmp (priv->key_mgmt, "wpa-eap") == 0)) {
|
|
/* Let caller check the 802.1x setting for secrets */
|
|
goto no_secrets;
|
|
}
|
|
|
|
g_assert_not_reached ();
|
|
return secrets;
|
|
|
|
no_secrets:
|
|
if (secrets)
|
|
g_ptr_array_free (secrets, TRUE);
|
|
return NULL;
|
|
}
|
|
|
|
static gboolean
|
|
verify (NMSetting *setting, GSList *all_settings, GError **error)
|
|
{
|
|
NMSettingWirelessSecurity *self = NM_SETTING_WIRELESS_SECURITY (setting);
|
|
NMSettingWirelessSecurityPrivate *priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (self);
|
|
const char *valid_key_mgmt[] = { "none", "ieee8021x", "wpa-none", "wpa-psk", "wpa-eap", NULL };
|
|
const char *valid_auth_algs[] = { "open", "shared", "leap", NULL };
|
|
const char *valid_protos[] = { "wpa", "rsn", NULL };
|
|
const char *valid_pairwise[] = { "tkip", "ccmp", NULL };
|
|
const char *valid_groups[] = { "wep40", "wep104", "tkip", "ccmp", NULL };
|
|
|
|
if (!priv->key_mgmt) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR_MISSING_PROPERTY,
|
|
_("property is missing"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!_nm_utils_string_in_list (priv->key_mgmt, valid_key_mgmt)) {
|
|
g_set_error (error,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR_INVALID_PROPERTY,
|
|
_("'%s' is not a valid value for the property"),
|
|
priv->key_mgmt);
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT);
|
|
return FALSE;
|
|
}
|
|
|
|
if (priv->auth_alg && !strcmp (priv->auth_alg, "leap")) {
|
|
/* LEAP must use ieee8021x key management */
|
|
if (strcmp (priv->key_mgmt, "ieee8021x")) {
|
|
g_set_error (error,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR_LEAP_REQUIRES_802_1X,
|
|
_("'%s' security requires '%s=%s'"),
|
|
"leap", NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "ieee8021x");
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NM_SETTING_WIRELESS_SECURITY_AUTH_ALG);
|
|
return FALSE;
|
|
}
|
|
if (!priv->leap_username) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR_LEAP_REQUIRES_USERNAME,
|
|
_("property is empty"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME);
|
|
return FALSE;
|
|
}
|
|
} else {
|
|
if ( (strcmp (priv->key_mgmt, "ieee8021x") == 0)
|
|
|| (strcmp (priv->key_mgmt, "wpa-eap") == 0)) {
|
|
/* Need an 802.1x setting too */
|
|
if (!nm_setting_find_in_list (all_settings, NM_SETTING_802_1X_SETTING_NAME)) {
|
|
g_set_error (error,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR_MISSING_802_1X_SETTING,
|
|
_("'%s' security requires '%s' setting presence"),
|
|
priv->key_mgmt, NM_SETTING_802_1X_SETTING_NAME);
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NM_SETTING_WIRELESS_SECURITY_KEY_MGMT);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (priv->leap_username && !strlen (priv->leap_username)) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR_INVALID_PROPERTY,
|
|
_("property is empty"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME);
|
|
return FALSE;
|
|
}
|
|
|
|
if (priv->wep_tx_keyidx > 3) {
|
|
g_set_error (error,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR_INVALID_PROPERTY,
|
|
_("'%d' value is out of range <0-3>"),
|
|
priv->wep_tx_keyidx);
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NM_SETTING_WIRELESS_SECURITY_WEP_TX_KEYIDX);
|
|
return FALSE;
|
|
}
|
|
|
|
if (priv->wep_key_type > NM_WEP_KEY_TYPE_LAST) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR_INVALID_PROPERTY,
|
|
_("property is invalid"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE);
|
|
return FALSE;
|
|
}
|
|
|
|
if (priv->auth_alg && !_nm_utils_string_in_list (priv->auth_alg, valid_auth_algs)) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR_INVALID_PROPERTY,
|
|
_("property is invalid"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NM_SETTING_WIRELESS_SECURITY_AUTH_ALG);
|
|
return FALSE;
|
|
}
|
|
|
|
if (priv->proto && !_nm_utils_string_slist_validate (priv->proto, valid_protos)) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR_INVALID_PROPERTY,
|
|
_("property is invalid"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NM_SETTING_WIRELESS_SECURITY_PROTO);
|
|
return FALSE;
|
|
}
|
|
|
|
if (priv->pairwise) {
|
|
const char *wpa_none[] = { "wpa-none", NULL };
|
|
|
|
/* For ad-hoc connections, pairwise must be "none" */
|
|
if (_nm_utils_string_in_list (priv->key_mgmt, wpa_none)) {
|
|
GSList *iter;
|
|
gboolean found = FALSE;
|
|
|
|
for (iter = priv->pairwise; iter; iter = g_slist_next (iter)) {
|
|
if (!strcmp ((char *) iter->data, "none")) {
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* pairwise cipher list didn't contain "none", which is invalid
|
|
* for WPA adhoc connections.
|
|
*/
|
|
if (!found) {
|
|
g_set_error (error,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR_INVALID_PROPERTY,
|
|
_("'%s' connections require '%s' in this property"),
|
|
NM_SETTING_WIRELESS_MODE_ADHOC, "none");
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NM_SETTING_WIRELESS_SECURITY_PAIRWISE);
|
|
return FALSE;
|
|
}
|
|
} else if (!_nm_utils_string_slist_validate (priv->pairwise, valid_pairwise)) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR_INVALID_PROPERTY,
|
|
_("property is invalid"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NM_SETTING_WIRELESS_SECURITY_PAIRWISE);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (priv->group && !_nm_utils_string_slist_validate (priv->group, valid_groups)) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR_INVALID_PROPERTY,
|
|
_("property is invalid"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NM_SETTING_WIRELESS_SECURITY_GROUP);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Shared Key auth can only be used with WEP */
|
|
if (priv->auth_alg && !strcmp (priv->auth_alg, "shared")) {
|
|
if (priv->key_mgmt && strcmp (priv->key_mgmt, "none")) {
|
|
g_set_error (error,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR,
|
|
NM_SETTING_WIRELESS_SECURITY_ERROR_SHARED_KEY_REQUIRES_WEP,
|
|
_("'%s' can only be used with '%s=%s' (WEP)"),
|
|
"shared", NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "none");
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRELESS_SECURITY_SETTING_NAME, NM_SETTING_WIRELESS_SECURITY_AUTH_ALG);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
get_secret_flags (NMSetting *setting,
|
|
const char *secret_name,
|
|
gboolean verify_secret,
|
|
NMSettingSecretFlags *out_flags,
|
|
GError **error)
|
|
{
|
|
NMSettingClass *setting_class;
|
|
gboolean verify_override = verify_secret;
|
|
|
|
/* There's only one 'flags' property for WEP keys, so alias all the WEP key
|
|
* property names to that flags property.
|
|
*/
|
|
if ( !g_strcmp0 (secret_name, NM_SETTING_WIRELESS_SECURITY_WEP_KEY0)
|
|
|| !g_strcmp0 (secret_name, NM_SETTING_WIRELESS_SECURITY_WEP_KEY1)
|
|
|| !g_strcmp0 (secret_name, NM_SETTING_WIRELESS_SECURITY_WEP_KEY2)
|
|
|| !g_strcmp0 (secret_name, NM_SETTING_WIRELESS_SECURITY_WEP_KEY3)) {
|
|
secret_name = "wep-key";
|
|
verify_override = FALSE; /* Already know it's a secret */
|
|
}
|
|
|
|
/* Chain up to superclass with modified key name */
|
|
setting_class = NM_SETTING_CLASS (nm_setting_wireless_security_parent_class);
|
|
return setting_class->get_secret_flags (setting, secret_name, verify_override, out_flags, error);
|
|
}
|
|
|
|
static gboolean
|
|
set_secret_flags (NMSetting *setting,
|
|
const char *secret_name,
|
|
gboolean verify_secret,
|
|
NMSettingSecretFlags flags,
|
|
GError **error)
|
|
{
|
|
NMSettingClass *setting_class;
|
|
gboolean verify_override = verify_secret;
|
|
|
|
/* There's only one 'flags' property for WEP keys, so alias all the WEP key
|
|
* property names to that flags property.
|
|
*/
|
|
if ( !g_strcmp0 (secret_name, NM_SETTING_WIRELESS_SECURITY_WEP_KEY0)
|
|
|| !g_strcmp0 (secret_name, NM_SETTING_WIRELESS_SECURITY_WEP_KEY1)
|
|
|| !g_strcmp0 (secret_name, NM_SETTING_WIRELESS_SECURITY_WEP_KEY2)
|
|
|| !g_strcmp0 (secret_name, NM_SETTING_WIRELESS_SECURITY_WEP_KEY3)) {
|
|
secret_name = "wep-key";
|
|
verify_override = FALSE; /* Already know it's a secret */
|
|
}
|
|
|
|
/* Chain up to superclass with modified key name */
|
|
setting_class = NM_SETTING_CLASS (nm_setting_wireless_security_parent_class);
|
|
return setting_class->set_secret_flags (setting, secret_name, verify_override, flags, error);
|
|
}
|
|
|
|
static void
|
|
nm_setting_wireless_security_init (NMSettingWirelessSecurity *setting)
|
|
{
|
|
}
|
|
|
|
static void
|
|
finalize (GObject *object)
|
|
{
|
|
NMSettingWirelessSecurity *self = NM_SETTING_WIRELESS_SECURITY (object);
|
|
NMSettingWirelessSecurityPrivate *priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (self);
|
|
|
|
/* Strings first. g_free() already checks for NULLs so we don't have to */
|
|
|
|
g_free (priv->key_mgmt);
|
|
g_free (priv->auth_alg);
|
|
g_free (priv->leap_username);
|
|
g_free (priv->wep_key0);
|
|
g_free (priv->wep_key1);
|
|
g_free (priv->wep_key2);
|
|
g_free (priv->wep_key3);
|
|
g_free (priv->psk);
|
|
g_free (priv->leap_password);
|
|
|
|
g_slist_free_full (priv->proto, g_free);
|
|
g_slist_free_full (priv->pairwise, g_free);
|
|
g_slist_free_full (priv->group, g_free);
|
|
|
|
G_OBJECT_CLASS (nm_setting_wireless_security_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
set_property (GObject *object, guint prop_id,
|
|
const GValue *value, GParamSpec *pspec)
|
|
{
|
|
NMSettingWirelessSecurity *setting = NM_SETTING_WIRELESS_SECURITY (object);
|
|
NMSettingWirelessSecurityPrivate *priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
const char *str;
|
|
|
|
switch (prop_id) {
|
|
case PROP_KEY_MGMT:
|
|
g_free (priv->key_mgmt);
|
|
str = g_value_get_string (value);
|
|
priv->key_mgmt = str ? g_ascii_strdown (str, -1) : NULL;
|
|
break;
|
|
case PROP_WEP_TX_KEYIDX:
|
|
priv->wep_tx_keyidx = g_value_get_uint (value);
|
|
break;
|
|
case PROP_AUTH_ALG:
|
|
g_free (priv->auth_alg);
|
|
str = g_value_get_string (value);
|
|
priv->auth_alg = str ? g_ascii_strdown (str, -1) : NULL;
|
|
break;
|
|
case PROP_PROTO:
|
|
g_slist_free_full (priv->proto, g_free);
|
|
priv->proto = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_PAIRWISE:
|
|
g_slist_free_full (priv->pairwise, g_free);
|
|
priv->pairwise = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_GROUP:
|
|
g_slist_free_full (priv->group, g_free);
|
|
priv->group = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_LEAP_USERNAME:
|
|
g_free (priv->leap_username);
|
|
priv->leap_username = g_value_dup_string (value);
|
|
break;
|
|
case PROP_WEP_KEY0:
|
|
g_free (priv->wep_key0);
|
|
priv->wep_key0 = g_value_dup_string (value);
|
|
break;
|
|
case PROP_WEP_KEY1:
|
|
g_free (priv->wep_key1);
|
|
priv->wep_key1 = g_value_dup_string (value);
|
|
break;
|
|
case PROP_WEP_KEY2:
|
|
g_free (priv->wep_key2);
|
|
priv->wep_key2 = g_value_dup_string (value);
|
|
break;
|
|
case PROP_WEP_KEY3:
|
|
g_free (priv->wep_key3);
|
|
priv->wep_key3 = g_value_dup_string (value);
|
|
break;
|
|
case PROP_WEP_KEY_FLAGS:
|
|
priv->wep_key_flags = g_value_get_uint (value);
|
|
break;
|
|
case PROP_PSK:
|
|
g_free (priv->psk);
|
|
priv->psk = g_value_dup_string (value);
|
|
break;
|
|
case PROP_PSK_FLAGS:
|
|
priv->psk_flags = g_value_get_uint (value);
|
|
break;
|
|
case PROP_LEAP_PASSWORD:
|
|
g_free (priv->leap_password);
|
|
priv->leap_password = g_value_dup_string (value);
|
|
break;
|
|
case PROP_LEAP_PASSWORD_FLAGS:
|
|
priv->leap_password_flags = g_value_get_uint (value);
|
|
break;
|
|
case PROP_WEP_KEY_TYPE:
|
|
priv->wep_key_type = g_value_get_uint (value);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
get_property (GObject *object, guint prop_id,
|
|
GValue *value, GParamSpec *pspec)
|
|
{
|
|
NMSettingWirelessSecurity *setting = NM_SETTING_WIRELESS_SECURITY (object);
|
|
NMSettingWirelessSecurityPrivate *priv = NM_SETTING_WIRELESS_SECURITY_GET_PRIVATE (setting);
|
|
|
|
switch (prop_id) {
|
|
case PROP_KEY_MGMT:
|
|
g_value_set_string (value, priv->key_mgmt);
|
|
break;
|
|
case PROP_WEP_TX_KEYIDX:
|
|
g_value_set_uint (value, priv->wep_tx_keyidx);
|
|
break;
|
|
case PROP_AUTH_ALG:
|
|
g_value_set_string (value, priv->auth_alg);
|
|
break;
|
|
case PROP_PROTO:
|
|
g_value_set_boxed (value, priv->proto);
|
|
break;
|
|
case PROP_PAIRWISE:
|
|
g_value_set_boxed (value, priv->pairwise);
|
|
break;
|
|
case PROP_GROUP:
|
|
g_value_set_boxed (value, priv->group);
|
|
break;
|
|
case PROP_LEAP_USERNAME:
|
|
g_value_set_string (value, priv->leap_username);
|
|
break;
|
|
case PROP_WEP_KEY0:
|
|
g_value_set_string (value, priv->wep_key0);
|
|
break;
|
|
case PROP_WEP_KEY1:
|
|
g_value_set_string (value, priv->wep_key1);
|
|
break;
|
|
case PROP_WEP_KEY2:
|
|
g_value_set_string (value, priv->wep_key2);
|
|
break;
|
|
case PROP_WEP_KEY3:
|
|
g_value_set_string (value, priv->wep_key3);
|
|
break;
|
|
case PROP_WEP_KEY_FLAGS:
|
|
g_value_set_uint (value, priv->wep_key_flags);
|
|
break;
|
|
case PROP_PSK:
|
|
g_value_set_string (value, priv->psk);
|
|
break;
|
|
case PROP_PSK_FLAGS:
|
|
g_value_set_uint (value, priv->psk_flags);
|
|
break;
|
|
case PROP_LEAP_PASSWORD:
|
|
g_value_set_string (value, priv->leap_password);
|
|
break;
|
|
case PROP_LEAP_PASSWORD_FLAGS:
|
|
g_value_set_uint (value, priv->leap_password_flags);
|
|
break;
|
|
case PROP_WEP_KEY_TYPE:
|
|
g_value_set_uint (value, priv->wep_key_type);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
nm_setting_wireless_security_class_init (NMSettingWirelessSecurityClass *setting_class)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (setting_class);
|
|
NMSettingClass *parent_class = NM_SETTING_CLASS (setting_class);
|
|
|
|
g_type_class_add_private (setting_class, sizeof (NMSettingWirelessSecurityPrivate));
|
|
|
|
/* virtual methods */
|
|
object_class->set_property = set_property;
|
|
object_class->get_property = get_property;
|
|
object_class->finalize = finalize;
|
|
|
|
parent_class->verify = verify;
|
|
parent_class->need_secrets = need_secrets;
|
|
parent_class->get_secret_flags = get_secret_flags;
|
|
parent_class->set_secret_flags = set_secret_flags;
|
|
|
|
/* Properties */
|
|
/**
|
|
* NMSettingWirelessSecurity:key-mgmt:
|
|
*
|
|
* Key management used for the connection. One of "none" (WEP), "ieee8021x"
|
|
* (Dynamic WEP), "wpa-none" (Ad-Hoc WPA-PSK), "wpa-psk" (infrastructure
|
|
* WPA-PSK), or "wpa-eap" (WPA-Enterprise). This property must be set for
|
|
* any Wi-Fi connection that uses security.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_KEY_MGMT,
|
|
g_param_spec_string (NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "", "",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
NM_SETTING_PARAM_REQUIRED |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:wep-tx-keyidx:
|
|
*
|
|
* When static WEP is used (ie, key-mgmt = "none") and a non-default WEP key
|
|
* index is used by the AP, put that WEP key index here. Valid values are 0
|
|
* (default key) through 3. Note that some consumer access points (like the
|
|
* Linksys WRT54G) number the keys 1 - 4.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_WEP_TX_KEYIDX,
|
|
g_param_spec_uint (NM_SETTING_WIRELESS_SECURITY_WEP_TX_KEYIDX, "", "",
|
|
0, 3, 0,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:auth-alg:
|
|
*
|
|
* When WEP is used (ie, key-mgmt = "none" or "ieee8021x") indicate the
|
|
* 802.11 authentication algorithm required by the AP here. One of "open"
|
|
* for Open System, "shared" for Shared Key, or "leap" for Cisco LEAP. When
|
|
* using Cisco LEAP (ie, key-mgmt = "ieee8021x" and auth-alg = "leap") the
|
|
* "leap-username" and "leap-password" properties must be specified.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_AUTH_ALG,
|
|
g_param_spec_string (NM_SETTING_WIRELESS_SECURITY_AUTH_ALG, "", "",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:proto:
|
|
*
|
|
* List of strings specifying the allowed WPA protocol versions to use.
|
|
* Each element may be one "wpa" (allow WPA) or "rsn" (allow WPA2/RSN). If
|
|
* not specified, both WPA and RSN connections are allowed.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_PROTO,
|
|
_nm_param_spec_specialized (NM_SETTING_WIRELESS_SECURITY_PROTO, "", "",
|
|
DBUS_TYPE_G_LIST_OF_STRING,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:pairwise:
|
|
*
|
|
* A list of pairwise encryption algorithms which prevents connections to
|
|
* Wi-Fi networks that do not utilize one of the algorithms in the list.
|
|
* For maximum compatibility leave this property empty. Each list element
|
|
* may be one of "tkip" or "ccmp".
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_PAIRWISE,
|
|
_nm_param_spec_specialized (NM_SETTING_WIRELESS_SECURITY_PAIRWISE, "", "",
|
|
DBUS_TYPE_G_LIST_OF_STRING,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:group:
|
|
*
|
|
* A list of group/broadcast encryption algorithms which prevents
|
|
* connections to Wi-Fi networks that do not utilize one of the algorithms
|
|
* in the list. For maximum compatibility leave this property empty. Each
|
|
* list element may be one of "wep40", "wep104", "tkip", or "ccmp".
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_GROUP,
|
|
_nm_param_spec_specialized (NM_SETTING_WIRELESS_SECURITY_GROUP, "", "",
|
|
DBUS_TYPE_G_LIST_OF_STRING,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:leap-username:
|
|
*
|
|
* The login username for legacy LEAP connections (ie, key-mgmt =
|
|
* "ieee8021x" and auth-alg = "leap").
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_LEAP_USERNAME,
|
|
g_param_spec_string (NM_SETTING_WIRELESS_SECURITY_LEAP_USERNAME, "", "",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:wep-key0:
|
|
*
|
|
* Index 0 WEP key. This is the WEP key used in most networks. See the
|
|
* "wep-key-type" property for a description of how this key is interpreted.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_WEP_KEY0,
|
|
g_param_spec_string (NM_SETTING_WIRELESS_SECURITY_WEP_KEY0, "", "",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
NM_SETTING_PARAM_SECRET |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:wep-key1:
|
|
*
|
|
* Index 1 WEP key. This WEP index is not used by most networks. See the
|
|
* "wep-key-type" property for a description of how this key is interpreted.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_WEP_KEY1,
|
|
g_param_spec_string (NM_SETTING_WIRELESS_SECURITY_WEP_KEY1, "", "",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
NM_SETTING_PARAM_SECRET |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:wep-key2:
|
|
*
|
|
* Index 2 WEP key. This WEP index is not used by most networks. See the
|
|
* "wep-key-type" property for a description of how this key is interpreted.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_WEP_KEY2,
|
|
g_param_spec_string (NM_SETTING_WIRELESS_SECURITY_WEP_KEY2, "", "",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
NM_SETTING_PARAM_SECRET |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:wep-key3:
|
|
*
|
|
* Index 3 WEP key. This WEP index is not used by most networks. See the
|
|
* "wep-key-type" property for a description of how this key is interpreted.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_WEP_KEY3,
|
|
g_param_spec_string (NM_SETTING_WIRELESS_SECURITY_WEP_KEY3, "", "",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
NM_SETTING_PARAM_SECRET |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:wep-key-flags:
|
|
*
|
|
* Flags indicating how to handle the #NMSettingWirelessSecurity:wep-key0,
|
|
* #NMSettingWirelessSecurity:wep-key1, #NMSettingWirelessSecurity:wep-key2,
|
|
* and #NMSettingWirelessSecurity:wep-key3 properties.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_WEP_KEY_FLAGS,
|
|
g_param_spec_uint (NM_SETTING_WIRELESS_SECURITY_WEP_KEY_FLAGS, "", "",
|
|
NM_SETTING_SECRET_FLAG_NONE,
|
|
NM_SETTING_SECRET_FLAGS_ALL,
|
|
NM_SETTING_SECRET_FLAG_NONE,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:psk:
|
|
*
|
|
* Pre-Shared-Key for WPA networks. If the key is 64-characters long, it
|
|
* must contain only hexadecimal characters and is interpreted as a
|
|
* hexadecimal WPA key. Otherwise, the key must be between 8 and 63 ASCII
|
|
* characters (as specified in the 802.11i standard) and is interpreted as a
|
|
* WPA passphrase, and is hashed to derive the actual WPA-PSK used when
|
|
* connecting to the Wi-Fi network.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_PSK,
|
|
g_param_spec_string (NM_SETTING_WIRELESS_SECURITY_PSK, "", "",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
NM_SETTING_PARAM_SECRET |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:psk-flags:
|
|
*
|
|
* Flags indicating how to handle the #NMSettingWirelessSecurity:psk
|
|
* property.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_PSK_FLAGS,
|
|
g_param_spec_uint (NM_SETTING_WIRELESS_SECURITY_PSK_FLAGS, "", "",
|
|
NM_SETTING_SECRET_FLAG_NONE,
|
|
NM_SETTING_SECRET_FLAGS_ALL,
|
|
NM_SETTING_SECRET_FLAG_NONE,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:leap-password:
|
|
*
|
|
* The login password for legacy LEAP connections (ie, key-mgmt =
|
|
* "ieee8021x" and auth-alg = "leap").
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_LEAP_PASSWORD,
|
|
g_param_spec_string (NM_SETTING_WIRELESS_SECURITY_LEAP_PASSWORD, "", "",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
NM_SETTING_PARAM_SECRET |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:leap-password-flags:
|
|
*
|
|
* Flags indicating how to handle the
|
|
* #NMSettingWirelessSecurity:leap-password property.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_LEAP_PASSWORD_FLAGS,
|
|
g_param_spec_uint (NM_SETTING_WIRELESS_SECURITY_LEAP_PASSWORD_FLAGS, "", "",
|
|
NM_SETTING_SECRET_FLAG_NONE,
|
|
NM_SETTING_SECRET_FLAGS_ALL,
|
|
NM_SETTING_SECRET_FLAG_NONE,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingWirelessSecurity:wep-key-type:
|
|
*
|
|
* Controls the interpretation of WEP keys. Allowed values are
|
|
* %NM_WEP_KEY_TYPE_KEY, in which case the key is either a 10- or
|
|
* 26-character hexadecimal string, or a 5- or 13-character ASCII password;
|
|
* or %NM_WEP_KEY_TYPE_PASSPHRASE, in which case the passphrase is provided
|
|
* as a string and will be hashed using the de-facto MD5 method to derive
|
|
* the actual WEP key.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_WEP_KEY_TYPE,
|
|
g_param_spec_uint (NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE, "", "",
|
|
NM_WEP_KEY_TYPE_UNKNOWN,
|
|
NM_WEP_KEY_TYPE_LAST,
|
|
NM_WEP_KEY_TYPE_UNKNOWN,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT |
|
|
G_PARAM_STATIC_STRINGS));
|
|
}
|