/* SPDX-License-Identifier: LGPL-2.1-or-later */

/*

 * Copyright (C) 2007 - 2013 Red Hat, Inc.

 * Copyright (C) 2007 - 2008 Novell, Inc.

 */

#include "libnm-core/nm-default-libnm-core.h"

#include "nm-setting-connection.h"

#include "nm-libnm-core-intern/nm-common-macros.h"

#include "nm-utils.h"

#include "nm-utils-private.h"

#include "nm-core-enum-types.h"

#include "nm-connection-private.h"

#include "nm-setting-bond.h"

#include "nm-setting-bridge.h"

#include "nm-setting-team.h"

#include "nm-setting-vlan.h"

#include "systemd/nm-sd-utils-shared.h"

/**

 * SECTION:nm-setting-connection

 * @short_description: Describes general connection properties

 *

 * 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.

 **/

/*****************************************************************************/

typedef enum _nm_packed {

    PERM_TYPE_INVALID,

    PERM_TYPE_USER,

} PermType;

typedef struct {

    PermType ptype;

    char *   item;

} Permission;

NM_GOBJECT_PROPERTIES_DEFINE(NMSettingConnection,

                             PROP_ID,

                             PROP_UUID,

                             PROP_INTERFACE_NAME,

                             PROP_TYPE,

                             PROP_PERMISSIONS,

                             PROP_AUTOCONNECT,

                             PROP_AUTOCONNECT_PRIORITY,

                             PROP_AUTOCONNECT_RETRIES,

                             PROP_MULTI_CONNECT,

                             PROP_TIMESTAMP,

                             PROP_READ_ONLY,

                             PROP_ZONE,

                             PROP_MASTER,

                             PROP_SLAVE_TYPE,

                             PROP_AUTOCONNECT_SLAVES,

                             PROP_SECONDARIES,

                             PROP_GATEWAY_PING_TIMEOUT,

                             PROP_METERED,

                             PROP_LLDP,

                             PROP_MDNS,

                             PROP_LLMNR,

                             PROP_STABLE_ID,

                             PROP_AUTH_RETRIES,

                             PROP_WAIT_DEVICE_TIMEOUT,

                             PROP_MUD_URL, );

typedef struct {

    GArray *permissions;

    GSList *secondaries; /* secondary connections to activate with the base connection */

    char *  id;

    char *  uuid;

    char *  stable_id;

    char *  interface_name;

    char *  type;

    char *  master;

    char *  slave_type;

    char *  zone;

    char *  mud_url;

    guint64 timestamp;

    int     autoconnect_priority;

    int     autoconnect_retries;

    int     multi_connect;

    int     auth_retries;

    int     mdns;

    int     llmnr;

    int     wait_device_timeout;

    guint   gateway_ping_timeout;

    NMSettingConnectionAutoconnectSlaves autoconnect_slaves;

    NMMetered                            metered;

    NMSettingConnectionLldp              lldp;

    bool                                 read_only : 1;

    bool                                 autoconnect : 1;

} NMSettingConnectionPrivate;

G_DEFINE_TYPE(NMSettingConnection, nm_setting_connection, NM_TYPE_SETTING)

#define NM_SETTING_CONNECTION_GET_PRIVATE(o) \

    (G_TYPE_INSTANCE_GET_PRIVATE((o), NM_TYPE_SETTING_CONNECTION, NMSettingConnectionPrivate))

/*****************************************************************************/

static void

_permission_set_stale(Permission *permission, PermType ptype, char *item_take)

{

    nm_assert(permission);

    nm_assert(NM_IN_SET(ptype, PERM_TYPE_INVALID, PERM_TYPE_USER));

    nm_assert(ptype != PERM_TYPE_USER

              || nm_settings_connection_validate_permission_user(item_take, -1));

    /* we don't inspect (clear) permission before setting. It takes a

     * stale instance. */

    *permission = (Permission){

        .ptype = ptype,

        .item  = item_take,

    };

}

static void

_permission_clear_stale(Permission *permission)

{

    g_free(permission->item);

    /* We leave the permission instance with dangling pointers.

     * It is "stale". */

}

static gboolean

_permission_set_stale_parse(Permission *permission, const char *str)

