3b97185ff8
NMSettingConnection was making sure that bond slaves didn't have an IP configuration, but it should have been making that check for bridge and team slaves too.
1307 lines
43 KiB
C
1307 lines
43 KiB
C
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
|
|
|
|
/*
|
|
* Dan Williams <dcbw@redhat.com>
|
|
* Tambet Ingo <tambet@gmail.com>
|
|
*
|
|
* 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.
|
|
*
|
|
* (C) Copyright 2007 - 2013 Red Hat, Inc.
|
|
* (C) Copyright 2007 - 2008 Novell, Inc.
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <glib/gi18n.h>
|
|
|
|
#include "nm-utils.h"
|
|
#include "nm-dbus-glib-types.h"
|
|
#include "nm-param-spec-specialized.h"
|
|
#include "nm-setting-connection.h"
|
|
#include "nm-setting-private.h"
|
|
|
|
/**
|
|
* SECTION:nm-setting-connection
|
|
* @short_description: Describes general connection properties
|
|
* @include: nm-setting-connection.h
|
|
*
|
|
* The #NMSettingConnection object is a #NMSetting subclass that describes
|
|
* properties that apply to all #NMConnection objects, regardless of what type
|
|
* of network connection they describe. Each #NMConnection object must contain
|
|
* a #NMSettingConnection setting.
|
|
**/
|
|
|
|
/**
|
|
* nm_setting_connection_error_quark:
|
|
*
|
|
* Registers an error quark for #NMSettingConnection if necessary.
|
|
*
|
|
* Returns: the error quark used for #NMSettingConnection errors.
|
|
**/
|
|
GQuark
|
|
nm_setting_connection_error_quark (void)
|
|
{
|
|
static GQuark quark;
|
|
|
|
if (G_UNLIKELY (!quark))
|
|
quark = g_quark_from_static_string ("nm-setting-connection-error-quark");
|
|
return quark;
|
|
}
|
|
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (NMSettingConnection, nm_setting_connection, NM_TYPE_SETTING,
|
|
_nm_register_setting (NM_SETTING_CONNECTION_SETTING_NAME,
|
|
g_define_type_id,
|
|
0,
|
|
NM_SETTING_CONNECTION_ERROR))
|
|
NM_SETTING_REGISTER_TYPE (NM_TYPE_SETTING_CONNECTION)
|
|
|
|
#define NM_SETTING_CONNECTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_SETTING_CONNECTION, NMSettingConnectionPrivate))
|
|
|
|
typedef enum {
|
|
PERM_TYPE_USER = 0,
|
|
} PermType;
|
|
|
|
typedef struct {
|
|
guint8 ptype;
|
|
char *item;
|
|
} Permission;
|
|
|
|
typedef struct {
|
|
char *id;
|
|
char *uuid;
|
|
char *interface_name;
|
|
char *type;
|
|
char *master;
|
|
char *slave_type;
|
|
GSList *permissions; /* list of Permission structs */
|
|
gboolean autoconnect;
|
|
guint64 timestamp;
|
|
gboolean read_only;
|
|
char *zone;
|
|
GSList *secondaries; /* secondary connections to activate with the base connection */
|
|
guint gateway_ping_timeout;
|
|
} NMSettingConnectionPrivate;
|
|
|
|
enum {
|
|
PROP_0,
|
|
PROP_ID,
|
|
PROP_UUID,
|
|
PROP_INTERFACE_NAME,
|
|
PROP_TYPE,
|
|
PROP_PERMISSIONS,
|
|
PROP_AUTOCONNECT,
|
|
PROP_TIMESTAMP,
|
|
PROP_READ_ONLY,
|
|
PROP_ZONE,
|
|
PROP_MASTER,
|
|
PROP_SLAVE_TYPE,
|
|
PROP_SECONDARIES,
|
|
PROP_GATEWAY_PING_TIMEOUT,
|
|
|
|
LAST_PROP
|
|
};
|
|
|
|
/***********************************************************************/
|
|
|
|
#define PERM_USER_PREFIX "user:"
|
|
|
|
static Permission *
|
|
permission_new_from_str (const char *str)
|
|
{
|
|
Permission *p;
|
|
const char *last_colon;
|
|
size_t ulen = 0, i;
|
|
|
|
g_return_val_if_fail (strncmp (str, PERM_USER_PREFIX, strlen (PERM_USER_PREFIX)) == 0, NULL);
|
|
str += strlen (PERM_USER_PREFIX);
|
|
|
|
last_colon = strrchr (str, ':');
|
|
if (last_colon) {
|
|
/* Ensure that somebody didn't pass "user::" */
|
|
g_return_val_if_fail (last_colon > str, NULL);
|
|
|
|
/* Reject :[detail] for now */
|
|
g_return_val_if_fail (*(last_colon + 1) == '\0', NULL);
|
|
|
|
/* Make sure we don't include detail in the username */
|
|
ulen = last_colon - str;
|
|
} else
|
|
ulen = strlen (str);
|
|
|
|
/* Sanity check the length of the username */
|
|
g_return_val_if_fail (ulen < 100, NULL);
|
|
|
|
/* Make sure there's no ':' in the username */
|
|
for (i = 0; i < ulen; i++)
|
|
g_return_val_if_fail (str[i] != ':', NULL);
|
|
|
|
/* And the username must be valid UTF-8 */
|
|
g_return_val_if_fail (g_utf8_validate (str, -1, NULL) == TRUE, NULL);
|
|
|
|
/* Yay, valid... create the new permission */
|
|
p = g_slice_new0 (Permission);
|
|
p->ptype = PERM_TYPE_USER;
|
|
if (last_colon) {
|
|
p->item = g_malloc (ulen + 1);
|
|
memcpy (p->item, str, ulen);
|
|
p->item[ulen] = '\0';
|
|
} else
|
|
p->item = g_strdup (str);
|
|
|
|
return p;
|
|
}
|
|
|
|
static Permission *
|
|
permission_new (const char *uname)
|
|
{
|
|
Permission *p;
|
|
|
|
g_return_val_if_fail (uname, NULL);
|
|
g_return_val_if_fail (uname[0] != '\0', NULL);
|
|
g_return_val_if_fail (strchr (uname, ':') == NULL, NULL);
|
|
g_return_val_if_fail (g_utf8_validate (uname, -1, NULL) == TRUE, NULL);
|
|
|
|
/* Yay, valid... create the new permission */
|
|
p = g_slice_new0 (Permission);
|
|
p->ptype = PERM_TYPE_USER;
|
|
p->item = g_strdup (uname);
|
|
return p;
|
|
}
|
|
|
|
static char *
|
|
permission_to_string (Permission *p)
|
|
{
|
|
return g_strdup_printf (PERM_USER_PREFIX "%s:", p->item);
|
|
}
|
|
|
|
static void
|
|
permission_free (Permission *p)
|
|
{
|
|
g_free (p->item);
|
|
memset (p, 0, sizeof (*p));
|
|
g_slice_free (Permission, p);
|
|
}
|
|
|
|
/***********************************************************************/
|
|
|
|
/**
|
|
* nm_setting_connection_new:
|
|
*
|
|
* Creates a new #NMSettingConnection object with default values.
|
|
*
|
|
* Returns: the new empty #NMSettingConnection object
|
|
**/
|
|
NMSetting *nm_setting_connection_new (void)
|
|
{
|
|
return (NMSetting *) g_object_new (NM_TYPE_SETTING_CONNECTION, NULL);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_get_id:
|
|
* @setting: the #NMSettingConnection
|
|
*
|
|
* Returns the #NMSettingConnection:id property of the connection.
|
|
*
|
|
* Returns: the connection ID
|
|
**/
|
|
const char *
|
|
nm_setting_connection_get_id (NMSettingConnection *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), NULL);
|
|
|
|
return NM_SETTING_CONNECTION_GET_PRIVATE (setting)->id;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_get_uuid:
|
|
* @setting: the #NMSettingConnection
|
|
*
|
|
* Returns the #NMSettingConnection:uuid property of the connection.
|
|
*
|
|
* Returns: the connection UUID
|
|
**/
|
|
const char *
|
|
nm_setting_connection_get_uuid (NMSettingConnection *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), NULL);
|
|
|
|
return NM_SETTING_CONNECTION_GET_PRIVATE (setting)->uuid;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_get_interface_name:
|
|
* @setting: the #NMSettingConnection
|
|
*
|
|
* Returns the #NMSettingConnection:interface-name property of the connection.
|
|
*
|
|
* Returns: the connection's interface name
|
|
*
|
|
* Since: 0.9.10
|
|
**/
|
|
const char *
|
|
nm_setting_connection_get_interface_name (NMSettingConnection *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), NULL);
|
|
|
|
return NM_SETTING_CONNECTION_GET_PRIVATE (setting)->interface_name;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_get_connection_type:
|
|
* @setting: the #NMSettingConnection
|
|
*
|
|
* Returns the #NMSettingConnection:type property of the connection.
|
|
*
|
|
* Returns: the connection type
|
|
**/
|
|
const char *
|
|
nm_setting_connection_get_connection_type (NMSettingConnection *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), NULL);
|
|
|
|
return NM_SETTING_CONNECTION_GET_PRIVATE (setting)->type;
|
|
}
|
|
|
|
|
|
/**
|
|
* nm_setting_connection_get_num_permissions:
|
|
* @setting: the #NMSettingConnection
|
|
*
|
|
* Returns the number of entires in the #NMSettingConnection:permissions
|
|
* property of this setting.
|
|
*
|
|
* Returns: the number of permissions entires
|
|
*/
|
|
guint32
|
|
nm_setting_connection_get_num_permissions (NMSettingConnection *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), 0);
|
|
|
|
return g_slist_length (NM_SETTING_CONNECTION_GET_PRIVATE (setting)->permissions);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_get_permission:
|
|
* @setting: the #NMSettingConnection
|
|
* @idx: the zero-based index of the permissions entry
|
|
* @out_ptype: on return, the permission type (at this time, always "user")
|
|
* @out_pitem: on return, the permission item (formatted accoring to @ptype, see
|
|
* #NMSettingConnection:permissions for more detail
|
|
* @out_detail: on return, the permission detail (at this time, always %NULL)
|
|
*
|
|
* Retrieve one of the entries of the #NMSettingConnection:permissions property
|
|
* of this setting.
|
|
*
|
|
* Returns: %TRUE if a permission was returned, %FALSE if @idx was invalid
|
|
*/
|
|
gboolean
|
|
nm_setting_connection_get_permission (NMSettingConnection *setting,
|
|
guint32 idx,
|
|
const char **out_ptype,
|
|
const char **out_pitem,
|
|
const char **out_detail)
|
|
{
|
|
NMSettingConnectionPrivate *priv;
|
|
Permission *p;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), FALSE);
|
|
|
|
priv = NM_SETTING_CONNECTION_GET_PRIVATE (setting);
|
|
|
|
g_return_val_if_fail (idx < g_slist_length (priv->permissions), FALSE);
|
|
|
|
p = g_slist_nth_data (priv->permissions, idx);
|
|
if (out_ptype)
|
|
*out_ptype = "user";
|
|
if (out_pitem)
|
|
*out_pitem = p->item;
|
|
if (out_detail)
|
|
*out_detail = NULL;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_permissions_user_allowed:
|
|
* @setting: the #NMSettingConnection
|
|
* @uname: the user name to check permissions for
|
|
*
|
|
* Checks whether the given username is allowed to view/access this connection.
|
|
*
|
|
* Returns: %TRUE if the requested user is allowed to view this connection,
|
|
* %FALSE if the given user is not allowed to view this connection
|
|
*/
|
|
gboolean
|
|
nm_setting_connection_permissions_user_allowed (NMSettingConnection *setting,
|
|
const char *uname)
|
|
{
|
|
NMSettingConnectionPrivate *priv;
|
|
GSList *iter;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), FALSE);
|
|
g_return_val_if_fail (uname != NULL, FALSE);
|
|
g_return_val_if_fail (*uname != '\0', FALSE);
|
|
|
|
priv = NM_SETTING_CONNECTION_GET_PRIVATE (setting);
|
|
|
|
/* If no permissions, visible to all */
|
|
if (priv->permissions == NULL)
|
|
return TRUE;
|
|
|
|
/* Find the username in the permissions list */
|
|
for (iter = priv->permissions; iter; iter = g_slist_next (iter)) {
|
|
Permission *p = iter->data;
|
|
|
|
if (strcmp (uname, p->item) == 0)
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_add_permission:
|
|
* @setting: the #NMSettingConnection
|
|
* @ptype: the permission type; at this time only "user" is supported
|
|
* @pitem: the permission item formatted as required for @ptype
|
|
* @detail: (allow-none): unused at this time; must be %NULL
|
|
*
|
|
* Adds a permission to the connection's permission list. At this time, only
|
|
* the "user" permission type is supported, and @pitem must be a username. See
|
|
* #NMSettingConnection:permissions: for more details.
|
|
*
|
|
* Returns: TRUE if the permission was unique and was successfully added to the
|
|
* list, FALSE if @ptype or @pitem was invalid or it the permission was already
|
|
* present in the list
|
|
*/
|
|
gboolean
|
|
nm_setting_connection_add_permission (NMSettingConnection *setting,
|
|
const char *ptype,
|
|
const char *pitem,
|
|
const char *detail)
|
|
{
|
|
NMSettingConnectionPrivate *priv;
|
|
Permission *p;
|
|
GSList *iter;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), FALSE);
|
|
g_return_val_if_fail (ptype, FALSE);
|
|
g_return_val_if_fail (strlen (ptype) > 0, FALSE);
|
|
g_return_val_if_fail (detail == NULL, FALSE);
|
|
|
|
/* Only "user" for now... */
|
|
g_return_val_if_fail (strcmp (ptype, "user") == 0, FALSE);
|
|
|
|
priv = NM_SETTING_CONNECTION_GET_PRIVATE (setting);
|
|
|
|
/* No dupes */
|
|
for (iter = priv->permissions; iter; iter = g_slist_next (iter)) {
|
|
p = iter->data;
|
|
if (strcmp (pitem, p->item) == 0)
|
|
return FALSE;
|
|
}
|
|
|
|
p = permission_new (pitem);
|
|
g_return_val_if_fail (p != NULL, FALSE);
|
|
priv->permissions = g_slist_append (priv->permissions, p);
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_CONNECTION_PERMISSIONS);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_remove_permission:
|
|
* @setting: the #NMSettingConnection
|
|
* @idx: the zero-based index of the permission to remove
|
|
*
|
|
* Removes the permission at index @idx from the connection.
|
|
*/
|
|
void
|
|
nm_setting_connection_remove_permission (NMSettingConnection *setting,
|
|
guint32 idx)
|
|
{
|
|
NMSettingConnectionPrivate *priv;
|
|
GSList *iter;
|
|
|
|
g_return_if_fail (NM_IS_SETTING_CONNECTION (setting));
|
|
|
|
priv = NM_SETTING_CONNECTION_GET_PRIVATE (setting);
|
|
iter = g_slist_nth (priv->permissions, idx);
|
|
g_return_if_fail (iter != NULL);
|
|
|
|
permission_free ((Permission *) iter->data);
|
|
priv->permissions = g_slist_delete_link (priv->permissions, iter);
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_CONNECTION_PERMISSIONS);
|
|
}
|
|
|
|
|
|
/**
|
|
* nm_setting_connection_get_autoconnect:
|
|
* @setting: the #NMSettingConnection
|
|
*
|
|
* Returns the #NMSettingConnection:autoconnect property of the connection.
|
|
*
|
|
* Returns: the connection's autoconnect behavior
|
|
**/
|
|
gboolean
|
|
nm_setting_connection_get_autoconnect (NMSettingConnection *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), FALSE);
|
|
|
|
return NM_SETTING_CONNECTION_GET_PRIVATE (setting)->autoconnect;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_get_timestamp:
|
|
* @setting: the #NMSettingConnection
|
|
*
|
|
* Returns the #NMSettingConnection:timestamp property of the connection.
|
|
*
|
|
* Returns: the connection's timestamp
|
|
**/
|
|
guint64
|
|
nm_setting_connection_get_timestamp (NMSettingConnection *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), 0);
|
|
|
|
return NM_SETTING_CONNECTION_GET_PRIVATE (setting)->timestamp;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_get_read_only:
|
|
* @setting: the #NMSettingConnection
|
|
*
|
|
* Returns the #NMSettingConnection:read-only property of the connection.
|
|
*
|
|
* Returns: %TRUE if the connection is read-only, %FALSE if it is not
|
|
**/
|
|
gboolean
|
|
nm_setting_connection_get_read_only (NMSettingConnection *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), TRUE);
|
|
|
|
return NM_SETTING_CONNECTION_GET_PRIVATE (setting)->read_only;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_get_zone:
|
|
* @setting: the #NMSettingConnection
|
|
*
|
|
* Returns the #NMSettingConnection:zone property of the connection.
|
|
*
|
|
* Returns: the trust level of a connection
|
|
**/
|
|
const char *
|
|
nm_setting_connection_get_zone (NMSettingConnection *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), NULL);
|
|
|
|
return NM_SETTING_CONNECTION_GET_PRIVATE (setting)->zone;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_get_master:
|
|
* @setting: the #NMSettingConnection
|
|
*
|
|
* Returns the #NMSettingConnection:master property of the connection.
|
|
*
|
|
* Returns: interface name of the master device or UUID of the master
|
|
* connection.
|
|
*/
|
|
const char *
|
|
nm_setting_connection_get_master (NMSettingConnection *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), NULL);
|
|
|
|
return NM_SETTING_CONNECTION_GET_PRIVATE (setting)->master;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_get_slave_type:
|
|
* @setting: the #NMSettingConnection
|
|
*
|
|
* Returns the #NMSettingConnection:slave-type property of the connection.
|
|
*
|
|
* Returns: the type of slave this connection is, if any
|
|
*/
|
|
const char *
|
|
nm_setting_connection_get_slave_type (NMSettingConnection *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), NULL);
|
|
|
|
return NM_SETTING_CONNECTION_GET_PRIVATE (setting)->slave_type;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_is_slave_type:
|
|
* @setting: the #NMSettingConnection
|
|
* @type: the setting name (ie #NM_SETTING_BOND_SETTING_NAME) to be matched
|
|
* against @setting's slave type
|
|
*
|
|
* Returns: TRUE if connection is of the given slave @type
|
|
*/
|
|
gboolean
|
|
nm_setting_connection_is_slave_type (NMSettingConnection *setting,
|
|
const char *type)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), FALSE);
|
|
|
|
return !g_strcmp0 (NM_SETTING_CONNECTION_GET_PRIVATE (setting)->slave_type, type);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_get_num_secondaries:
|
|
* @setting: the #NMSettingConnection
|
|
*
|
|
* Returns: the number of configured secondary connection UUIDs
|
|
*
|
|
* Since: 0.9.8
|
|
**/
|
|
guint32
|
|
nm_setting_connection_get_num_secondaries (NMSettingConnection *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), 0);
|
|
|
|
return g_slist_length (NM_SETTING_CONNECTION_GET_PRIVATE (setting)->secondaries);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_get_secondary:
|
|
* @setting: the #NMSettingConnection
|
|
* @idx: the zero-based index of the secondary connection UUID entry
|
|
*
|
|
* Returns: the secondary connection UUID at index @idx
|
|
*
|
|
* Since: 0.9.8
|
|
**/
|
|
const char *
|
|
nm_setting_connection_get_secondary (NMSettingConnection *setting, guint32 idx)
|
|
{
|
|
NMSettingConnectionPrivate *priv;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), NULL);
|
|
|
|
priv = NM_SETTING_CONNECTION_GET_PRIVATE (setting);
|
|
g_return_val_if_fail (idx <= g_slist_length (priv->secondaries), NULL);
|
|
|
|
return (const char *) g_slist_nth_data (priv->secondaries, idx);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_add_secondary:
|
|
* @setting: the #NMSettingConnection
|
|
* @sec_uuid: the secondary connection UUID to add
|
|
*
|
|
* Adds a new secondary connetion UUID to the setting.
|
|
*
|
|
* Returns: %TRUE if the secondary connection UUID was added; %FALSE if the UUID
|
|
* was already present
|
|
*
|
|
* Since: 0.9.8
|
|
**/
|
|
gboolean
|
|
nm_setting_connection_add_secondary (NMSettingConnection *setting,
|
|
const char *sec_uuid)
|
|
{
|
|
NMSettingConnectionPrivate *priv;
|
|
GSList *iter;
|
|
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), FALSE);
|
|
g_return_val_if_fail (sec_uuid != NULL, FALSE);
|
|
g_return_val_if_fail (sec_uuid[0] != '\0', FALSE);
|
|
|
|
priv = NM_SETTING_CONNECTION_GET_PRIVATE (setting);
|
|
for (iter = priv->secondaries; iter; iter = g_slist_next (iter)) {
|
|
if (!strcmp (sec_uuid, (char *) iter->data))
|
|
return FALSE;
|
|
}
|
|
|
|
priv->secondaries = g_slist_append (priv->secondaries, g_strdup (sec_uuid));
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_CONNECTION_SECONDARIES);
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_remove_secondary:
|
|
* @setting: the #NMSettingConnection
|
|
* @idx: index number of the secondary connection UUID
|
|
*
|
|
* Removes the secondary coonnection UUID at index @idx.
|
|
*
|
|
* Since: 0.9.8
|
|
**/
|
|
void
|
|
nm_setting_connection_remove_secondary (NMSettingConnection *setting, guint32 idx)
|
|
{
|
|
NMSettingConnectionPrivate *priv;
|
|
GSList *elt;
|
|
|
|
g_return_if_fail (NM_IS_SETTING_CONNECTION (setting));
|
|
|
|
priv = NM_SETTING_CONNECTION_GET_PRIVATE (setting);
|
|
elt = g_slist_nth (priv->secondaries, idx);
|
|
g_return_if_fail (elt != NULL);
|
|
|
|
g_free (elt->data);
|
|
priv->secondaries = g_slist_delete_link (priv->secondaries, elt);
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_CONNECTION_SECONDARIES);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_connection_get_gateway_ping_timeout:
|
|
* @setting: the #NMSettingConnection
|
|
*
|
|
* Returns: the value contained in the #NMSettingConnection:gateway-ping-timeout
|
|
* property.
|
|
*
|
|
* Since: 0.9.10
|
|
**/
|
|
guint32
|
|
nm_setting_connection_get_gateway_ping_timeout (NMSettingConnection *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_CONNECTION (setting), 0);
|
|
|
|
return NM_SETTING_CONNECTION_GET_PRIVATE (setting)->gateway_ping_timeout;
|
|
}
|
|
|
|
|
|
static gboolean
|
|
verify (NMSetting *setting, GSList *all_settings, GError **error)
|
|
{
|
|
NMSettingConnectionPrivate *priv = NM_SETTING_CONNECTION_GET_PRIVATE (setting);
|
|
gboolean is_slave;
|
|
GSList *iter;
|
|
|
|
if (!priv->id) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_CONNECTION_ERROR,
|
|
NM_SETTING_CONNECTION_ERROR_MISSING_PROPERTY,
|
|
_("property is missing"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_CONNECTION_SETTING_NAME, NM_SETTING_CONNECTION_ID);
|
|
return FALSE;
|
|
} else if (!strlen (priv->id)) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_CONNECTION_ERROR,
|
|
NM_SETTING_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("property is empty"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_CONNECTION_SETTING_NAME, NM_SETTING_CONNECTION_ID);
|
|
return FALSE;
|
|
}
|
|
|
|
if (!priv->uuid) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_CONNECTION_ERROR,
|
|
NM_SETTING_CONNECTION_ERROR_MISSING_PROPERTY,
|
|
_("property is missing"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_CONNECTION_SETTING_NAME, NM_SETTING_CONNECTION_UUID);
|
|
return FALSE;
|
|
} else if (!nm_utils_is_uuid (priv->uuid)) {
|
|
g_set_error (error,
|
|
NM_SETTING_CONNECTION_ERROR,
|
|
NM_SETTING_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' is not a valid UUID"),
|
|
priv->uuid);
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_CONNECTION_SETTING_NAME, NM_SETTING_CONNECTION_UUID);
|
|
return FALSE;
|
|
}
|
|
|
|
/* If the connection has a virtual interface name, it must match
|
|
* the connection setting's interface name.
|
|
*/
|
|
for (iter = all_settings; iter; iter = iter->next) {
|
|
const char *virtual_iface;
|
|
|
|
virtual_iface = nm_setting_get_virtual_iface_name (iter->data);
|
|
if (virtual_iface) {
|
|
if (priv->interface_name) {
|
|
if (strcmp (priv->interface_name, virtual_iface) != 0) {
|
|
g_set_error (error,
|
|
NM_SETTING_CONNECTION_ERROR,
|
|
NM_SETTING_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' doesn't match the virtual interface name '%s'"),
|
|
priv->interface_name, virtual_iface);
|
|
g_prefix_error (error, "%s.%s: ",
|
|
NM_SETTING_CONNECTION_SETTING_NAME,
|
|
NM_SETTING_CONNECTION_INTERFACE_NAME);
|
|
return FALSE;
|
|
}
|
|
} else
|
|
priv->interface_name = g_strdup (virtual_iface);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (priv->interface_name) {
|
|
if (!nm_utils_iface_valid_name (priv->interface_name)) {
|
|
g_set_error (error,
|
|
NM_SETTING_CONNECTION_ERROR,
|
|
NM_SETTING_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("'%s' is not a valid interface name"),
|
|
priv->interface_name);
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_CONNECTION_SETTING_NAME, NM_SETTING_CONNECTION_INTERFACE_NAME);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (!priv->type) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_CONNECTION_ERROR,
|
|
NM_SETTING_CONNECTION_ERROR_MISSING_PROPERTY,
|
|
_("property is missing"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_CONNECTION_SETTING_NAME, NM_SETTING_CONNECTION_TYPE);
|
|
return FALSE;
|
|
} else if (!strlen (priv->type)) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_CONNECTION_ERROR,
|
|
NM_SETTING_CONNECTION_ERROR_INVALID_PROPERTY,
|
|
_("property is empty"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_CONNECTION_SETTING_NAME, NM_SETTING_CONNECTION_TYPE);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Make sure the corresponding 'type' item is present */
|
|
if (all_settings && !nm_setting_find_in_list (all_settings, priv->type)) {
|
|
g_set_error (error,
|
|
NM_SETTING_CONNECTION_ERROR,
|
|
NM_SETTING_CONNECTION_ERROR_TYPE_SETTING_NOT_FOUND,
|
|
_("requires presence of '%s' setting in the connection"),
|
|
priv->type);
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_CONNECTION_SETTING_NAME, NM_SETTING_CONNECTION_TYPE);
|
|
return FALSE;
|
|
}
|
|
|
|
is_slave = ( !g_strcmp0 (priv->slave_type, NM_SETTING_BOND_SETTING_NAME)
|
|
|| !g_strcmp0 (priv->slave_type, NM_SETTING_BRIDGE_SETTING_NAME)
|
|
|| !g_strcmp0 (priv->slave_type, NM_SETTING_TEAM_SETTING_NAME));
|
|
|
|
/* Bond/bridge/team slaves are not allowed to have any IP configuration. */
|
|
if (is_slave) {
|
|
NMSettingIP4Config *s_ip4;
|
|
NMSettingIP6Config *s_ip6;
|
|
|
|
s_ip4 = NM_SETTING_IP4_CONFIG (nm_setting_find_in_list (all_settings, NM_SETTING_IP4_CONFIG_SETTING_NAME));
|
|
if (s_ip4) {
|
|
if (strcmp (nm_setting_ip4_config_get_method (s_ip4),
|
|
NM_SETTING_IP4_CONFIG_METHOD_DISABLED)) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_CONNECTION_ERROR,
|
|
NM_SETTING_CONNECTION_ERROR_IP_CONFIG_NOT_ALLOWED,
|
|
_("IPv4 configuration is not allowed for slave"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_CONNECTION_SETTING_NAME, NM_SETTING_CONNECTION_SLAVE_TYPE);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
s_ip6 = NM_SETTING_IP6_CONFIG (nm_setting_find_in_list (all_settings, NM_SETTING_IP6_CONFIG_SETTING_NAME));
|
|
if (s_ip6) {
|
|
if (strcmp (nm_setting_ip6_config_get_method (s_ip6),
|
|
NM_SETTING_IP6_CONFIG_METHOD_IGNORE)) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_CONNECTION_ERROR,
|
|
NM_SETTING_CONNECTION_ERROR_IP_CONFIG_NOT_ALLOWED,
|
|
_("IPv6 configuration is not allowed for slave"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_CONNECTION_SETTING_NAME, NM_SETTING_CONNECTION_SLAVE_TYPE);
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
compare_property (NMSetting *setting,
|
|
NMSetting *other,
|
|
const GParamSpec *prop_spec,
|
|
NMSettingCompareFlags flags)
|
|
{
|
|
/* Handle ignore ID */
|
|
if ( (flags & NM_SETTING_COMPARE_FLAG_IGNORE_ID)
|
|
&& g_strcmp0 (prop_spec->name, NM_SETTING_CONNECTION_ID) == 0)
|
|
return TRUE;
|
|
|
|
/* Otherwise chain up to parent to handle generic compare */
|
|
return NM_SETTING_CLASS (nm_setting_connection_parent_class)->compare_property (setting, other, prop_spec, flags);
|
|
}
|
|
|
|
static void
|
|
nm_setting_connection_init (NMSettingConnection *setting)
|
|
{
|
|
g_object_set (setting, NM_SETTING_NAME, NM_SETTING_CONNECTION_SETTING_NAME, NULL);
|
|
}
|
|
|
|
static void
|
|
finalize (GObject *object)
|
|
{
|
|
NMSettingConnectionPrivate *priv = NM_SETTING_CONNECTION_GET_PRIVATE (object);
|
|
|
|
g_free (priv->id);
|
|
g_free (priv->uuid);
|
|
g_free (priv->interface_name);
|
|
g_free (priv->type);
|
|
g_free (priv->zone);
|
|
g_free (priv->master);
|
|
g_free (priv->slave_type);
|
|
g_slist_free_full (priv->permissions, (GDestroyNotify) permission_free);
|
|
g_slist_free_full (priv->secondaries, g_free);
|
|
|
|
G_OBJECT_CLASS (nm_setting_connection_parent_class)->finalize (object);
|
|
}
|
|
|
|
static GSList *
|
|
perm_stringlist_to_permlist (GSList *strlist)
|
|
{
|
|
GSList *list = NULL, *iter;
|
|
|
|
for (iter = strlist; iter; iter = g_slist_next (iter)) {
|
|
Permission *p;
|
|
|
|
p = permission_new_from_str ((const char *) iter->data);
|
|
if (p)
|
|
list = g_slist_append (list, p);
|
|
}
|
|
|
|
return list;
|
|
}
|
|
|
|
static void
|
|
set_property (GObject *object, guint prop_id,
|
|
const GValue *value, GParamSpec *pspec)
|
|
{
|
|
NMSettingConnectionPrivate *priv = NM_SETTING_CONNECTION_GET_PRIVATE (object);
|
|
|
|
switch (prop_id) {
|
|
case PROP_ID:
|
|
g_free (priv->id);
|
|
priv->id = g_value_dup_string (value);
|
|
break;
|
|
case PROP_UUID:
|
|
g_free (priv->uuid);
|
|
priv->uuid = g_value_dup_string (value);
|
|
break;
|
|
case PROP_INTERFACE_NAME:
|
|
g_free (priv->interface_name);
|
|
priv->interface_name = g_value_dup_string (value);
|
|
break;
|
|
case PROP_TYPE:
|
|
g_free (priv->type);
|
|
priv->type = g_value_dup_string (value);
|
|
break;
|
|
case PROP_PERMISSIONS:
|
|
g_slist_free_full (priv->permissions, (GDestroyNotify) permission_free);
|
|
priv->permissions = perm_stringlist_to_permlist (g_value_get_boxed (value));
|
|
break;
|
|
case PROP_AUTOCONNECT:
|
|
priv->autoconnect = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_TIMESTAMP:
|
|
priv->timestamp = g_value_get_uint64 (value);
|
|
break;
|
|
case PROP_READ_ONLY:
|
|
priv->read_only = g_value_get_boolean (value);
|
|
break;
|
|
case PROP_ZONE:
|
|
g_free (priv->zone);
|
|
priv->zone = g_value_dup_string (value);
|
|
break;
|
|
case PROP_MASTER:
|
|
g_free (priv->master);
|
|
priv->master = g_value_dup_string (value);
|
|
break;
|
|
case PROP_SLAVE_TYPE:
|
|
g_free (priv->slave_type);
|
|
priv->slave_type = g_value_dup_string (value);
|
|
break;
|
|
case PROP_SECONDARIES:
|
|
g_slist_free_full (priv->secondaries, g_free);
|
|
priv->secondaries = g_value_dup_boxed (value);
|
|
break;
|
|
case PROP_GATEWAY_PING_TIMEOUT:
|
|
priv->gateway_ping_timeout = g_value_get_uint (value);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static GSList *
|
|
perm_permlist_to_stringlist (GSList *permlist)
|
|
{
|
|
GSList *list = NULL, *iter;
|
|
|
|
for (iter = permlist; iter; iter = g_slist_next (iter))
|
|
list = g_slist_append (list, permission_to_string ((Permission *) iter->data));
|
|
return list;
|
|
}
|
|
|
|
static void
|
|
get_property (GObject *object, guint prop_id,
|
|
GValue *value, GParamSpec *pspec)
|
|
{
|
|
NMSettingConnection *setting = NM_SETTING_CONNECTION (object);
|
|
NMSettingConnectionPrivate *priv = NM_SETTING_CONNECTION_GET_PRIVATE (setting);
|
|
|
|
switch (prop_id) {
|
|
case PROP_ID:
|
|
g_value_set_string (value, nm_setting_connection_get_id (setting));
|
|
break;
|
|
case PROP_UUID:
|
|
g_value_set_string (value, nm_setting_connection_get_uuid (setting));
|
|
break;
|
|
case PROP_INTERFACE_NAME:
|
|
g_value_set_string (value, nm_setting_connection_get_interface_name (setting));
|
|
break;
|
|
case PROP_TYPE:
|
|
g_value_set_string (value, nm_setting_connection_get_connection_type (setting));
|
|
break;
|
|
case PROP_PERMISSIONS:
|
|
g_value_take_boxed (value, perm_permlist_to_stringlist (priv->permissions));
|
|
break;
|
|
case PROP_AUTOCONNECT:
|
|
g_value_set_boolean (value, nm_setting_connection_get_autoconnect (setting));
|
|
break;
|
|
case PROP_TIMESTAMP:
|
|
g_value_set_uint64 (value, nm_setting_connection_get_timestamp (setting));
|
|
break;
|
|
case PROP_READ_ONLY:
|
|
g_value_set_boolean (value, nm_setting_connection_get_read_only (setting));
|
|
break;
|
|
case PROP_ZONE:
|
|
g_value_set_string (value, nm_setting_connection_get_zone (setting));
|
|
break;
|
|
case PROP_MASTER:
|
|
g_value_set_string (value, nm_setting_connection_get_master (setting));
|
|
break;
|
|
case PROP_SLAVE_TYPE:
|
|
g_value_set_string (value, nm_setting_connection_get_slave_type (setting));
|
|
break;
|
|
case PROP_SECONDARIES:
|
|
g_value_set_boxed (value, priv->secondaries);
|
|
break;
|
|
case PROP_GATEWAY_PING_TIMEOUT:
|
|
g_value_set_uint (value, priv->gateway_ping_timeout);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
nm_setting_connection_class_init (NMSettingConnectionClass *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 (NMSettingConnectionPrivate));
|
|
|
|
/* virtual methods */
|
|
object_class->set_property = set_property;
|
|
object_class->get_property = get_property;
|
|
object_class->finalize = finalize;
|
|
parent_class->verify = verify;
|
|
parent_class->compare_property = compare_property;
|
|
|
|
/* Properties */
|
|
|
|
/**
|
|
* NMSettingConnection:id:
|
|
*
|
|
* A human readable unique idenfier for the connection, like "Work WiFi" or
|
|
* "T-Mobile 3G".
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_ID,
|
|
g_param_spec_string (NM_SETTING_CONNECTION_ID,
|
|
"ID",
|
|
"User-readable connection identifier/name. Must be "
|
|
"one or more characters and may change over the lifetime "
|
|
"of the connection if the user decides to rename it.",
|
|
NULL,
|
|
G_PARAM_READWRITE | NM_SETTING_PARAM_SERIALIZE | NM_SETTING_PARAM_FUZZY_IGNORE));
|
|
|
|
/**
|
|
* NMSettingConnection:uuid:
|
|
*
|
|
* A universally unique idenfier for the connection, for example generated
|
|
* with libuuid. Should be assigned when the connection is created, and
|
|
* never changed as long as the connection still applies to the same
|
|
* network. For example, should not be changed when the
|
|
* #NMSettingConnection:id or #NMSettingIP4Config changes, but might need
|
|
* to be re-created when the WiFi SSID, mobile broadband network provider,
|
|
* or #NMSettingConnection:type changes.
|
|
*
|
|
* The UUID must be in the format '2815492f-7e56-435e-b2e9-246bd7cdc664'
|
|
* (ie, contains only hexadecimal characters and '-'). A suitable UUID may
|
|
* be generated by nm_utils_uuid_generate() or
|
|
* nm_utils_uuid_generate_from_string().
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_UUID,
|
|
g_param_spec_string (NM_SETTING_CONNECTION_UUID,
|
|
"UUID",
|
|
"Universally unique connection identifier. Must be "
|
|
"in the format '2815492f-7e56-435e-b2e9-246bd7cdc664' "
|
|
"(ie, contains only hexadecimal characters and '-'). "
|
|
"The UUID should be assigned when the connection is "
|
|
"created and never changed as long as the connection "
|
|
"still applies to the same network. For example, "
|
|
"it should not be changed when the user changes the "
|
|
"connection's 'id', but should be recreated when the "
|
|
"WiFi SSID, mobile broadband network provider, or the "
|
|
"connection type changes.",
|
|
NULL,
|
|
G_PARAM_READWRITE | NM_SETTING_PARAM_SERIALIZE | NM_SETTING_PARAM_FUZZY_IGNORE));
|
|
|
|
/**
|
|
* NMSettingConnection:interface-name:
|
|
*
|
|
* The name of the network interface this connection is bound to. If
|
|
* not set, then the connection can be attached to any interface of the
|
|
* appropriate type (subject to restrictions imposed by other settings).
|
|
*
|
|
* For connection types where interface names cannot easily be
|
|
* made persistent (e.g. mobile broadband or USB ethernet), this
|
|
* property should not be used. Setting this property restricts
|
|
* the interfaces a connection can be used with, and if interface
|
|
* names change or are reordered the connection may be applied to
|
|
* the wrong interface.
|
|
*
|
|
* Since: 0.9.10
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_INTERFACE_NAME,
|
|
g_param_spec_string (NM_SETTING_CONNECTION_INTERFACE_NAME,
|
|
"Interface name",
|
|
"Interface name this connection is bound to. "
|
|
"If not set, then the connection can be attached "
|
|
"to any interface of the appropriate type (subject "
|
|
"to restrictions imposed by other settings). For "
|
|
"connection types where interface names cannot easily "
|
|
"be made persistent (e.g. mobile broadband or USB "
|
|
"ethernet), this property should not be used. Setting "
|
|
"this property restricts the interfaces a connection can "
|
|
"be used with, and if interface names change or are "
|
|
"reordered the connection may be applied to the wrong "
|
|
"interface.",
|
|
NULL,
|
|
G_PARAM_READWRITE | NM_SETTING_PARAM_SERIALIZE));
|
|
|
|
/**
|
|
* NMSettingConnection:type:
|
|
*
|
|
* The general hardware type of the device used for the network connection,
|
|
* contains the name of the #NMSetting object that describes that hardware
|
|
* type's parameters. For example, for WiFi devices, the name of the
|
|
* #NMSettingWireless setting.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_TYPE,
|
|
g_param_spec_string (NM_SETTING_CONNECTION_TYPE,
|
|
"Type",
|
|
"Base type of the connection. For hardware-dependent "
|
|
"connections, should contain the setting name of the "
|
|
"hardware-type specific setting (ie, '802-3-ethernet' "
|
|
"or '802-11-wireless' or 'bluetooth', etc), and for "
|
|
"non-hardware dependent connections like VPN or "
|
|
"otherwise, should contain the setting name of that "
|
|
"setting type (ie, 'vpn' or 'bridge', etc).",
|
|
NULL,
|
|
G_PARAM_READWRITE | NM_SETTING_PARAM_SERIALIZE));
|
|
|
|
/**
|
|
* NMSettingConnection:permissions:
|
|
*
|
|
* An array of strings defining what access a given user has to this
|
|
* connection. If this is NULL or empty, all users are allowed to access
|
|
* this connection. Otherwise a user is allowed to access this connection
|
|
* if and only if they are in this list. Each entry is of the form
|
|
* "[type]:[id]:[reserved]", for example:
|
|
*
|
|
* user:dcbw:blah
|
|
*
|
|
* At this time only the 'user' [type] is allowed. Any other values are
|
|
* ignored and reserved for future use. [id] is the username that this
|
|
* permission refers to, which may not contain the ':' character. Any
|
|
* [reserved] information present must be ignored and is reserved for
|
|
* future use. All of [type], [id], and [reserved] must be valid UTF-8.
|
|
*/
|
|
g_object_class_install_property
|
|
(object_class, PROP_PERMISSIONS,
|
|
_nm_param_spec_specialized (NM_SETTING_CONNECTION_PERMISSIONS,
|
|
"Permissions",
|
|
"An array of strings defining what access a given "
|
|
"user has to this connection. If this is NULL or "
|
|
"empty, all users are allowed to access this "
|
|
"connection. Otherwise a user is allowed to access "
|
|
"this connection if and only if they are in this "
|
|
"array. Each entry is of the form "
|
|
"\"[type]:[id]:[reserved]\", for example: "
|
|
"\"user:dcbw:blah\" At this time only the 'user' "
|
|
"[type] is allowed. Any other values are ignored and "
|
|
"reserved for future use. [id] is the username that "
|
|
"this permission refers to, which may not contain the "
|
|
"':' character. Any [reserved] information (if "
|
|
"present) must be ignored and is reserved for future "
|
|
"use. All of [type], [id], and [reserved] must be "
|
|
"valid UTF-8.",
|
|
DBUS_TYPE_G_LIST_OF_STRING,
|
|
G_PARAM_READWRITE | NM_SETTING_PARAM_SERIALIZE));
|
|
|
|
/**
|
|
* NMSettingConnection:autoconnect:
|
|
*
|
|
* Whether or not the connection should be automatically connected by
|
|
* NetworkManager when the resources for the connection are available.
|
|
* %TRUE to automatically activate the connection, %FALSE to require manual
|
|
* intervention to activate the connection. Defaults to %TRUE.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_AUTOCONNECT,
|
|
g_param_spec_boolean (NM_SETTING_CONNECTION_AUTOCONNECT,
|
|
"Autoconnect",
|
|
"If TRUE, NetworkManager will activate this connection "
|
|
"when its network resources are available. If FALSE, "
|
|
"the connection must be manually activated by the user "
|
|
"or some other mechanism.",
|
|
TRUE,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT | NM_SETTING_PARAM_SERIALIZE | NM_SETTING_PARAM_FUZZY_IGNORE));
|
|
|
|
/**
|
|
* NMSettingConnection:timestamp:
|
|
*
|
|
* The time, in seconds since the Unix Epoch, that the connection was last
|
|
* _successfully_ fully activated.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_TIMESTAMP,
|
|
g_param_spec_uint64 (NM_SETTING_CONNECTION_TIMESTAMP,
|
|
"Timestamp",
|
|
"Timestamp (in seconds since the Unix Epoch) that the "
|
|
"connection was last successfully activated. NetworkManager "
|
|
"updates the connection timestamp periodically when the "
|
|
"connection is active to ensure that an active connection "
|
|
"has the latest timestamp. The property is only meant for "
|
|
"reading (changes to this property will not be preserved).",
|
|
0, G_MAXUINT64, 0,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT | NM_SETTING_PARAM_SERIALIZE | NM_SETTING_PARAM_FUZZY_IGNORE));
|
|
|
|
/**
|
|
* NMSettingConnection:read-only:
|
|
*
|
|
* %FALSE if the connection can be modified using the provided settings
|
|
* service's D-Bus interface with the right privileges, or %TRUE
|
|
* if the connection is read-only and cannot be modified.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_READ_ONLY,
|
|
g_param_spec_boolean (NM_SETTING_CONNECTION_READ_ONLY,
|
|
"Read-Only",
|
|
"If TRUE, the connection is read-only and cannot be "
|
|
"changed by the user or any other mechanism. This is "
|
|
"normally set for system connections whose plugin "
|
|
"cannot yet write updated connections back out.",
|
|
FALSE,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT | NM_SETTING_PARAM_SERIALIZE | NM_SETTING_PARAM_FUZZY_IGNORE));
|
|
|
|
/**
|
|
* NMSettingConnection:zone:
|
|
*
|
|
* The trust level of a the connection.
|
|
* Free form case-insensitive string (for example "Home", "Work", "Public").
|
|
* NULL or unspecified zone means the connection will be placed in the
|
|
* default zone as defined by the firewall.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_ZONE,
|
|
g_param_spec_string (NM_SETTING_CONNECTION_ZONE,
|
|
"Zone",
|
|
"The trust level of a the connection."
|
|
"Free form case-insensitive string (for example "
|
|
"\"Home\", \"Work\", \"Public\"). NULL or "
|
|
"unspecified zone means the connection will be "
|
|
"placed in the default zone as defined by the "
|
|
"firewall.",
|
|
NULL,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT | NM_SETTING_PARAM_SERIALIZE | NM_SETTING_PARAM_FUZZY_IGNORE));
|
|
|
|
/**
|
|
* NMSettingConnection:master:
|
|
*
|
|
* Interface name of the master device or UUID of the master connection.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_MASTER,
|
|
g_param_spec_string (NM_SETTING_CONNECTION_MASTER,
|
|
"Master",
|
|
"Interface name of the master device or UUID of "
|
|
"the master connection",
|
|
NULL,
|
|
G_PARAM_READWRITE | NM_SETTING_PARAM_SERIALIZE | NM_SETTING_PARAM_FUZZY_IGNORE));
|
|
|
|
/**
|
|
* NMSettingConnection:slave-type:
|
|
*
|
|
* Setting name describing the type of slave device (ie
|
|
* #NM_SETTING_BOND_SETTING_NAME) or NULL if this connection is not a slave.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_SLAVE_TYPE,
|
|
g_param_spec_string (NM_SETTING_CONNECTION_SLAVE_TYPE,
|
|
"Slave-Type",
|
|
"Setting name describing the type of slave "
|
|
"this connection is (ie, 'bond') or NULL if this "
|
|
"connection is not a slave.",
|
|
NULL,
|
|
G_PARAM_READWRITE | NM_SETTING_PARAM_SERIALIZE | NM_SETTING_PARAM_FUZZY_IGNORE));
|
|
|
|
/**
|
|
* NMSettingConnection:secondaries:
|
|
*
|
|
* List of connection UUIDs that should be activated when the base connection
|
|
* itself is activated.
|
|
*
|
|
* Since: 0.9.8
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_SECONDARIES,
|
|
_nm_param_spec_specialized (NM_SETTING_CONNECTION_SECONDARIES,
|
|
"Secondaries",
|
|
"List of connection UUIDs that should be activated "
|
|
"when the base connection itself is activated.",
|
|
DBUS_TYPE_G_LIST_OF_STRING,
|
|
G_PARAM_READWRITE | NM_SETTING_PARAM_SERIALIZE | NM_SETTING_PARAM_FUZZY_IGNORE));
|
|
|
|
/**
|
|
* NMSettingConnection:gateway-ping-timeout:
|
|
*
|
|
* If greater than zero, delay success of IP addressing until either the
|
|
* timeout is reached, or an IP gateway replies to a ping.
|
|
*
|
|
* Since: 0.9.10
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_GATEWAY_PING_TIMEOUT,
|
|
g_param_spec_uint (NM_SETTING_CONNECTION_GATEWAY_PING_TIMEOUT,
|
|
"Gateway Ping Timeout",
|
|
"If greater than zero, delay success of IP "
|
|
"addressing until either the timeout is reached, or "
|
|
"an IP gateway replies to a ping.",
|
|
0, 30, 0,
|
|
G_PARAM_READWRITE | G_PARAM_CONSTRUCT | NM_SETTING_PARAM_SERIALIZE));
|
|
}
|