mirror of
https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git
synced 2025-12-24 14:50:07 +01:00
aedced3964
* libnm-util/nm-setting.c libnm-util/nm-setting.c - (nm_setting_compare): implement - (default_setting_compare_fn, do_one_compare, compare_gvalue_hash, compare_one_hash_gvalue): compare the contents of a setting * libnm-util/nm-connection.c - (nm_connection_compare): implement git-svn-id: http://svn-archive.gnome.org/svn/NetworkManager/trunk@3013 4912f4e0-d625-0410-9fb7-b9a5a253dbdc
1826 lines
51 KiB
C
1826 lines
51 KiB
C
/* -*- Mode: C; tab-width: 5; indent-tabs-mode: t; c-basic-offset: 5 -*- */
|
|
|
|
#include <glib-object.h>
|
|
#include <dbus/dbus-glib.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <netinet/ether.h>
|
|
|
|
#include "nm-setting.h"
|
|
#include "nm-utils.h"
|
|
|
|
static GHashTable * nm_setting_hash (NMSetting *setting);
|
|
static gboolean nm_setting_populate_from_hash_default (NMSetting *setting, GHashTable *table);
|
|
static void default_setting_clear_secrets (NMSetting *setting);
|
|
static gboolean default_setting_compare_fn (NMSetting *setting, NMSetting *other, gboolean two_way);
|
|
|
|
gboolean
|
|
nm_setting_populate_from_hash (NMSetting *setting, GHashTable *hash)
|
|
{
|
|
g_return_val_if_fail (setting != NULL, FALSE);
|
|
|
|
if (setting->populate_fn)
|
|
return setting->populate_fn (setting, hash);
|
|
else
|
|
return nm_setting_populate_from_hash_default (setting, hash);
|
|
}
|
|
|
|
gboolean
|
|
nm_setting_verify (NMSetting *setting)
|
|
{
|
|
g_return_val_if_fail (setting != NULL, FALSE);
|
|
|
|
if (setting->verify_fn)
|
|
return setting->verify_fn (setting, NULL);
|
|
}
|
|
|
|
typedef struct {
|
|
gboolean success;
|
|
GHashTable *all_settings;
|
|
} VerifySettingsInfo;
|
|
|
|
static void
|
|
verify_one_setting (gpointer key, gpointer value, gpointer user_data)
|
|
{
|
|
NMSetting *setting = (NMSetting *) value;
|
|
VerifySettingsInfo *info = (VerifySettingsInfo *) user_data;
|
|
|
|
if (info->success && setting->verify_fn) {
|
|
info->success = setting->verify_fn (setting, info->all_settings);
|
|
}
|
|
}
|
|
|
|
gboolean
|
|
nm_settings_verify_all (GHashTable *all_settings)
|
|
{
|
|
gpointer p;
|
|
VerifySettingsInfo info;
|
|
|
|
g_return_val_if_fail (all_settings != NULL, FALSE);
|
|
|
|
/* First, make sure there's at least 'connection' setting */
|
|
p = g_hash_table_lookup (all_settings, NM_SETTING_CONNECTION);
|
|
if (!p) {
|
|
g_warning ("'connection' setting not present.");
|
|
return FALSE;
|
|
}
|
|
|
|
/* Now, run the verify function of each setting */
|
|
info.success = TRUE;
|
|
info.all_settings = all_settings;
|
|
g_hash_table_foreach (all_settings, verify_one_setting, &info);
|
|
|
|
return info.success;
|
|
}
|
|
|
|
static GHashTable *
|
|
default_setting_hash (NMSetting *setting)
|
|
{
|
|
return nm_setting_hash (setting);
|
|
}
|
|
|
|
GHashTable *
|
|
nm_setting_to_hash (NMSetting *setting)
|
|
{
|
|
g_return_val_if_fail (setting != NULL, NULL);
|
|
|
|
if (setting->hash_fn)
|
|
return setting->hash_fn (setting);
|
|
else
|
|
return default_setting_hash (setting);
|
|
}
|
|
|
|
gboolean
|
|
nm_setting_update_secrets (NMSetting *setting,
|
|
GHashTable *secrets)
|
|
{
|
|
g_return_val_if_fail (setting != NULL, FALSE);
|
|
g_return_val_if_fail (secrets != NULL, FALSE);
|
|
|
|
if (setting->update_secrets_fn)
|
|
return setting->update_secrets_fn (setting, secrets);
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
nm_setting_clear_secrets (NMSetting *setting)
|
|
{
|
|
g_return_if_fail (setting != NULL);
|
|
|
|
if (setting->clear_secrets_fn)
|
|
setting->clear_secrets_fn (setting);
|
|
else
|
|
default_setting_clear_secrets (setting);
|
|
}
|
|
|
|
GPtrArray *
|
|
nm_setting_need_secrets (NMSetting *setting)
|
|
{
|
|
g_return_val_if_fail (setting != NULL, NULL);
|
|
|
|
if (setting->need_secrets_fn)
|
|
return setting->need_secrets_fn (setting);
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
nm_setting_destroy (NMSetting *setting)
|
|
{
|
|
char *name;
|
|
|
|
g_return_if_fail (setting != NULL);
|
|
|
|
name = setting->name;
|
|
|
|
if (setting->destroy_fn)
|
|
setting->destroy_fn (setting);
|
|
|
|
g_free (name);
|
|
}
|
|
|
|
void
|
|
nm_setting_enumerate_values (NMSetting *setting,
|
|
NMSettingValueIterFn func,
|
|
gpointer user_data)
|
|
{
|
|
SettingMember *m;
|
|
|
|
g_return_if_fail (setting != NULL);
|
|
g_return_if_fail (func != NULL);
|
|
|
|
m = setting->_members;
|
|
while (m->key) {
|
|
void *val = G_STRUCT_MEMBER_P (setting, m->offset);
|
|
(*func) (setting, m->key, m->type, val, m->secret, user_data);
|
|
m++;
|
|
};
|
|
}
|
|
|
|
gboolean
|
|
nm_setting_compare (NMSetting *setting, NMSetting *other, gboolean two_way)
|
|
{
|
|
g_return_val_if_fail (setting != NULL, FALSE);
|
|
g_return_val_if_fail (other != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (setting->name != NULL, FALSE);
|
|
g_return_val_if_fail (other->name != NULL, FALSE);
|
|
|
|
g_return_val_if_fail (strcmp (setting->name, other->name) == 0, FALSE);
|
|
|
|
if (!setting->compare_fn)
|
|
return default_setting_compare_fn (setting, other, two_way);
|
|
return setting->compare_fn (setting, other, two_way);
|
|
}
|
|
|
|
/***********************************************************************/
|
|
|
|
/* Helper functions for converting NMSetting to hash table. */
|
|
|
|
static void
|
|
destroy_gvalue (gpointer data)
|
|
{
|
|
GValue *value = (GValue *) data;
|
|
|
|
g_value_unset (value);
|
|
g_slice_free (GValue, value);
|
|
}
|
|
|
|
static GHashTable *
|
|
setting_hash_new (void)
|
|
{
|
|
return g_hash_table_new_full (g_str_hash, g_str_equal, NULL,
|
|
destroy_gvalue);
|
|
}
|
|
|
|
static GValue *
|
|
string_to_gvalue (const char *str)
|
|
{
|
|
GValue *val;
|
|
|
|
val = g_slice_new0 (GValue);
|
|
g_value_init (val, G_TYPE_STRING);
|
|
g_value_set_string (val, str);
|
|
|
|
return val;
|
|
}
|
|
|
|
static GValue *
|
|
boolean_to_gvalue (gboolean b)
|
|
{
|
|
GValue *val;
|
|
|
|
val = g_slice_new0 (GValue);
|
|
g_value_init (val, G_TYPE_BOOLEAN);
|
|
g_value_set_boolean (val, b);
|
|
|
|
return val;
|
|
}
|
|
|
|
#if 0
|
|
static GValue *
|
|
int_to_gvalue (int i)
|
|
{
|
|
GValue *val;
|
|
|
|
val = g_slice_new0 (GValue);
|
|
g_value_init (val, G_TYPE_INT);
|
|
g_value_set_int (val, i);
|
|
|
|
return val;
|
|
}
|
|
#endif
|
|
|
|
static GValue *
|
|
uint_to_gvalue (guint32 i)
|
|
{
|
|
GValue *val;
|
|
|
|
val = g_slice_new0 (GValue);
|
|
g_value_init (val, G_TYPE_UINT);
|
|
g_value_set_uint (val, i);
|
|
|
|
return val;
|
|
}
|
|
|
|
static GValue *
|
|
uint64_to_gvalue (guint64 i)
|
|
{
|
|
GValue *val;
|
|
|
|
val = g_slice_new0 (GValue);
|
|
g_value_init (val, G_TYPE_UINT64);
|
|
g_value_set_uint64 (val, i);
|
|
|
|
return val;
|
|
}
|
|
|
|
#if 0
|
|
static GValue *
|
|
byte_to_gvalue (guchar c)
|
|
{
|
|
GValue *val;
|
|
|
|
val = g_slice_new0 (GValue);
|
|
g_value_init (val, G_TYPE_UCHAR);
|
|
g_value_set_uchar (val, c);
|
|
|
|
return val;
|
|
}
|
|
#endif
|
|
|
|
static GValue *
|
|
byte_array_to_gvalue (GByteArray *array)
|
|
{
|
|
GValue *val;
|
|
|
|
val = g_slice_new0 (GValue);
|
|
g_value_init (val, DBUS_TYPE_G_UCHAR_ARRAY);
|
|
g_value_set_boxed (val, array);
|
|
|
|
return val;
|
|
}
|
|
|
|
static GValue *
|
|
uint_array_to_gvalue (GArray *array)
|
|
{
|
|
GValue *val;
|
|
|
|
val = g_slice_new0 (GValue);
|
|
g_value_init (val, DBUS_TYPE_G_UINT_ARRAY);
|
|
g_value_set_boxed (val, array);
|
|
|
|
return val;
|
|
}
|
|
|
|
static GValue *
|
|
slist_to_gvalue (GSList *list, GType type)
|
|
{
|
|
GValue *val;
|
|
|
|
val = g_slice_new0 (GValue);
|
|
g_value_init (val, dbus_g_type_get_collection ("GSList", type));
|
|
g_value_set_boxed (val, list);
|
|
|
|
return val;
|
|
}
|
|
|
|
static GValue *
|
|
ip4_addresses_to_gvalue (GSList *list)
|
|
{
|
|
GPtrArray *ptr_array;
|
|
GSList *iter;
|
|
GValue *val;
|
|
|
|
ptr_array = g_ptr_array_new ();
|
|
|
|
for (iter = list; iter; iter = iter->next) {
|
|
NMSettingIP4Address *ip4_addr = (NMSettingIP4Address *) iter->data;
|
|
GArray *array;
|
|
|
|
array = g_array_sized_new (FALSE, FALSE, sizeof (guint32), 3);
|
|
g_array_append_val (array, ip4_addr->address);
|
|
g_array_append_val (array, ip4_addr->netmask);
|
|
|
|
if (ip4_addr->gateway)
|
|
g_array_append_val (array, ip4_addr->gateway);
|
|
|
|
g_ptr_array_add (ptr_array, array);
|
|
}
|
|
|
|
val = g_slice_new0 (GValue);
|
|
g_value_init (val, dbus_g_type_get_collection ("GPtrArray", G_TYPE_VALUE_ARRAY));
|
|
g_value_set_boxed (val, ptr_array);
|
|
|
|
return val;
|
|
}
|
|
|
|
static GByteArray *
|
|
convert_array_to_byte_array (GArray *array)
|
|
{
|
|
GByteArray *byte_array;
|
|
|
|
byte_array = g_byte_array_sized_new (array->len);
|
|
g_byte_array_append (byte_array, (const guint8 *) array->data, array->len);
|
|
|
|
return byte_array;
|
|
}
|
|
|
|
static GSList *
|
|
convert_strv_to_slist (char **str)
|
|
{
|
|
GSList *list = NULL;
|
|
guint i = 0;
|
|
|
|
while (str[i])
|
|
list = g_slist_prepend (list, g_strdup (str[i++]));
|
|
|
|
return g_slist_reverse (list);
|
|
}
|
|
|
|
static GSList *
|
|
convert_ip4_addresses_to_slist (GPtrArray *array)
|
|
{
|
|
int i;
|
|
GSList *list = NULL;
|
|
|
|
for (i = 0; i < array->len; i++) {
|
|
GValueArray *value_array = (GValueArray *) g_ptr_array_index (array, i);
|
|
|
|
if (value_array->n_values == 2 || value_array->n_values == 3) {
|
|
NMSettingIP4Address *ip4_addr;
|
|
|
|
ip4_addr = g_new0 (NMSettingIP4Address, 1);
|
|
ip4_addr->address = g_value_get_uint (g_value_array_get_nth (value_array, 0));
|
|
ip4_addr->netmask = g_value_get_uint (g_value_array_get_nth (value_array, 1));
|
|
|
|
if (value_array->n_values == 3)
|
|
ip4_addr->gateway = g_value_get_uint (g_value_array_get_nth (value_array, 2));
|
|
|
|
list = g_slist_prepend (list, ip4_addr);
|
|
} else
|
|
nm_warning ("Ignoring invalid IP4 address");
|
|
}
|
|
|
|
return g_slist_reverse (list);
|
|
}
|
|
|
|
static gboolean
|
|
string_in_list (const char *str, const char **valid_strings)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; valid_strings[i]; i++)
|
|
if (strcmp (str, valid_strings[i]) == 0)
|
|
break;
|
|
|
|
return valid_strings[i] != NULL;
|
|
}
|
|
|
|
static gboolean
|
|
string_slist_validate (GSList *list, const char **valid_values)
|
|
{
|
|
GSList *iter;
|
|
|
|
for (iter = list; iter; iter = iter->next) {
|
|
if (!string_in_list ((char *) iter->data, valid_values))
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************/
|
|
|
|
static gboolean
|
|
nm_setting_populate_from_hash_default (NMSetting *setting, GHashTable *table)
|
|
{
|
|
SettingMember *m;
|
|
|
|
g_return_val_if_fail (setting != NULL, FALSE);
|
|
g_return_val_if_fail (table != NULL, FALSE);
|
|
|
|
m = setting->_members;
|
|
while (m->key) {
|
|
GValue *value;
|
|
|
|
if (m->type == NM_S_TYPE_GVALUE_HASH) {
|
|
GHashTable **val = (GHashTable **) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
*val = nm_utils_gvalue_hash_dup (table);
|
|
break;
|
|
}
|
|
|
|
value = (GValue *) g_hash_table_lookup (table, m->key);
|
|
if (!value && m->required) {
|
|
g_warning ("Missing required value '%s'.", m->key);
|
|
return FALSE;
|
|
} else if (!value) {
|
|
goto next;
|
|
}
|
|
|
|
if ((m->type == NM_S_TYPE_STRING) && G_VALUE_HOLDS_STRING (value)) {
|
|
char **val = (char **) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
*val = g_strdup (g_value_get_string (value));
|
|
} else if ((m->type == NM_S_TYPE_BOOL) && G_VALUE_HOLDS_BOOLEAN (value)) {
|
|
gboolean *val = (gboolean *) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
*val = g_value_get_boolean (value);
|
|
} else if ((m->type == NM_S_TYPE_UINT32) && G_VALUE_HOLDS_UINT (value)) {
|
|
guint32 *val = (guint32 *) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
*val = g_value_get_uint (value);
|
|
} else if ((m->type == NM_S_TYPE_UINT64) && G_VALUE_HOLDS_UINT64 (value)) {
|
|
guint64 *val = (guint64 *) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
*val = g_value_get_uint64 (value);
|
|
} else if ((m->type == NM_S_TYPE_BYTE_ARRAY) && G_VALUE_HOLDS_BOXED (value)) {
|
|
GByteArray **val = (GByteArray **) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
*val = convert_array_to_byte_array ((GArray *) g_value_get_boxed (value));
|
|
} else if ((m->type == NM_S_TYPE_STRING_ARRAY) && G_VALUE_HOLDS_BOXED (value)) {
|
|
GSList **val = (GSList **) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
*val = convert_strv_to_slist ((char **) g_value_get_boxed (value));
|
|
} else if ((m->type == NM_S_TYPE_UINT_ARRAY) && G_VALUE_HOLDS_BOXED (value)) {
|
|
GArray **val = (GArray **) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
GArray *tmp = (GArray *) g_value_get_boxed (value);
|
|
|
|
*val = g_array_sized_new (FALSE, FALSE, sizeof (guint32), tmp->len);
|
|
g_array_append_vals (*val, tmp->data, tmp->len);
|
|
} else if ((m->type == NM_S_TYPE_IP4_ADDRESSES) && G_VALUE_HOLDS_BOXED (value)) {
|
|
GSList **val = (GSList **) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
*val = convert_ip4_addresses_to_slist ((GPtrArray *) g_value_get_boxed (value));
|
|
}
|
|
next:
|
|
m++;
|
|
};
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#define ADD_MEMBER(nmtype, ctype, key, func) \
|
|
case nmtype: { \
|
|
ctype* val = (ctype*) G_STRUCT_MEMBER_P (setting, m->offset); \
|
|
if (*val || (nmtype == NM_S_TYPE_BOOL) || m->required) { \
|
|
g_hash_table_insert (hash, (char *) key, func (*val)); \
|
|
} \
|
|
break; \
|
|
}
|
|
|
|
#define ADD_MEMBER_EXTRA(nmtype, ctype, key, func, extra) \
|
|
case nmtype: { \
|
|
ctype* val = (ctype*) G_STRUCT_MEMBER_P (setting, m->offset); \
|
|
if (*val || (nmtype == NM_S_TYPE_BOOL) || m->required) { \
|
|
g_hash_table_insert (hash, (char *) key, func (*val, extra)); \
|
|
} \
|
|
break; \
|
|
}
|
|
|
|
static GHashTable *
|
|
nm_setting_hash (NMSetting *setting)
|
|
{
|
|
GHashTable *hash;
|
|
SettingMember *m;
|
|
|
|
g_return_val_if_fail (setting != NULL, NULL);
|
|
|
|
hash = setting_hash_new ();
|
|
|
|
m = setting->_members;
|
|
while (m->key) {
|
|
switch (m->type) {
|
|
ADD_MEMBER(NM_S_TYPE_STRING, char *, m->key, string_to_gvalue)
|
|
ADD_MEMBER(NM_S_TYPE_BOOL, gboolean, m->key, boolean_to_gvalue)
|
|
ADD_MEMBER(NM_S_TYPE_UINT32, guint32, m->key, uint_to_gvalue)
|
|
ADD_MEMBER(NM_S_TYPE_UINT64, guint64, m->key, uint64_to_gvalue)
|
|
ADD_MEMBER(NM_S_TYPE_BYTE_ARRAY, GByteArray *, m->key, byte_array_to_gvalue)
|
|
ADD_MEMBER(NM_S_TYPE_UINT_ARRAY, GArray *, m->key, uint_array_to_gvalue)
|
|
ADD_MEMBER_EXTRA(NM_S_TYPE_STRING_ARRAY, GSList *, m->key, slist_to_gvalue, G_TYPE_STRING)
|
|
ADD_MEMBER(NM_S_TYPE_IP4_ADDRESSES, GSList *, m->key, ip4_addresses_to_gvalue)
|
|
default:
|
|
break;
|
|
}
|
|
m++;
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
static void
|
|
default_setting_clear_secrets (NMSetting *setting)
|
|
{
|
|
SettingMember *m;
|
|
|
|
g_return_if_fail (setting != NULL);
|
|
|
|
m = setting->_members;
|
|
while (m->key) {
|
|
if (m->secret == FALSE)
|
|
goto next;
|
|
|
|
switch (m->type) {
|
|
case NM_S_TYPE_GVALUE_HASH: {
|
|
GHashTable **val = (GHashTable **) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
g_hash_table_remove_all (*val);
|
|
break;
|
|
}
|
|
case NM_S_TYPE_STRING: {
|
|
char **val = (char **) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
g_free (*val);
|
|
*val = NULL;
|
|
break;
|
|
}
|
|
case NM_S_TYPE_BOOL: {
|
|
gboolean *val = (gboolean *) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
*val = FALSE;
|
|
break;
|
|
}
|
|
case NM_S_TYPE_UINT32: {
|
|
guint32 *val = (guint32 *) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
*val = 0;
|
|
break;
|
|
}
|
|
case NM_S_TYPE_UINT64: {
|
|
guint64 *val = (guint64 *) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
*val = 0;
|
|
break;
|
|
}
|
|
case NM_S_TYPE_BYTE_ARRAY: {
|
|
GByteArray **val = (GByteArray **) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
g_byte_array_free (*val, TRUE);
|
|
*val = NULL;
|
|
break;
|
|
}
|
|
case NM_S_TYPE_UINT_ARRAY: {
|
|
GArray **val = (GArray **) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
g_array_free (*val, TRUE);
|
|
*val = NULL;
|
|
break;
|
|
}
|
|
case NM_S_TYPE_STRING_ARRAY: {
|
|
GSList **val = (GSList **) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
g_slist_foreach (*val, (GFunc) g_free, NULL);
|
|
g_slist_free (*val);
|
|
*val = NULL;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
next:
|
|
m++;
|
|
}
|
|
}
|
|
|
|
typedef struct {
|
|
GHashTable *other;
|
|
gboolean failed;
|
|
} GValueHashCompareInfo;
|
|
|
|
static void
|
|
compare_one_hash_gvalue (gpointer key, gpointer value, gpointer user_data)
|
|
{
|
|
GValueHashCompareInfo *info = (GValueHashCompareInfo *) user_data;
|
|
GValue *val = (GValue *) value;
|
|
GValue *other_val;
|
|
|
|
if (info->failed)
|
|
return;
|
|
|
|
other_val = g_hash_table_lookup (info->other, key);
|
|
if (!other_val)
|
|
goto failed;
|
|
|
|
if (G_VALUE_TYPE (val) != G_VALUE_TYPE (other_val))
|
|
goto failed;
|
|
|
|
switch (G_VALUE_TYPE (val)) {
|
|
case G_TYPE_STRING: {
|
|
const char *a_str = g_value_get_string (val);
|
|
const char *b_str = g_value_get_string (other_val);
|
|
if ((!a_str && b_str) || (a_str && !b_str))
|
|
goto failed;
|
|
if (!a_str && !b_str)
|
|
break;
|
|
if (strcmp (a_str, b_str) != 0)
|
|
goto failed;
|
|
break;
|
|
}
|
|
default:
|
|
g_warning ("%s: unhandled GValue type %s", __func__, G_VALUE_TYPE_NAME (val));
|
|
goto failed;
|
|
break;
|
|
}
|
|
return;
|
|
|
|
failed:
|
|
info->failed = TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
compare_gvalue_hash (GHashTable *a, GHashTable *b)
|
|
{
|
|
GValueHashCompareInfo info = { b, FALSE };
|
|
|
|
g_return_val_if_fail (a != NULL, FALSE);
|
|
g_return_val_if_fail (b != NULL, FALSE);
|
|
|
|
g_hash_table_foreach (a, compare_one_hash_gvalue, &info);
|
|
return info.failed ? FALSE : TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
do_one_compare (NMSetting *a, NMSetting *b)
|
|
{
|
|
SettingMember *m;
|
|
|
|
g_return_if_fail (a != NULL);
|
|
g_return_if_fail (b != NULL);
|
|
|
|
m = a->_members;
|
|
while (m->key) {
|
|
/* Ignore secrets since they aren't always supposed to be in the setting */
|
|
if (m->secret == FALSE)
|
|
goto next;
|
|
|
|
switch (m->type) {
|
|
case NM_S_TYPE_STRING: {
|
|
char **a_val = (char **) G_STRUCT_MEMBER_P (a, m->offset);
|
|
char **b_val = (char **) G_STRUCT_MEMBER_P (b, m->offset);
|
|
if ((*a_val && !*b_val) || (!*a_val && *b_val))
|
|
return FALSE;
|
|
if (*a_val && *b_val && strcmp (*a_val, *b_val))
|
|
return FALSE;
|
|
break;
|
|
}
|
|
case NM_S_TYPE_BOOL: {
|
|
gboolean *a_val = (gboolean *) G_STRUCT_MEMBER_P (a, m->offset);
|
|
gboolean *b_val = (gboolean *) G_STRUCT_MEMBER_P (b, m->offset);
|
|
if (*a_val != *b_val)
|
|
return FALSE;
|
|
break;
|
|
}
|
|
case NM_S_TYPE_UINT32: {
|
|
guint32 *a_val = (guint32 *) G_STRUCT_MEMBER_P (a, m->offset);
|
|
guint32 *b_val = (guint32 *) G_STRUCT_MEMBER_P (b, m->offset);
|
|
if (*a_val != *b_val)
|
|
return FALSE;
|
|
break;
|
|
}
|
|
case NM_S_TYPE_UINT64: {
|
|
guint64 *a_val = (guint64 *) G_STRUCT_MEMBER_P (a, m->offset);
|
|
guint64 *b_val = (guint64 *) G_STRUCT_MEMBER_P (b, m->offset);
|
|
if (*a_val != *b_val)
|
|
return FALSE;
|
|
break;
|
|
}
|
|
case NM_S_TYPE_BYTE_ARRAY: {
|
|
GByteArray **a_val = (GByteArray **) G_STRUCT_MEMBER_P (a, m->offset);
|
|
GByteArray **b_val = (GByteArray **) G_STRUCT_MEMBER_P (b, m->offset);
|
|
if ((*a_val && !*b_val) || (!*a_val && *b_val))
|
|
return FALSE;
|
|
if (*a_val && *b_val) {
|
|
if ((*a_val)->len != (*b_val)->len)
|
|
return FALSE;
|
|
if (memcmp ((*a_val)->data, (*b_val)->data, (*a_val)->len))
|
|
return FALSE;
|
|
}
|
|
break;
|
|
}
|
|
case NM_S_TYPE_UINT_ARRAY: {
|
|
GArray **a_val = (GArray **) G_STRUCT_MEMBER_P (a, m->offset);
|
|
GArray **b_val = (GArray **) G_STRUCT_MEMBER_P (b, m->offset);
|
|
if ((*a_val && !*b_val) || (!*a_val && *b_val))
|
|
return FALSE;
|
|
if (*a_val && *b_val) {
|
|
if ((*a_val)->len != (*b_val)->len)
|
|
return FALSE;
|
|
if (memcmp ((*a_val)->data, (*b_val)->data, (*a_val)->len))
|
|
return FALSE;
|
|
}
|
|
break;
|
|
}
|
|
case NM_S_TYPE_STRING_ARRAY: {
|
|
GSList **a_val = (GSList **) G_STRUCT_MEMBER_P (a, m->offset);
|
|
GSList **b_val = (GSList **) G_STRUCT_MEMBER_P (b, m->offset);
|
|
GSList *a_iter;
|
|
|
|
for (a_iter = *a_val; a_iter; a_iter = g_slist_next (a_iter)) {
|
|
const char *a_str = a_iter->data;
|
|
GSList *b_iter;
|
|
gboolean found = FALSE;
|
|
|
|
for (b_iter = *b_val; b_iter; b_iter = g_slist_next (b_iter)) {
|
|
const char *b_str = b_iter->data;
|
|
if (!a_str && !b_str) {
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
if (a_str && b_str && !strcmp (a_str, b_str)) {
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if (!found)
|
|
return FALSE;
|
|
}
|
|
break;
|
|
}
|
|
case NM_S_TYPE_IP4_ADDRESSES: {
|
|
GSList **a_val = (GSList **) G_STRUCT_MEMBER_P (a, m->offset);
|
|
GSList **b_val = (GSList **) G_STRUCT_MEMBER_P (b, m->offset);
|
|
GSList *a_iter;
|
|
|
|
for (a_iter = *a_val; a_iter; a_iter = g_slist_next (a_iter)) {
|
|
NMSettingIP4Address *a_addr = (NMSettingIP4Address *) a_iter->data;
|
|
GSList *b_iter;
|
|
gboolean found = FALSE;
|
|
|
|
g_assert (a_addr);
|
|
for (b_iter = *b_val; b_iter; b_iter = g_slist_next (b_iter)) {
|
|
NMSettingIP4Address *b_addr = (NMSettingIP4Address *) b_iter->data;
|
|
|
|
g_assert (b_addr);
|
|
if ( (a_addr->address == b_addr->address)
|
|
&& (a_addr->netmask == b_addr->netmask)
|
|
&& (a_addr->gateway == b_addr->gateway)) {
|
|
found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if (!found)
|
|
return FALSE;
|
|
}
|
|
break;
|
|
}
|
|
case NM_S_TYPE_GVALUE_HASH: {
|
|
GHashTable **a_val = (GHashTable **) G_STRUCT_MEMBER_P (a, m->offset);
|
|
GHashTable **b_val = (GHashTable **) G_STRUCT_MEMBER_P (b, m->offset);
|
|
if (!compare_gvalue_hash (*a_val, *b_val))
|
|
return FALSE;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
next:
|
|
m++;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
default_setting_compare_fn (NMSetting *setting, NMSetting *other, gboolean two_way)
|
|
{
|
|
gboolean same;
|
|
|
|
same = do_one_compare (setting, other);
|
|
|
|
/* compare A to B, then if that is the same compare B to A to ensure
|
|
* that keys that are in B but not A will make the comparison fail.
|
|
*/
|
|
if (two_way && (same == TRUE))
|
|
return do_one_compare (other, setting);
|
|
return same;
|
|
}
|
|
|
|
|
|
/* Connection */
|
|
|
|
static gboolean
|
|
setting_connection_verify (NMSetting *setting, GHashTable *all_settings)
|
|
{
|
|
NMSettingConnection *self = (NMSettingConnection *) setting;
|
|
|
|
if (!self->name || !strlen (self->name))
|
|
return FALSE;
|
|
|
|
if (!self->type || !strlen (self->type))
|
|
return FALSE;
|
|
|
|
/* Make sure the corresponding 'type' item is present */
|
|
if (all_settings && !g_hash_table_lookup (all_settings, self->type))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
setting_connection_destroy (NMSetting *setting)
|
|
{
|
|
NMSettingConnection *self = (NMSettingConnection *) setting;
|
|
|
|
g_free (self->name);
|
|
g_free (self->type);
|
|
|
|
g_slice_free (NMSettingConnection, self);
|
|
}
|
|
|
|
static SettingMember con_table[] = {
|
|
{ "name", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingConnection, name), TRUE, FALSE },
|
|
{ "type", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingConnection, type), TRUE, FALSE },
|
|
{ "autoconnect", NM_S_TYPE_BOOL, G_STRUCT_OFFSET (NMSettingConnection, autoconnect), FALSE, FALSE },
|
|
{ "timestamp", NM_S_TYPE_UINT64, G_STRUCT_OFFSET (NMSettingConnection, timestamp), FALSE, FALSE },
|
|
{ NULL, 0, 0 },
|
|
};
|
|
|
|
NMSetting *
|
|
nm_setting_connection_new (void)
|
|
{
|
|
NMSetting *setting;
|
|
|
|
setting = (NMSetting *) g_slice_new0 (NMSettingConnection);
|
|
|
|
setting->name = g_strdup (NM_SETTING_CONNECTION);
|
|
setting->_members = con_table;
|
|
setting->verify_fn = setting_connection_verify;
|
|
setting->destroy_fn = setting_connection_destroy;
|
|
|
|
return setting;
|
|
}
|
|
|
|
/* IP4 config */
|
|
|
|
static gboolean
|
|
setting_ip4_config_verify (NMSetting *setting, GHashTable *all_settings)
|
|
{
|
|
NMSettingIP4Config *self = (NMSettingIP4Config *) setting;
|
|
|
|
if (self->manual) {
|
|
if (!self->addresses) {
|
|
g_warning ("address is not provided");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
setting_ip4_config_destroy (NMSetting *setting)
|
|
{
|
|
NMSettingIP4Config *self = (NMSettingIP4Config *) setting;
|
|
|
|
if (self->dns)
|
|
g_array_free (self->dns, TRUE);
|
|
|
|
if (self->dns_search) {
|
|
g_slist_foreach (self->dns_search, (GFunc) g_free, NULL);
|
|
g_slist_free (self->dns_search);
|
|
}
|
|
|
|
if (self->addresses) {
|
|
g_slist_foreach (self->addresses, (GFunc) g_free, NULL);
|
|
g_slist_free (self->addresses);
|
|
}
|
|
|
|
g_slice_free (NMSettingIP4Config, self);
|
|
}
|
|
|
|
static SettingMember ip4_config_table[] = {
|
|
{ "manual", NM_S_TYPE_BOOL, G_STRUCT_OFFSET (NMSettingIP4Config, manual), FALSE, FALSE },
|
|
{ "dns", NM_S_TYPE_UINT_ARRAY, G_STRUCT_OFFSET (NMSettingIP4Config, dns), FALSE, FALSE },
|
|
{ "dns-search", NM_S_TYPE_STRING_ARRAY, G_STRUCT_OFFSET (NMSettingIP4Config, dns_search), FALSE, FALSE },
|
|
{ "addresses", NM_S_TYPE_IP4_ADDRESSES,G_STRUCT_OFFSET (NMSettingIP4Config, addresses), FALSE, FALSE },
|
|
{ NULL, 0, 0 },
|
|
};
|
|
|
|
NMSetting *
|
|
nm_setting_ip4_config_new (void)
|
|
{
|
|
NMSetting *setting;
|
|
|
|
setting = (NMSetting *) g_slice_new0 (NMSettingIP4Config);
|
|
|
|
setting->name = g_strdup (NM_SETTING_IP4_CONFIG);
|
|
setting->_members = ip4_config_table;
|
|
setting->verify_fn = setting_ip4_config_verify;
|
|
setting->destroy_fn = setting_ip4_config_destroy;
|
|
|
|
return setting;
|
|
}
|
|
|
|
/* Wired device */
|
|
|
|
static gboolean
|
|
setting_wired_verify (NMSetting *setting, GHashTable *all_settings)
|
|
{
|
|
NMSettingWired *self = (NMSettingWired *) setting;
|
|
const char *valid_ports[] = { "tp", "aui", "bnc", "mii", NULL };
|
|
const char *valid_duplex[] = { "half", "full", NULL };
|
|
|
|
if (self->port && !string_in_list (self->port, valid_ports)) {
|
|
g_warning ("Invalid port");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->duplex && !string_in_list (self->duplex, valid_duplex)) {
|
|
g_warning ("Invalid duplex");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->mac_address && self->mac_address->len != 6) {
|
|
g_warning ("Invalid mac address");
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
setting_wired_destroy (NMSetting *setting)
|
|
{
|
|
NMSettingWired *self = (NMSettingWired *) setting;
|
|
|
|
g_free (self->port);
|
|
g_free (self->duplex);
|
|
|
|
if (self->mac_address)
|
|
g_byte_array_free (self->mac_address, TRUE);
|
|
|
|
g_slice_free (NMSettingWired, self);
|
|
}
|
|
|
|
static SettingMember wired_table[] = {
|
|
{ "port", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWired, port), FALSE, FALSE },
|
|
{ "speed", NM_S_TYPE_UINT32, G_STRUCT_OFFSET (NMSettingWired, speed), FALSE, FALSE },
|
|
{ "duplex", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWired, duplex), FALSE, FALSE },
|
|
{ "auto-negotiate", NM_S_TYPE_BOOL, G_STRUCT_OFFSET (NMSettingWired, auto_negotiate), FALSE, FALSE },
|
|
{ "mac-address", NM_S_TYPE_BYTE_ARRAY, G_STRUCT_OFFSET (NMSettingWired, mac_address), FALSE, FALSE },
|
|
{ "mtu", NM_S_TYPE_UINT32, G_STRUCT_OFFSET (NMSettingWired, mtu), FALSE, FALSE },
|
|
{ NULL, 0, 0 },
|
|
};
|
|
|
|
NMSetting *
|
|
nm_setting_wired_new (void)
|
|
{
|
|
NMSetting *setting;
|
|
NMSettingWired *s_wired;
|
|
|
|
s_wired = g_slice_new0 (NMSettingWired);
|
|
setting = (NMSetting *) s_wired;
|
|
|
|
setting->name = g_strdup (NM_SETTING_WIRED);
|
|
setting->_members = wired_table;
|
|
setting->verify_fn = setting_wired_verify;
|
|
setting->destroy_fn = setting_wired_destroy;
|
|
|
|
s_wired->auto_negotiate = TRUE;
|
|
|
|
return setting;
|
|
}
|
|
|
|
/* Wireless device */
|
|
|
|
static gboolean
|
|
setting_wireless_verify (NMSetting *setting, GHashTable *all_settings)
|
|
{
|
|
NMSettingWireless *self = (NMSettingWireless *) setting;
|
|
const char *valid_modes[] = { "infrastructure", "adhoc", NULL };
|
|
const char *valid_bands[] = { "a", "bg", NULL };
|
|
GSList *iter;
|
|
|
|
if (!self->ssid || self->ssid->len < 1 || self->ssid->len > 32) {
|
|
g_warning ("Invalid or missing ssid");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->mode && !string_in_list (self->mode, valid_modes)) {
|
|
g_warning ("Invalid mode. Should be either 'infrastructure' or 'adhoc'");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->band && !string_in_list (self->band, valid_bands)) {
|
|
g_warning ("Invalid band. Should be either 'a' or 'bg'");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->channel && !self->band) {
|
|
g_warning ("Channel was provided without band");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->channel) {
|
|
if (!strcmp (self->band, "a")) {
|
|
int i;
|
|
int valid_channels[] = { 36, 40, 44, 48, 52, 56, 60, 64, 100, 104, 108, 112,
|
|
116, 120, 124, 128, 132, 136, 140, 149, 153, 157, 161, 0 };
|
|
|
|
for (i = 0; valid_channels[i]; i++) {
|
|
if (self->channel == valid_channels[i])
|
|
break;
|
|
}
|
|
|
|
if (valid_channels[i] == 0) {
|
|
g_warning ("Invalid channel");
|
|
return FALSE;
|
|
}
|
|
} else if (!strcmp (self->band, "bg") && self->channel > 14) {
|
|
g_warning ("Invalid channel");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (self->bssid && self->bssid->len != 6) {
|
|
g_warning ("Invalid bssid");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->mac_address && self->mac_address->len != 6) {
|
|
g_warning ("Invalid mac address");
|
|
return FALSE;
|
|
}
|
|
|
|
for (iter = self->seen_bssids; iter; iter = iter->next) {
|
|
struct ether_addr addr;
|
|
|
|
if (!ether_aton_r (iter->data, &addr)) {
|
|
g_warning ("Invalid bssid");
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if ( self->security
|
|
&& all_settings
|
|
&& !g_hash_table_lookup (all_settings, self->security)) {
|
|
g_warning ("Invalid or missing security");
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
setting_wireless_destroy (NMSetting *setting)
|
|
{
|
|
NMSettingWireless *self = (NMSettingWireless *) setting;
|
|
|
|
g_free (self->mode);
|
|
g_free (self->band);
|
|
g_free (self->security);
|
|
|
|
if (self->ssid)
|
|
g_byte_array_free (self->ssid, TRUE);
|
|
if (self->bssid)
|
|
g_byte_array_free (self->bssid, TRUE);
|
|
if (self->mac_address)
|
|
g_byte_array_free (self->mac_address, TRUE);
|
|
|
|
if (self->seen_bssids) {
|
|
g_slist_foreach (self->seen_bssids, (GFunc) g_free, NULL);
|
|
g_slist_free (self->seen_bssids);
|
|
}
|
|
|
|
|
|
g_slice_free (NMSettingWireless, self);
|
|
}
|
|
|
|
static SettingMember wireless_table[] = {
|
|
{ "ssid", NM_S_TYPE_BYTE_ARRAY, G_STRUCT_OFFSET (NMSettingWireless, ssid), TRUE, FALSE },
|
|
{ "mode", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWireless, mode), FALSE, FALSE },
|
|
{ "band", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWireless, band), FALSE, FALSE },
|
|
{ "channel", NM_S_TYPE_UINT32, G_STRUCT_OFFSET (NMSettingWireless, channel), FALSE, FALSE },
|
|
{ "bssid", NM_S_TYPE_BYTE_ARRAY, G_STRUCT_OFFSET (NMSettingWireless, bssid), FALSE, FALSE },
|
|
{ "rate", NM_S_TYPE_UINT32, G_STRUCT_OFFSET (NMSettingWireless, rate), FALSE, FALSE },
|
|
{ "tx-power", NM_S_TYPE_UINT32, G_STRUCT_OFFSET (NMSettingWireless, tx_power), FALSE, FALSE },
|
|
{ "mac-address", NM_S_TYPE_BYTE_ARRAY, G_STRUCT_OFFSET (NMSettingWireless, mac_address), FALSE, FALSE },
|
|
{ "mtu", NM_S_TYPE_UINT32, G_STRUCT_OFFSET (NMSettingWireless, mtu), FALSE, FALSE },
|
|
{ "seen-bssids", NM_S_TYPE_STRING_ARRAY, G_STRUCT_OFFSET (NMSettingWireless, seen_bssids), FALSE, FALSE },
|
|
{ "security", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWireless, security), FALSE, FALSE },
|
|
{ NULL, 0, 0 },
|
|
};
|
|
|
|
NMSetting *
|
|
nm_setting_wireless_new (void)
|
|
{
|
|
NMSetting *setting;
|
|
|
|
setting = (NMSetting *) g_slice_new0 (NMSettingWireless);
|
|
|
|
setting->name = g_strdup (NM_SETTING_WIRELESS);
|
|
setting->_members = wireless_table;
|
|
setting->verify_fn = setting_wireless_verify;
|
|
setting->destroy_fn = setting_wireless_destroy;
|
|
|
|
return setting;
|
|
}
|
|
|
|
/* Wireless security */
|
|
|
|
static gboolean
|
|
setting_wireless_security_verify (NMSetting *setting, GHashTable *all_settings)
|
|
{
|
|
NMSettingWirelessSecurity *self = (NMSettingWirelessSecurity *) setting;
|
|
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[] = { "wep40", "wep104", "tkip", "ccmp", NULL };
|
|
const char *valid_groups[] = { "wep40", "wep104", "tkip", "ccmp", NULL };
|
|
const char *valid_phase1_peapver[] = { "0", "1", NULL };
|
|
|
|
/* Every time a method gets added to the following, add one to EAPMethodNeedSecretsTable */
|
|
const char *valid_eap[] = { "leap", "md5", "tls", "peap", "ttls", "sim", "psk", "fast", NULL };
|
|
const char *valid_phase2_auth[] = { "pap", "chap", "mschap", "mschapv2", "gtc", "otp", "md5", "tls", NULL };
|
|
const char *valid_phase2_autheap[] = { "md5", "mschapv2", "otp", "gtc", "tls", NULL };
|
|
|
|
if (!self->key_mgmt || !string_in_list (self->key_mgmt, valid_key_mgmt)) {
|
|
g_warning ("Missing or invalid key management");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->wep_tx_keyidx > 3) {
|
|
g_warning ("Invalid WEP key index");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->auth_alg && !string_in_list (self->auth_alg, valid_auth_algs)) {
|
|
g_warning ("Invalid authentication algorithm");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->proto && !string_slist_validate (self->proto, valid_protos)) {
|
|
g_warning ("Invalid authentication protocol");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->pairwise && !string_slist_validate (self->pairwise, valid_pairwise)) {
|
|
g_warning ("Invalid pairwise");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->group && !string_slist_validate (self->group, valid_groups)) {
|
|
g_warning ("Invalid group");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->eap && !string_slist_validate (self->eap, valid_eap)) {
|
|
g_warning ("Invalid eap");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->phase1_peapver && !string_in_list (self->phase1_peapver, valid_phase1_peapver)) {
|
|
g_warning ("Invalid phase1 peapver");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->phase1_peaplabel && strcmp (self->phase1_peaplabel, "1")) {
|
|
g_warning ("Invalid phase1 peaplabel");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->phase1_fast_provisioning && strcmp (self->phase1_fast_provisioning, "1")) {
|
|
g_warning ("Invalid phase1 fast provisioning");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->phase2_auth && !string_in_list (self->phase2_auth, valid_phase2_auth)) {
|
|
g_warning ("Invalid phase2 authentication");
|
|
return FALSE;
|
|
}
|
|
|
|
if (self->phase2_autheap && !string_in_list (self->phase2_autheap, valid_phase2_autheap)) {
|
|
g_warning ("Invalid phase2 autheap");
|
|
return FALSE;
|
|
}
|
|
|
|
/* FIXME: finish */
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
setting_wireless_security_destroy (NMSetting *setting)
|
|
{
|
|
NMSettingWirelessSecurity *self = (NMSettingWirelessSecurity *) setting;
|
|
|
|
/* Strings first. g_free() already checks for NULLs so we don't have to */
|
|
|
|
g_free (self->key_mgmt);
|
|
g_free (self->auth_alg);
|
|
g_free (self->identity);
|
|
g_free (self->anonymous_identity);
|
|
g_free (self->ca_path);
|
|
g_free (self->phase1_peapver);
|
|
g_free (self->phase1_peaplabel);
|
|
g_free (self->phase1_fast_provisioning);
|
|
g_free (self->phase2_auth);
|
|
g_free (self->phase2_autheap);
|
|
g_free (self->phase2_ca_path);
|
|
g_free (self->nai);
|
|
g_free (self->wep_key0);
|
|
g_free (self->wep_key1);
|
|
g_free (self->wep_key2);
|
|
g_free (self->wep_key3);
|
|
g_free (self->psk);
|
|
g_free (self->password);
|
|
g_free (self->pin);
|
|
g_free (self->eappsk);
|
|
g_free (self->private_key_passwd);
|
|
g_free (self->phase2_private_key_passwd);
|
|
|
|
if (self->proto) {
|
|
g_slist_foreach (self->proto, (GFunc) g_free, NULL);
|
|
g_slist_free (self->proto);
|
|
}
|
|
|
|
if (self->pairwise) {
|
|
g_slist_foreach (self->pairwise, (GFunc) g_free, NULL);
|
|
g_slist_free (self->pairwise);
|
|
}
|
|
|
|
if (self->group) {
|
|
g_slist_foreach (self->group, (GFunc) g_free, NULL);
|
|
g_slist_free (self->group);
|
|
}
|
|
|
|
if (self->eap) {
|
|
g_slist_foreach (self->eap, (GFunc) g_free, NULL);
|
|
g_slist_free (self->eap);
|
|
}
|
|
|
|
if (self->ca_cert)
|
|
g_byte_array_free (self->ca_cert, TRUE);
|
|
if (self->client_cert)
|
|
g_byte_array_free (self->client_cert, TRUE);
|
|
if (self->private_key)
|
|
g_byte_array_free (self->private_key, TRUE);
|
|
if (self->phase2_ca_cert)
|
|
g_byte_array_free (self->phase2_ca_cert, TRUE);
|
|
if (self->phase2_client_cert)
|
|
g_byte_array_free (self->phase2_client_cert, TRUE);
|
|
if (self->phase2_private_key)
|
|
g_byte_array_free (self->phase2_private_key, TRUE);
|
|
|
|
g_slice_free (NMSettingWirelessSecurity, self);
|
|
}
|
|
|
|
static gboolean
|
|
string_list_contains (GSList *list, const char *string)
|
|
{
|
|
GSList *iter;
|
|
|
|
g_return_val_if_fail (string != NULL, FALSE);
|
|
|
|
for (iter = list; iter; iter = g_slist_next (iter))
|
|
if (!strcmp (iter->data, string))
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
setting_wireless_security_update_secrets (NMSetting *setting,
|
|
GHashTable *secrets)
|
|
{
|
|
NMSettingWirelessSecurity *self = (NMSettingWirelessSecurity *) setting;
|
|
SettingMember *m;
|
|
|
|
g_return_val_if_fail (self != NULL, FALSE);
|
|
g_return_val_if_fail (secrets != NULL, FALSE);
|
|
|
|
m = setting->_members;
|
|
while (m->key) {
|
|
GValue *value;
|
|
|
|
if (m->secret == FALSE)
|
|
goto next;
|
|
|
|
value = (GValue *) g_hash_table_lookup (secrets, m->key);
|
|
if (value && G_VALUE_HOLDS_STRING (value)) {
|
|
char **val = (char **) G_STRUCT_MEMBER_P (setting, m->offset);
|
|
g_free (*val);
|
|
*val = g_strdup (g_value_get_string (value));
|
|
}
|
|
|
|
next:
|
|
m++;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
verify_wep_key (const char *key)
|
|
{
|
|
int keylen, i;
|
|
|
|
if (!key)
|
|
return FALSE;
|
|
|
|
keylen = strlen (key);
|
|
if (keylen != 10 && keylen != 26)
|
|
return FALSE;
|
|
|
|
for (i = 0; i < keylen; i++) {
|
|
if (!isxdigit (key[i]))
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
verify_wpa_psk (const char *psk)
|
|
{
|
|
int psklen, i;
|
|
|
|
if (!psk)
|
|
return FALSE;
|
|
|
|
psklen = strlen (psk);
|
|
if (psklen != 64)
|
|
return FALSE;
|
|
|
|
for (i = 0; i < psklen; i++) {
|
|
if (!isxdigit (psk[i]))
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
need_secrets_password (NMSettingWirelessSecurity *self,
|
|
GPtrArray *secrets,
|
|
gboolean phase2)
|
|
{
|
|
if (!self->password || !strlen (self->password))
|
|
g_ptr_array_add (secrets, "password");
|
|
}
|
|
|
|
static void
|
|
need_secrets_eappsk (NMSettingWirelessSecurity *self,
|
|
GPtrArray *secrets,
|
|
gboolean phase2)
|
|
{
|
|
if (!self->eappsk || !strlen (self->eappsk))
|
|
g_ptr_array_add (secrets, "eappsk");
|
|
}
|
|
|
|
static void
|
|
need_secrets_sim (NMSettingWirelessSecurity *self,
|
|
GPtrArray *secrets,
|
|
gboolean phase2)
|
|
{
|
|
if (!self->pin || !strlen (self->pin))
|
|
g_ptr_array_add (secrets, "eappsk");
|
|
}
|
|
|
|
static void
|
|
need_secrets_tls (NMSettingWirelessSecurity *self,
|
|
GPtrArray *secrets,
|
|
gboolean phase2)
|
|
{
|
|
if (phase2) {
|
|
if (!self->phase2_private_key_passwd || !strlen (self->phase2_private_key_passwd))
|
|
g_ptr_array_add (secrets, "phase2-private-key-passwd");
|
|
} else {
|
|
if (!self->private_key_passwd || !strlen (self->private_key_passwd))
|
|
g_ptr_array_add (secrets, "private-key-passwd");
|
|
}
|
|
}
|
|
|
|
/* Implemented below... */
|
|
static void need_secrets_phase2 (NMSettingWirelessSecurity *self,
|
|
GPtrArray *secrets,
|
|
gboolean phase2);
|
|
|
|
|
|
typedef void (*EAPMethodNeedSecretsFunc) (NMSettingWirelessSecurity *self,
|
|
GPtrArray *secrets,
|
|
gboolean phase2);
|
|
|
|
typedef struct {
|
|
const char *method;
|
|
EAPMethodNeedSecretsFunc func;
|
|
} EAPMethodNeedSecretsTable;
|
|
|
|
static EAPMethodNeedSecretsTable eap_need_secrets_table[] = {
|
|
{ "leap", need_secrets_password },
|
|
{ "md5", need_secrets_password },
|
|
{ "pap", need_secrets_password },
|
|
{ "chap", need_secrets_password },
|
|
{ "mschap", need_secrets_password },
|
|
{ "mschapv2", need_secrets_password },
|
|
{ "fast", need_secrets_password },
|
|
{ "psk", need_secrets_eappsk },
|
|
{ "pax", need_secrets_eappsk },
|
|
{ "sake", need_secrets_eappsk },
|
|
{ "gpsk", need_secrets_eappsk },
|
|
{ "tls", need_secrets_tls },
|
|
{ "peap", need_secrets_phase2 },
|
|
{ "ttls", need_secrets_phase2 },
|
|
{ "sim", need_secrets_sim },
|
|
{ "gtc", NULL }, // FIXME: implement
|
|
{ "otp", NULL }, // FIXME: implement
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
static void
|
|
need_secrets_phase2 (NMSettingWirelessSecurity *self,
|
|
GPtrArray *secrets,
|
|
gboolean phase2)
|
|
{
|
|
char *method = NULL;
|
|
int i;
|
|
|
|
g_return_if_fail (phase2 == FALSE);
|
|
|
|
/* Check phase2_auth and phase2_autheap */
|
|
method = self->phase2_auth;
|
|
if (!method && self->phase2_autheap)
|
|
method = self->phase2_autheap;
|
|
|
|
if (!method) {
|
|
g_warning ("Couldn't find EAP method.");
|
|
g_assert_not_reached();
|
|
return;
|
|
}
|
|
|
|
/* Ask the configured phase2 method if it needs secrets */
|
|
for (i = 0; eap_need_secrets_table[i].method; i++) {
|
|
if (eap_need_secrets_table[i].func == NULL)
|
|
continue;
|
|
if (strcmp (eap_need_secrets_table[i].method, method)) {
|
|
(*eap_need_secrets_table[i].func) (self, secrets, TRUE);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
static GPtrArray *
|
|
setting_wireless_security_need_secrets (NMSetting *setting)
|
|
{
|
|
NMSettingWirelessSecurity *self = (NMSettingWirelessSecurity *) setting;
|
|
GPtrArray *secrets;
|
|
|
|
secrets = g_ptr_array_sized_new (4);
|
|
if (!secrets) {
|
|
g_warning ("Not enough memory to create required secrets array.");
|
|
return NULL;
|
|
}
|
|
|
|
g_assert (self->key_mgmt);
|
|
|
|
/* Static WEP */
|
|
if (strcmp (self->key_mgmt, "none") == 0) {
|
|
if (!verify_wep_key (self->wep_key0)) {
|
|
g_ptr_array_add (secrets, "wep-key0");
|
|
return secrets;
|
|
}
|
|
if (self->wep_tx_keyidx == 1 && !verify_wep_key (self->wep_key1)) {
|
|
g_ptr_array_add (secrets, "wep-key1");
|
|
return secrets;
|
|
}
|
|
if (self->wep_tx_keyidx == 2 && !verify_wep_key (self->wep_key2)) {
|
|
g_ptr_array_add (secrets, "wep-key2");
|
|
return secrets;
|
|
}
|
|
if (self->wep_tx_keyidx == 3 && !verify_wep_key (self->wep_key3)) {
|
|
g_ptr_array_add (secrets, "wep-key3");
|
|
return secrets;
|
|
}
|
|
goto no_secrets;
|
|
}
|
|
|
|
/* WPA-PSK infrastructure and adhoc */
|
|
if ( (strcmp (self->key_mgmt, "wpa-none") == 0)
|
|
|| (strcmp (self->key_mgmt, "wpa-psk") == 0)) {
|
|
if (!verify_wpa_psk (self->psk)) {
|
|
g_ptr_array_add (secrets, "psk");
|
|
return secrets;
|
|
}
|
|
goto no_secrets;
|
|
}
|
|
|
|
/* LEAP */
|
|
if ( (strcmp (self->key_mgmt, "ieee8021x") == 0)
|
|
&& self->auth_alg
|
|
&& (strcmp (self->auth_alg, "leap") == 0)
|
|
&& (string_list_contains (self->eap, "leap"))) {
|
|
if (!self->password || !strlen (self->password)) {
|
|
g_ptr_array_add (secrets, "password");
|
|
return secrets;
|
|
}
|
|
goto no_secrets;
|
|
}
|
|
|
|
if ( (strcmp (self->key_mgmt, "ieee8021x") == 0)
|
|
|| (strcmp (self->key_mgmt, "wpa-eap") == 0)) {
|
|
GSList *iter;
|
|
gboolean eap_method_found = FALSE;
|
|
|
|
/* Ask each configured EAP method if it needs secrets */
|
|
for (iter = self->eap; iter && !eap_method_found; iter = g_slist_next (iter)) {
|
|
const char *method = (const char *) iter->data;
|
|
int i;
|
|
|
|
for (i = 0; eap_need_secrets_table[i].method; i++) {
|
|
if (eap_need_secrets_table[i].func == NULL)
|
|
continue;
|
|
if (strcmp (eap_need_secrets_table[i].method, method)) {
|
|
(*eap_need_secrets_table[i].func) (self, secrets, FALSE);
|
|
|
|
/* Only break out of the outer loop if this EAP method
|
|
* needed secrets.
|
|
*/
|
|
if (secrets->len > 0)
|
|
eap_method_found = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (secrets->len)
|
|
return secrets;
|
|
goto no_secrets;
|
|
}
|
|
|
|
g_assert_not_reached ();
|
|
return secrets;
|
|
|
|
no_secrets:
|
|
if (secrets)
|
|
g_ptr_array_free (secrets, TRUE);
|
|
return NULL;
|
|
}
|
|
|
|
static SettingMember wireless_sec_table[] = {
|
|
{ "key-mgmt", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, key_mgmt), TRUE, FALSE },
|
|
{ "wep-tx-keyidx", NM_S_TYPE_UINT32, G_STRUCT_OFFSET (NMSettingWirelessSecurity, wep_tx_keyidx), FALSE, FALSE },
|
|
{ "auth-alg", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, auth_alg), FALSE, FALSE },
|
|
{ "proto", NM_S_TYPE_STRING_ARRAY, G_STRUCT_OFFSET (NMSettingWirelessSecurity, proto), FALSE, FALSE },
|
|
{ "pairwise", NM_S_TYPE_STRING_ARRAY, G_STRUCT_OFFSET (NMSettingWirelessSecurity, pairwise), FALSE, FALSE },
|
|
{ "group", NM_S_TYPE_STRING_ARRAY, G_STRUCT_OFFSET (NMSettingWirelessSecurity, group), FALSE, FALSE },
|
|
{ "eap", NM_S_TYPE_STRING_ARRAY, G_STRUCT_OFFSET (NMSettingWirelessSecurity, eap), FALSE, FALSE },
|
|
{ "identity", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, identity), FALSE, FALSE },
|
|
{ "anonymous-identity", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, anonymous_identity), FALSE, FALSE },
|
|
{ "ca-cert", NM_S_TYPE_BYTE_ARRAY, G_STRUCT_OFFSET (NMSettingWirelessSecurity, ca_cert), FALSE, FALSE },
|
|
{ "ca-path", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, ca_path), FALSE, FALSE },
|
|
{ "client-cert", NM_S_TYPE_BYTE_ARRAY, G_STRUCT_OFFSET (NMSettingWirelessSecurity, client_cert), FALSE, FALSE },
|
|
{ "private-key", NM_S_TYPE_BYTE_ARRAY, G_STRUCT_OFFSET (NMSettingWirelessSecurity, private_key), FALSE, FALSE },
|
|
{ "phase1-peapver", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, phase1_peapver), FALSE, FALSE },
|
|
{ "phase1-peaplabel", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, phase1_peaplabel), FALSE, FALSE },
|
|
{ "phase1-fast-provisioning", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, phase1_fast_provisioning), FALSE, FALSE },
|
|
{ "phase2-auth", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, phase2_auth), FALSE, FALSE },
|
|
{ "phase2-autheap", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, phase2_autheap), FALSE, FALSE },
|
|
{ "phase2-ca-cert", NM_S_TYPE_BYTE_ARRAY, G_STRUCT_OFFSET (NMSettingWirelessSecurity, phase2_ca_cert), FALSE, FALSE },
|
|
{ "phase2-ca-path", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, phase2_ca_path), FALSE, FALSE },
|
|
{ "phase2-client-cert", NM_S_TYPE_BYTE_ARRAY, G_STRUCT_OFFSET (NMSettingWirelessSecurity, phase2_client_cert), FALSE, FALSE },
|
|
{ "phase2-private-key", NM_S_TYPE_BYTE_ARRAY, G_STRUCT_OFFSET (NMSettingWirelessSecurity, phase2_private_key), FALSE, FALSE },
|
|
{ "nai", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, nai), FALSE, FALSE },
|
|
{ "wep-key0", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, wep_key0), FALSE, TRUE },
|
|
{ "wep-key1", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, wep_key1), FALSE, TRUE },
|
|
{ "wep-key2", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, wep_key2), FALSE, TRUE },
|
|
{ "wep-key3", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, wep_key3), FALSE, TRUE },
|
|
{ "psk", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, psk), FALSE, TRUE },
|
|
{ "password", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, password), FALSE, TRUE },
|
|
{ "pin", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, pin), FALSE, TRUE },
|
|
{ "eappsk", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, eappsk), FALSE, TRUE },
|
|
{ "private-key-passwd", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, private_key_passwd), FALSE, TRUE },
|
|
{ "phase2-private-key-passwd", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingWirelessSecurity, phase2_private_key_passwd), FALSE, TRUE },
|
|
{ NULL, 0, 0 },
|
|
};
|
|
|
|
NMSetting *
|
|
nm_setting_wireless_security_new (void)
|
|
{
|
|
NMSetting *setting;
|
|
|
|
setting = (NMSetting *) g_slice_new0 (NMSettingWirelessSecurity);
|
|
|
|
setting->name = g_strdup (NM_SETTING_WIRELESS_SECURITY);
|
|
setting->_members = wireless_sec_table;
|
|
setting->verify_fn = setting_wireless_security_verify;
|
|
setting->update_secrets_fn = setting_wireless_security_update_secrets;
|
|
setting->need_secrets_fn = setting_wireless_security_need_secrets;
|
|
setting->destroy_fn = setting_wireless_security_destroy;
|
|
|
|
return setting;
|
|
}
|
|
|
|
/* PPP */
|
|
|
|
static gboolean
|
|
setting_ppp_verify (NMSetting *setting, GHashTable *all_settings)
|
|
{
|
|
/* FIXME: Do we even want this or can we just let pppd evaluate the options? */
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
setting_ppp_destroy (NMSetting *setting)
|
|
{
|
|
NMSettingPPP *self = (NMSettingPPP *) setting;
|
|
|
|
g_slice_free (NMSettingPPP, self);
|
|
}
|
|
|
|
static SettingMember ppp_table[] = {
|
|
{ "noauth", NM_S_TYPE_BOOL, G_STRUCT_OFFSET (NMSettingPPP, noauth), FALSE, FALSE },
|
|
{ "refuse-eap", NM_S_TYPE_BOOL, G_STRUCT_OFFSET (NMSettingPPP, refuse_eap), FALSE, FALSE },
|
|
{ "refuse-chap", NM_S_TYPE_BOOL, G_STRUCT_OFFSET (NMSettingPPP, refuse_chap), FALSE, FALSE },
|
|
{ "refuse-mschap", NM_S_TYPE_BOOL, G_STRUCT_OFFSET (NMSettingPPP, refuse_mschap), FALSE, FALSE },
|
|
{ "nobsdcomp", NM_S_TYPE_BOOL, G_STRUCT_OFFSET (NMSettingPPP, nobsdcomp), FALSE, FALSE },
|
|
{ "nodeflate", NM_S_TYPE_BOOL, G_STRUCT_OFFSET (NMSettingPPP, nodeflate), FALSE, FALSE },
|
|
{ "require-mppe", NM_S_TYPE_BOOL, G_STRUCT_OFFSET (NMSettingPPP, require_mppe), FALSE, FALSE },
|
|
{ "require-mppe-128", NM_S_TYPE_BOOL, G_STRUCT_OFFSET (NMSettingPPP, require_mppe_128), FALSE, FALSE },
|
|
{ "mppe-stateful", NM_S_TYPE_BOOL, G_STRUCT_OFFSET (NMSettingPPP, mppe_stateful), FALSE, FALSE },
|
|
{ "require-mppc", NM_S_TYPE_BOOL, G_STRUCT_OFFSET (NMSettingPPP, require_mppc), FALSE, FALSE },
|
|
{ "crtscts", NM_S_TYPE_BOOL, G_STRUCT_OFFSET (NMSettingPPP, crtscts), FALSE, FALSE },
|
|
{ "usepeerdns", NM_S_TYPE_BOOL, G_STRUCT_OFFSET (NMSettingPPP, usepeerdns), FALSE, FALSE },
|
|
{ "baud", NM_S_TYPE_UINT32, G_STRUCT_OFFSET (NMSettingPPP, baud), FALSE, FALSE },
|
|
{ "mru", NM_S_TYPE_UINT32, G_STRUCT_OFFSET (NMSettingPPP, mru), FALSE, FALSE },
|
|
{ "mtu", NM_S_TYPE_UINT32, G_STRUCT_OFFSET (NMSettingPPP, mtu), FALSE, FALSE },
|
|
{ "lcp-echo-failure", NM_S_TYPE_UINT32, G_STRUCT_OFFSET (NMSettingPPP, lcp_echo_failure), FALSE, FALSE },
|
|
{ "lcp-echo-interval", NM_S_TYPE_UINT32, G_STRUCT_OFFSET (NMSettingPPP, lcp_echo_interval), FALSE, FALSE },
|
|
{ NULL, 0, 0 },
|
|
};
|
|
|
|
NMSetting *
|
|
nm_setting_ppp_new (void)
|
|
{
|
|
NMSetting *setting;
|
|
|
|
setting = (NMSetting *) g_slice_new0 (NMSettingPPP);
|
|
|
|
setting->name = g_strdup (NM_SETTING_PPP);
|
|
setting->_members = ppp_table;
|
|
setting->verify_fn = setting_ppp_verify;
|
|
setting->destroy_fn = setting_ppp_destroy;
|
|
|
|
return setting;
|
|
}
|
|
|
|
/* vpn setting */
|
|
|
|
static gboolean
|
|
setting_vpn_verify (NMSetting *setting, GHashTable *all_settings)
|
|
{
|
|
NMSettingVPN *self = (NMSettingVPN *) setting;
|
|
|
|
if (!self->service_type || !strlen (self->service_type))
|
|
return FALSE;
|
|
|
|
/* default username can be NULL, but can't be zero-length */
|
|
if (self->user_name && !strlen (self->user_name))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
setting_vpn_destroy (NMSetting *setting)
|
|
{
|
|
NMSettingVPN *self = (NMSettingVPN *) setting;
|
|
|
|
g_free (self->service_type);
|
|
g_free (self->user_name);
|
|
|
|
if (self->routes) {
|
|
g_slist_foreach (self->routes, (GFunc) g_free, NULL);
|
|
g_slist_free (self->routes);
|
|
}
|
|
|
|
g_slice_free (NMSettingVPN, self);
|
|
}
|
|
|
|
static SettingMember vpn_table[] = {
|
|
{ "service_type", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingVPN, service_type), TRUE, FALSE },
|
|
{ "user_name", NM_S_TYPE_STRING, G_STRUCT_OFFSET (NMSettingVPN, user_name), FALSE, FALSE },
|
|
{ "routes", NM_S_TYPE_STRING_ARRAY, G_STRUCT_OFFSET (NMSettingVPN, routes), FALSE, FALSE },
|
|
{ NULL, 0, 0 },
|
|
};
|
|
|
|
NMSetting *
|
|
nm_setting_vpn_new (void)
|
|
{
|
|
NMSetting *setting;
|
|
|
|
setting = (NMSetting *) g_slice_new0 (NMSettingVPN);
|
|
|
|
setting->name = g_strdup (NM_SETTING_VPN);
|
|
setting->_members = vpn_table;
|
|
setting->verify_fn = setting_vpn_verify;
|
|
setting->destroy_fn = setting_vpn_destroy;
|
|
|
|
return setting;
|
|
}
|
|
|
|
/* vpn-properties setting */
|
|
|
|
static gboolean
|
|
setting_vpn_properties_verify (NMSetting *setting, GHashTable *all_settings)
|
|
{
|
|
NMSettingVPNProperties *self = (NMSettingVPNProperties *) setting;
|
|
|
|
if (!self->data)
|
|
return FALSE;
|
|
|
|
/* FIXME: actually check the data as well */
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static GHashTable *
|
|
setting_vpn_properties_hash (NMSetting *setting)
|
|
{
|
|
NMSettingVPNProperties *self = (NMSettingVPNProperties *) setting;
|
|
|
|
g_return_val_if_fail (self->data != NULL, NULL);
|
|
|
|
return nm_utils_gvalue_hash_dup (self->data);
|
|
}
|
|
|
|
static void
|
|
setting_vpn_properties_destroy (NMSetting *setting)
|
|
{
|
|
NMSettingVPNProperties *self = (NMSettingVPNProperties *) setting;
|
|
|
|
g_hash_table_destroy (self->data);
|
|
g_slice_free (NMSettingVPNProperties, self);
|
|
}
|
|
|
|
static void
|
|
property_value_destroy (gpointer data)
|
|
{
|
|
GValue *value = (GValue *) data;
|
|
|
|
g_value_unset (value);
|
|
g_slice_free (GValue, data);
|
|
}
|
|
|
|
static void
|
|
add_one_secret (gpointer key, gpointer value, gpointer user_data)
|
|
{
|
|
NMSettingVPNProperties *self = (NMSettingVPNProperties *) user_data;
|
|
GValue * new_value;
|
|
|
|
if (!value || !G_VALUE_HOLDS_STRING (value))
|
|
return;
|
|
|
|
new_value = g_slice_new0 (GValue);
|
|
if (!new_value)
|
|
return;
|
|
|
|
g_value_init (new_value, G_TYPE_STRING);
|
|
g_value_copy (value, new_value);
|
|
g_hash_table_insert (self->data, g_strdup (key), new_value);
|
|
}
|
|
|
|
static gboolean
|
|
setting_vpn_properties_update_secrets (NMSetting *setting,
|
|
GHashTable *secrets)
|
|
{
|
|
NMSettingVPNProperties *self = (NMSettingVPNProperties *) setting;
|
|
|
|
g_return_val_if_fail (self != NULL, FALSE);
|
|
g_return_val_if_fail (secrets != NULL, FALSE);
|
|
|
|
g_hash_table_foreach (secrets, add_one_secret, self);
|
|
return TRUE;
|
|
}
|
|
|
|
static SettingMember vpn_properties_table[] = {
|
|
{ "data", NM_S_TYPE_GVALUE_HASH, G_STRUCT_OFFSET (NMSettingVPNProperties, data), TRUE, FALSE },
|
|
{ NULL, 0, 0 },
|
|
};
|
|
|
|
NMSetting *
|
|
nm_setting_vpn_properties_new (void)
|
|
{
|
|
NMSetting *setting;
|
|
NMSettingVPNProperties *s_vpn_props;
|
|
|
|
setting = (NMSetting *) g_slice_new0 (NMSettingVPNProperties);
|
|
|
|
setting->name = g_strdup (NM_SETTING_VPN_PROPERTIES);
|
|
setting->_members = vpn_properties_table;
|
|
setting->verify_fn = setting_vpn_properties_verify;
|
|
setting->hash_fn = setting_vpn_properties_hash;
|
|
setting->update_secrets_fn = setting_vpn_properties_update_secrets;
|
|
setting->destroy_fn = setting_vpn_properties_destroy;
|
|
|
|
s_vpn_props = (NMSettingVPNProperties *) setting;
|
|
s_vpn_props->data = g_hash_table_new_full (g_str_hash, g_str_equal,
|
|
(GDestroyNotify) g_free,
|
|
property_value_destroy);
|
|
|
|
return setting;
|
|
}
|