{

    const char *str0 = str;

    const char *last_colon;

    gsize       ulen;

    nm_assert(str);

    if (!str)

        goto invalid;

    if (!NM_STR_HAS_PREFIX(str, NM_SETTINGS_CONNECTION_PERMISSION_USER_PREFIX))

        goto invalid;

    str += NM_STRLEN(NM_SETTINGS_CONNECTION_PERMISSION_USER_PREFIX);

    last_colon = strrchr(str, ':');

    if (last_colon) {

        /* Reject :[detail] for now */

        if (last_colon[1] != '\0')

            goto invalid;

        ulen = last_colon - str;

    } else

        ulen = strlen(str);

    if (!nm_settings_connection_validate_permission_user(str, ulen))

        goto invalid;

    /* Yay, valid... create the new permission */

    if (permission)

        _permission_set_stale(permission, PERM_TYPE_USER, g_strndup(str, ulen));

    return TRUE;

invalid:

    if (permission)

        _permission_set_stale(permission, PERM_TYPE_INVALID, g_strdup(str0));

    return FALSE;

}

static char *

_permission_to_string(Permission *permission)

{

    nm_assert(permission);

    switch (permission->ptype) {

    case PERM_TYPE_USER:

        return g_strdup_printf(NM_SETTINGS_CONNECTION_PERMISSION_USER_PREFIX "%s:",

                               permission->item);

    case PERM_TYPE_INVALID:

        nm_assert(permission->item);

        return g_strdup(permission->item);

    }

    nm_assert_not_reached();

    return g_strdup(permission->item ?: "");

}

/*****************************************************************************/

/**

 * 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_stable_id:

 * @setting: the #NMSettingConnection

 *

 * Returns the #NMSettingConnection:stable_id property of the connection.

 *

 * Returns: the stable-id for the connection

 *

 * Since: 1.4

 **/

const char *

nm_setting_connection_get_stable_id(NMSettingConnection *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_CONNECTION(setting), NULL);

    return NM_SETTING_CONNECTION_GET_PRIVATE(setting)->stable_id;

}

/**

 * nm_setting_connection_get_interface_name:

 * @setting: the #NMSettingConnection

 *

 * Returns the #NMSettingConnection:interface-name property of the connection.

 *

 * Returns: the connection's interface name

 **/

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 entries in the #NMSettingConnection:permissions

 * property of this setting.

 *

 * Returns: the number of permissions entries

 */

guint32

nm_setting_connection_get_num_permissions(NMSettingConnection *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_CONNECTION(setting), 0);

    return nm_g_array_len(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. This is currently always "user",

 *   unless the entry is invalid, in which case it returns "invalid".

 * @out_pitem: on return, the permission item (formatted according 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 *                permission;

    g_return_val_if_fail(NM_IS_SETTING_CONNECTION(setting), FALSE);

    priv = NM_SETTING_CONNECTION_GET_PRIVATE(setting);

    g_return_val_if_fail(idx < nm_g_array_len(priv->permissions), FALSE);

    permission = &g_array_index(priv->permissions, Permission, idx);

    switch (permission->ptype) {

    case PERM_TYPE_USER:

        NM_SET_OUT(out_ptype, NM_SETTINGS_CONNECTION_PERMISSION_USER);

        NM_SET_OUT(out_pitem, permission->item);

        NM_SET_OUT(out_detail, NULL);

        return TRUE;

    case PERM_TYPE_INVALID:

        goto invalid;

    }

    nm_assert_not_reached();

invalid:

    NM_SET_OUT(out_ptype, "invalid");

    NM_SET_OUT(out_pitem, permission->item);

    NM_SET_OUT(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;

    guint                       i;

    g_return_val_if_fail(NM_IS_SETTING_CONNECTION(setting), FALSE);

    g_return_val_if_fail(uname != NULL, FALSE);

    priv = NM_SETTING_CONNECTION_GET_PRIVATE(setting);

    if (nm_g_array_len(priv->permissions) == 0) {

        /* If no permissions, visible to all */

        return TRUE;

    }

    for (i = 0; i < priv->permissions->len; i++) {

        const Permission *permission = &g_array_index(priv->permissions, Permission, i);

        if (permission->ptype == PERM_TYPE_USER && nm_streq(permission->item, uname))

            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.

 * If the permission was already present in the list, it will not be added

 * a second time but %TRUE will be returned. Note that before 1.28, in this

 * case %FALSE would be returned.

 */

gboolean

nm_setting_connection_add_permission(NMSettingConnection *setting,

                                     const char *         ptype,

                                     const char *         pitem,

                                     const char *         detail)

{

    NMSettingConnectionPrivate *priv;

    guint                       i;

    g_return_val_if_fail(NM_IS_SETTING_CONNECTION(setting), FALSE);

    g_return_val_if_fail(ptype, FALSE);

    g_return_val_if_fail(pitem, FALSE);

    if (!nm_streq0(ptype, NM_SETTINGS_CONNECTION_PERMISSION_USER))

        return FALSE;

    if (!nm_settings_connection_validate_permission_user(pitem, -1))

        return FALSE;

    if (detail)

        return FALSE;

    priv = NM_SETTING_CONNECTION_GET_PRIVATE(setting);

    if (!priv->permissions) {

        priv->permissions = g_array_sized_new(FALSE, FALSE, sizeof(Permission), 1);

        g_array_set_clear_func(priv->permissions, (GDestroyNotify) _permission_clear_stale);

    }

    for (i = 0; i < priv->permissions->len; i++) {

        const Permission *permission = &g_array_index(priv->permissions, Permission, i);

        if (permission->ptype == PERM_TYPE_USER && nm_streq(permission->item, pitem))

            return TRUE;

    }

    _permission_set_stale(nm_g_array_append_new(priv->permissions, Permission),

                          PERM_TYPE_USER,

                          g_strdup(pitem));

    _notify(setting, PROP_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;

    g_return_if_fail(NM_IS_SETTING_CONNECTION(setting));

    priv = NM_SETTING_CONNECTION_GET_PRIVATE(setting);

    g_return_if_fail(idx < nm_g_array_len(priv->permissions));

    g_array_remove_index(priv->permissions, idx);

    _notify(setting, PROP_PERMISSIONS);

}

/**

 * nm_setting_connection_remove_permission_by_value:

 * @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

 *

 * Removes the permission from the connection.

 * 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 found and removed; %FALSE if it was not.

 */

gboolean

nm_setting_connection_remove_permission_by_value(NMSettingConnection *setting,

                                                 const char *         ptype,

                                                 const char *         pitem,

                                                 const char *         detail)

{

    NMSettingConnectionPrivate *priv;

    guint                       i;

    g_return_val_if_fail(NM_IS_SETTING_CONNECTION(setting), FALSE);

    g_return_val_if_fail(ptype, FALSE);

    g_return_val_if_fail(pitem, FALSE);

    if (!nm_streq0(ptype, NM_SETTINGS_CONNECTION_PERMISSION_USER))

        return FALSE;

    if (detail)

        return FALSE;

    priv = NM_SETTING_CONNECTION_GET_PRIVATE(setting);

    if (priv->permissions) {

        for (i = 0; i < priv->permissions->len; i++) {

            const Permission *permission = &g_array_index(priv->permissions, Permission, i);

            if (permission->ptype == PERM_TYPE_USER && nm_streq(permission->item, pitem)) {

                g_array_remove_index(priv->permissions, i);

                _notify(setting, PROP_PERMISSIONS);

                return TRUE;

            }

        }

    }

    return FALSE;

}

/**

 * 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_autoconnect_priority:

 * @setting: the #NMSettingConnection

 *

 * Returns the #NMSettingConnection:autoconnect-priority property of the connection.

 * The higher number, the higher priority.

 *

 * Returns: the connection's autoconnect priority

 **/

int

nm_setting_connection_get_autoconnect_priority(NMSettingConnection *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_CONNECTION(setting), 0);

    return NM_SETTING_CONNECTION_GET_PRIVATE(setting)->autoconnect_priority;

}

/**

 * nm_setting_connection_get_autoconnect_retries:

 * @setting: the #NMSettingConnection

 *

 * Returns the #NMSettingConnection:autoconnect-retries property of the connection.

 * Zero means infinite, -1 means the global default value.

 *

 * Returns: the connection's autoconnect retries

 *

 * Since: 1.6

 **/

int

nm_setting_connection_get_autoconnect_retries(NMSettingConnection *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_CONNECTION(setting), -1);

    return NM_SETTING_CONNECTION_GET_PRIVATE(setting)->autoconnect_retries;

}

/**

 * nm_setting_connection_get_multi_connect:

 * @setting: the #NMSettingConnection

 *

 * Returns: the #NMSettingConnection:multi-connect property of the connection.

 *

 * Since: 1.14

 **/

NMConnectionMultiConnect

nm_setting_connection_get_multi_connect(NMSettingConnection *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_CONNECTION(setting), -1);

    return (NMConnectionMultiConnect) NM_SETTING_CONNECTION_GET_PRIVATE(setting)->multi_connect;

}

/**

 * nm_setting_connection_get_auth_retries:

 * @setting: the #NMSettingConnection

 *

 * Returns the value contained in the #NMSettingConnection:auth-retries property.

 *

 * Returns: the configured authentication retries. Zero means

 * infinity and -1 means a global default value.

 *

 * Since: 1.10

 **/

int

nm_setting_connection_get_auth_retries(NMSettingConnection *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_CONNECTION(setting), -1);

    return NM_SETTING_CONNECTION_GET_PRIVATE(setting)->auth_retries;

}

/**

 * 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;

}

static GVariant *

_to_dbus_fcn_timestamp(const NMSettInfoSetting *               sett_info,

                       guint                                   property_idx,

                       NMConnection *                          connection,

                       NMSetting *                             setting,

                       NMConnectionSerializationFlags          flags,

                       const NMConnectionSerializationOptions *options)

{

    guint64 v;

    v = options && options->timestamp.has ? options->timestamp.val

                                          : NM_SETTING_CONNECTION_GET_PRIVATE(setting)->timestamp;

    if (v == 0u)

        return NULL;

    return g_variant_new_uint64(v);

}

/**

 * 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_wait_device_timeout:

 * @setting: the #NMSettingConnection

 *

 * Returns: the %NM_SETTING_CONNECTION_WAIT_DEVICE_TIMEOUT property with

 *   the timeout in milliseconds. -1 is the default.

 *

 * Since: 1.20

 */

gint32

nm_setting_connection_get_wait_device_timeout(NMSettingConnection *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_CONNECTION(setting), -1);

    return NM_SETTING_CONNECTION_GET_PRIVATE(setting)->wait_device_timeout;

}

/**

 * nm_setting_connection_get_autoconnect_slaves:

 * @setting: the #NMSettingConnection

 *

 * Returns the #NMSettingConnection:autoconnect-slaves property of the connection.

 *

 * Returns: whether slaves of the connection should be activated together

 *          with the connection.

 *

 * Since: 1.2

 **/

NMSettingConnectionAutoconnectSlaves

nm_setting_connection_get_autoconnect_slaves(NMSettingConnection *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_CONNECTION(setting),

                         NM_SETTING_CONNECTION_AUTOCONNECT_SLAVES_DEFAULT);

    return NM_SETTING_CONNECTION_GET_PRIVATE(setting)->autoconnect_slaves;

}

/**

 * nm_setting_connection_get_num_secondaries:

 * @setting: the #NMSettingConnection

 *

 * Returns: the number of configured secondary connection UUIDs

 **/

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

 **/

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_get_mud_url:

 * @setting: the #NMSettingConnection

 *

 * Returns the value contained in the #NMSettingConnection:mud-url

 * property.

 *

 * Since: 1.26

 **/

const char *

nm_setting_connection_get_mud_url(NMSettingConnection *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_CONNECTION(setting), NULL);

    return NM_SETTING_CONNECTION_GET_PRIVATE(setting)->mud_url;

}

/**

 * nm_setting_connection_add_secondary:

 * @setting: the #NMSettingConnection

 * @sec_uuid: the secondary connection UUID to add

 *

 * Adds a new secondary connection UUID to the setting.

 *

 * Returns: %TRUE if the secondary connection UUID was added; %FALSE if the UUID

 * was already present

 **/

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));

    _notify(setting, PROP_SECONDARIES);

    return TRUE;

}

/**

 * nm_setting_connection_remove_secondary:

 * @setting: the #NMSettingConnection

 * @idx: index number of the secondary connection UUID

 *

 * Removes the secondary connection UUID at index @idx.

 **/

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);

    _notify(setting, PROP_SECONDARIES);

}

/**

 * nm_setting_connection_remove_secondary_by_value:

 * @setting: the #NMSettingConnection

 * @sec_uuid: the secondary connection UUID to remove

 *

 * Removes the secondary connection UUID @sec_uuid.

 *

 * Returns: %TRUE if the secondary connection UUID was found and removed; %FALSE if it was not.

 **/

gboolean

nm_setting_connection_remove_secondary_by_value(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)) {

            priv->secondaries = g_slist_delete_link(priv->secondaries, iter);

            _notify(setting, PROP_SECONDARIES);

            return TRUE;

        }

    }

    return FALSE;

}

/**

 * nm_setting_connection_get_gateway_ping_timeout: