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

/*

 * Copyright (C) 2017 Red Hat, Inc.

 * Copyright (C) 2013 Jiri Pirko <jiri@resnulli.us>

 */

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

#include "nm-setting-team.h"

#include <stdlib.h>

#include "nm-utils.h"

#include "nm-utils-private.h"

#include "nm-team-utils.h"

#include "nm-connection-private.h"

/**

 * SECTION:nm-setting-team

 * @short_description: Describes connection properties for teams

 *

 * The #NMSettingTeam object is a #NMSetting subclass that describes properties

 * necessary for team connections.

 **/

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

 * NMTeamLinkWatcher

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

G_DEFINE_BOXED_TYPE(NMTeamLinkWatcher,

                    nm_team_link_watcher,

                    _nm_team_link_watcher_ref,

                    nm_team_link_watcher_unref)

typedef enum {

    LINK_WATCHER_ETHTOOL   = 0,

    LINK_WATCHER_NSNA_PING = 1,

    LINK_WATCHER_ARP_PING  = 2,

} LinkWatcherTypes;

static const char *_link_watcher_name[] = {[LINK_WATCHER_ETHTOOL] = NM_TEAM_LINK_WATCHER_ETHTOOL,

                                           [LINK_WATCHER_NSNA_PING] =

                                               NM_TEAM_LINK_WATCHER_NSNA_PING,

                                           [LINK_WATCHER_ARP_PING] = NM_TEAM_LINK_WATCHER_ARP_PING};

struct NMTeamLinkWatcher {

    int ref_count;

    guint8 type; /* LinkWatcherTypes */

    union {

        struct {

            int delay_up;

            int delay_down;

        } ethtool;

        struct {

            const char *target_host;

            int         init_wait;

            int         interval;

            int         missed_max;

        } nsna_ping;

        struct {

            const char *                  target_host;

            const char *                  source_host;

            int                           init_wait;

            int                           interval;

            int                           missed_max;

            int                           vlanid;

            NMTeamLinkWatcherArpPingFlags flags;

        } arp_ping;

    };

};

#define _CHECK_WATCHER_VOID(watcher)                       \

    G_STMT_START                                           \

    {                                                      \

        g_return_if_fail(watcher != NULL);                 \

        g_return_if_fail(watcher->ref_count > 0);          \

        nm_assert(watcher->type <= LINK_WATCHER_ARP_PING); \

    }                                                      \

    G_STMT_END

#define _CHECK_WATCHER(watcher, err_val)                       \

    G_STMT_START                                               \

    {                                                          \

        g_return_val_if_fail(watcher != NULL, err_val);        \

        g_return_val_if_fail(watcher->ref_count > 0, err_val); \

        nm_assert(watcher->type <= LINK_WATCHER_ARP_PING);     \

    }                                                          \

    G_STMT_END

/**

 * nm_team_link_watcher_new_ethtool:

 * @delay_up: delay_up value

 * @delay_down: delay_down value

 * @error: this call never fails, so this var is not used but kept for format

 *   consistency with the link_watcher constructors of other type

 *

 * Creates a new ethtool #NMTeamLinkWatcher object

 *

 * Returns: (transfer full): the new #NMTeamLinkWatcher object

 *

 * Since: 1.12

 **/

NMTeamLinkWatcher *

nm_team_link_watcher_new_ethtool(int delay_up, int delay_down, GError **error)

{

    NMTeamLinkWatcher *watcher;

    const char *       val_fail = NULL;

    if (delay_up < 0 || !_NM_INT_LE_MAXINT32(delay_up))

        val_fail = "delay-up";

    if (delay_down < 0 || !_NM_INT_LE_MAXINT32(delay_down))

        val_fail = "delay-down";

    if (val_fail) {

        g_set_error(error,

                    NM_CONNECTION_ERROR,

                    NM_CONNECTION_ERROR_FAILED,

                    _("%s is out of range [0, %d]"),

                    val_fail,

                    G_MAXINT32);

        return NULL;

    }

    NM_PRAGMA_WARNING_DISABLE("-Warray-bounds")

    watcher = g_malloc(nm_offsetofend(NMTeamLinkWatcher, ethtool));

    watcher->ref_count          = 1;

    watcher->type               = LINK_WATCHER_ETHTOOL;

    watcher->ethtool.delay_up   = delay_up;

    watcher->ethtool.delay_down = delay_down;

    NM_PRAGMA_WARNING_REENABLE

    return watcher;

}

/**

 * nm_team_link_watcher_new_nsna_ping:

 * @init_wait: init_wait value

 * @interval: interval value

 * @missed_max: missed_max value

 * @target_host: the host name or the ipv6 address that will be used as

 *   target address in the NS packet

 * @error: (out) (allow-none): location to store the error on failure

 *

 * Creates a new nsna_ping #NMTeamLinkWatcher object

 *

 * Returns: (transfer full): the new #NMTeamLinkWatcher object, or %NULL on error

 *

 * Since: 1.12

 **/

NMTeamLinkWatcher *

nm_team_link_watcher_new_nsna_ping(int         init_wait,

                                   int         interval,

                                   int         missed_max,

                                   const char *target_host,

                                   GError **   error)

{

    NMTeamLinkWatcher *watcher;

    const char *       val_fail = NULL;

    char *             str;

    gsize              l_target_host;

    if (!target_host) {

        g_set_error(error,

                    NM_CONNECTION_ERROR,

                    NM_CONNECTION_ERROR_FAILED,

                    _("Missing target-host in nsna_ping link watcher"));

        return NULL;

    }

    if (strpbrk(target_host, " \\/\t=\"\'")) {

        g_set_error(error,

                    NM_CONNECTION_ERROR,

                    NM_CONNECTION_ERROR_FAILED,

                    _("target-host '%s' contains invalid characters"),

                    target_host);

        return NULL;

    }

    if (init_wait < 0 || !_NM_INT_LE_MAXINT32(init_wait))

        val_fail = "init-wait";

    if (interval < 0 || !_NM_INT_LE_MAXINT32(interval))

        val_fail = "interval";

    if (missed_max < 0 || !_NM_INT_LE_MAXINT32(missed_max))

        val_fail = "missed-max";

    if (val_fail) {

        g_set_error(error,

                    NM_CONNECTION_ERROR,

                    NM_CONNECTION_ERROR_FAILED,

                    _("%s is out of range [0, %d]"),

                    val_fail,

                    G_MAXINT32);

        return NULL;

    }

    l_target_host = strlen(target_host) + 1;

    watcher = g_malloc(nm_offsetofend(NMTeamLinkWatcher, nsna_ping) + l_target_host);

    watcher->ref_count            = 1;

    watcher->type                 = LINK_WATCHER_NSNA_PING;

    watcher->nsna_ping.init_wait  = init_wait;

    watcher->nsna_ping.interval   = interval;

    watcher->nsna_ping.missed_max = missed_max;

    str = &((char *) watcher)[nm_offsetofend(NMTeamLinkWatcher, nsna_ping)];

    watcher->nsna_ping.target_host = str;

    memcpy(str, target_host, l_target_host);

    return watcher;

}

/**

 * nm_team_link_watcher_new_arp_ping:

 * @init_wait: init_wait value

 * @interval: interval value

 * @missed_max: missed_max value

 * @target_host: the host name or the ip address that will be used as destination

 *   address in the arp request

 * @source_host: the host name or the ip address that will be used as source

 *   address in the arp request

 * @flags: the watcher #NMTeamLinkWatcherArpPingFlags

 * @error: (out) (allow-none): location to store the error on failure

 *

 * Creates a new arp_ping #NMTeamLinkWatcher object

 *

 * Returns: (transfer full): the new #NMTeamLinkWatcher object, or %NULL on error

 *

 * Since: 1.12

 **/

NMTeamLinkWatcher *

nm_team_link_watcher_new_arp_ping(int                           init_wait,

                                  int                           interval,

                                  int                           missed_max,

                                  const char *                  target_host,

                                  const char *                  source_host,

                                  NMTeamLinkWatcherArpPingFlags flags,

                                  GError **                     error)

{

    return nm_team_link_watcher_new_arp_ping2(init_wait,

                                              interval,

                                              missed_max,

                                              -1,

                                              target_host,

                                              source_host,

                                              flags,

                                              error);

}

/**

 * nm_team_link_watcher_new_arp_ping2:

 * @init_wait: init_wait value

 * @interval: interval value

 * @missed_max: missed_max value

 * @vlanid: vlanid value

 * @target_host: the host name or the ip address that will be used as destination

 *   address in the arp request

 * @source_host: the host name or the ip address that will be used as source

 *   address in the arp request

 * @flags: the watcher #NMTeamLinkWatcherArpPingFlags

 * @error: (out) (allow-none): location to store the error on failure

 *

 * Creates a new arp_ping #NMTeamLinkWatcher object

 *

 * Returns: (transfer full): the new #NMTeamLinkWatcher object, or %NULL on error

 *

 * Since: 1.16

 **/

NMTeamLinkWatcher *

nm_team_link_watcher_new_arp_ping2(int                           init_wait,

                                   int                           interval,

                                   int                           missed_max,

                                   int                           vlanid,

                                   const char *                  target_host,

                                   const char *                  source_host,

                                   NMTeamLinkWatcherArpPingFlags flags,

                                   GError **                     error)

{

    NMTeamLinkWatcher *watcher;

    const char *       val_fail = NULL;

    char *             str;

    gsize              l_target_host;

    gsize              l_source_host;

    if (!target_host || !source_host) {

        g_set_error(error,

                    NM_CONNECTION_ERROR,

                    NM_CONNECTION_ERROR_FAILED,

                    _("Missing %s in arp_ping link watcher"),

                    target_host ? "source-host" : "target-host");

        return NULL;

    }

    if (strpbrk(target_host, " \\/\t=\"\'")) {

        g_set_error(error,

                    NM_CONNECTION_ERROR,

                    NM_CONNECTION_ERROR_FAILED,

                    _("target-host '%s' contains invalid characters"),

                    target_host);

        return NULL;

    }

    if (strpbrk(source_host, " \\/\t=\"\'")) {

        g_set_error(error,

                    NM_CONNECTION_ERROR,

                    NM_CONNECTION_ERROR_FAILED,

                    _("source-host '%s' contains invalid characters"),

                    source_host);

        return NULL;

    }

    else if (init_wait < 0 || !_NM_INT_LE_MAXINT32(init_wait))

        val_fail = "init-wait";

    else if (interval < 0 || !_NM_INT_LE_MAXINT32(interval))

        val_fail = "interval";

    else if (missed_max < 0 || !_NM_INT_LE_MAXINT32(missed_max))

        val_fail = "missed-max";

    if (val_fail) {

        g_set_error(error,

                    NM_CONNECTION_ERROR,

                    NM_CONNECTION_ERROR_FAILED,

                    _("%s is out of range [0, %d]"),

                    val_fail,

                    G_MAXINT32);

        return NULL;

    }

    if (vlanid < -1 || vlanid > 4094) {

        g_set_error_literal(error,

                            NM_CONNECTION_ERROR,

                            NM_CONNECTION_ERROR_FAILED,

                            _("vlanid is out of range [-1, 4094]"));

        return NULL;

    }

    l_target_host = strlen(target_host) + 1;

    l_source_host = strlen(source_host) + 1;

    watcher = g_malloc(nm_offsetofend(NMTeamLinkWatcher, arp_ping) + l_target_host + l_source_host);

    watcher->ref_count           = 1;

    watcher->type                = LINK_WATCHER_ARP_PING;

    watcher->arp_ping.init_wait  = init_wait;

    watcher->arp_ping.interval   = interval;

    watcher->arp_ping.missed_max = missed_max;

    watcher->arp_ping.flags      = flags;

    watcher->arp_ping.vlanid     = vlanid;

    str = &((char *) watcher)[nm_offsetofend(NMTeamLinkWatcher, arp_ping)];

    watcher->arp_ping.target_host = str;

    memcpy(str, target_host, l_target_host);

    str += l_target_host;

    watcher->arp_ping.source_host = str;

    memcpy(str, source_host, l_source_host);

    return watcher;

}

NMTeamLinkWatcher *

_nm_team_link_watcher_ref(NMTeamLinkWatcher *watcher)

{

    _CHECK_WATCHER(watcher, NULL);

    g_atomic_int_inc(&watcher->ref_count);

    return watcher;

}

/**

 * nm_team_link_watcher_ref:

 * @watcher: the #NMTeamLinkWatcher

 *

 * Increases the reference count of the object.

 *

 * Since: 1.12

 **/

void

nm_team_link_watcher_ref(NMTeamLinkWatcher *watcher)

{

    _nm_team_link_watcher_ref(watcher);

}

/**

 * nm_team_link_watcher_unref:

 * @watcher: the #NMTeamLinkWatcher

 *

 * Decreases the reference count of the object.  If the reference count

 * reaches zero, the object will be destroyed.

 *

 * Since: 1.12

 **/

void

nm_team_link_watcher_unref(NMTeamLinkWatcher *watcher)

{

    _CHECK_WATCHER_VOID(watcher);

    if (g_atomic_int_dec_and_test(&watcher->ref_count))

        g_free(watcher);

}

int

nm_team_link_watcher_cmp(const NMTeamLinkWatcher *watcher, const NMTeamLinkWatcher *other)

{

    NM_CMP_SELF(watcher, other);

    NM_CMP_FIELD(watcher, other, type);

    switch (watcher->type) {

    case LINK_WATCHER_ETHTOOL:

        NM_CMP_FIELD(watcher, other, ethtool.delay_up);

        NM_CMP_FIELD(watcher, other, ethtool.delay_down);

        break;

    case LINK_WATCHER_NSNA_PING:

        NM_CMP_FIELD_STR(watcher, other, nsna_ping.target_host);

        NM_CMP_FIELD(watcher, other, nsna_ping.init_wait);

        NM_CMP_FIELD(watcher, other, nsna_ping.interval);

        NM_CMP_FIELD(watcher, other, nsna_ping.missed_max);

        break;

    case LINK_WATCHER_ARP_PING:

        NM_CMP_FIELD_STR(watcher, other, arp_ping.target_host);

        NM_CMP_FIELD_STR(watcher, other, arp_ping.source_host);

        NM_CMP_FIELD(watcher, other, arp_ping.init_wait);

        NM_CMP_FIELD(watcher, other, arp_ping.interval);

        NM_CMP_FIELD(watcher, other, arp_ping.missed_max);

        NM_CMP_FIELD(watcher, other, arp_ping.vlanid);

        NM_CMP_FIELD(watcher, other, arp_ping.flags);

        break;

    }

    return 0;

}

/**

 * nm_team_link_watcher_equal:

 * @watcher: the #NMTeamLinkWatcher

 * @other: the #NMTeamLinkWatcher to compare @watcher to.

 *

 * Determines if two #NMTeamLinkWatcher objects contain the same values

 * in all the properties.

 *

 * Returns: %TRUE if the objects contain the same values, %FALSE if they do not.

 *

 * Since: 1.12

 **/

gboolean

nm_team_link_watcher_equal(const NMTeamLinkWatcher *watcher, const NMTeamLinkWatcher *other)

{

    return nm_team_link_watcher_cmp(watcher, other) == 0;

}

static int

_team_link_watchers_cmp_p_with_data(gconstpointer data_a, gconstpointer data_b, gpointer user_data)

{

    return nm_team_link_watcher_cmp(*((const NMTeamLinkWatcher *const *) data_a),

                                    *((const NMTeamLinkWatcher *const *) data_b));

}

int

nm_team_link_watchers_cmp(const NMTeamLinkWatcher *const *a,

                          const NMTeamLinkWatcher *const *b,

                          gsize                           len,

                          gboolean                        ignore_order)

{

    gs_free const NMTeamLinkWatcher **a_free = NULL;

    gs_free const NMTeamLinkWatcher **b_free = NULL;

    guint                             i;

    if (ignore_order && len > 1) {

        a = nm_memdup_maybe_a(200, a, len * sizeof(*a), &a_free);

        b = nm_memdup_maybe_a(200, b, len * sizeof(*b), &b_free);

        g_qsort_with_data((gpointer) a, len, sizeof(*a), _team_link_watchers_cmp_p_with_data, NULL);

        g_qsort_with_data((gpointer) b, len, sizeof(*b), _team_link_watchers_cmp_p_with_data, NULL);

    }

    for (i = 0; i < len; i++) {

        NM_CMP_RETURN(nm_team_link_watcher_cmp(a[i], b[i]));

    }

    return 0;

}

gboolean

nm_team_link_watchers_equal(const GPtrArray *a, const GPtrArray *b, gboolean ignore_order)

{

    return a == b

           || (a && b && a->len == b->len

               && (nm_team_link_watchers_cmp((const NMTeamLinkWatcher *const *) a->pdata,

                                             (const NMTeamLinkWatcher *const *) b->pdata,

                                             a->len,

                                             ignore_order)

                   == 0));

}

/**

 * nm_team_link_watcher_dup:

 * @watcher: the #NMTeamLinkWatcher

 *

 * Creates a copy of @watcher

 *

 * Returns: (transfer full): a copy of @watcher

 *

 * Since: 1.12

 **/

NMTeamLinkWatcher *

nm_team_link_watcher_dup(const NMTeamLinkWatcher *watcher)

{

    _CHECK_WATCHER(watcher, NULL);

    switch (watcher->type) {

    case LINK_WATCHER_ETHTOOL:

        return nm_team_link_watcher_new_ethtool(watcher->ethtool.delay_up,

                                                watcher->ethtool.delay_down,

                                                NULL);

        break;

    case LINK_WATCHER_NSNA_PING:

        return nm_team_link_watcher_new_nsna_ping(watcher->nsna_ping.init_wait,

                                                  watcher->nsna_ping.interval,

                                                  watcher->nsna_ping.missed_max,

                                                  watcher->nsna_ping.target_host,

                                                  NULL);

        break;

    case LINK_WATCHER_ARP_PING:

        return nm_team_link_watcher_new_arp_ping2(watcher->arp_ping.init_wait,

                                                  watcher->arp_ping.interval,

                                                  watcher->arp_ping.missed_max,

                                                  watcher->arp_ping.vlanid,

                                                  watcher->arp_ping.target_host,

                                                  watcher->arp_ping.source_host,

                                                  watcher->arp_ping.flags,

                                                  NULL);

    default:

        nm_assert_not_reached();

        return NULL;

    }

}

/**

 * nm_team_link_watcher_get_name:

 * @watcher: the #NMTeamLinkWatcher

 *

 * Gets the name of the link watcher to be used.

 *

 * Since: 1.12

 **/

const char *

nm_team_link_watcher_get_name(const NMTeamLinkWatcher *watcher)

{

    _CHECK_WATCHER(watcher, NULL);

    return _link_watcher_name[watcher->type];

}

/**

 * nm_team_link_watcher_get_delay_up:

 * @watcher: the #NMTeamLinkWatcher

 *

 * Gets the delay_up interval (in milliseconds) that elapses between the link

 * coming up and the runner being notified about it.

 *

 * Since: 1.12

 **/

int

nm_team_link_watcher_get_delay_up(const NMTeamLinkWatcher *watcher)

{

    _CHECK_WATCHER(watcher, 0);

    if (watcher->type == LINK_WATCHER_ETHTOOL)

        return watcher->ethtool.delay_up;

    return -1;

}

/**

 * nm_team_link_watcher_get_delay_down:

 * @watcher: the #NMTeamLinkWatcher

 *

 * Gets the delay_down interval (in milliseconds) that elapses between the link

 * going down and the runner being notified about it.

 *

 * Since: 1.12

 **/

int

nm_team_link_watcher_get_delay_down(const NMTeamLinkWatcher *watcher)

{

    _CHECK_WATCHER(watcher, 0);

    if (watcher->type == LINK_WATCHER_ETHTOOL)

        return watcher->ethtool.delay_down;

    return -1;

}

/**

 * nm_team_link_watcher_get_init_wait:

 * @watcher: the #NMTeamLinkWatcher

 *

 * Gets the init_wait interval (in milliseconds) that the team slave should

 * wait before sending the first packet to the target host.

 *

 * Since: 1.12

 **/

int

nm_team_link_watcher_get_init_wait(const NMTeamLinkWatcher *watcher)

{

    _CHECK_WATCHER(watcher, 0);

    if (watcher->type == LINK_WATCHER_NSNA_PING)

        return watcher->nsna_ping.init_wait;

    if (watcher->type == LINK_WATCHER_ARP_PING)

        return watcher->arp_ping.init_wait;

    return -1;

}

/**

 * nm_team_link_watcher_get_interval:

 * @watcher: the #NMTeamLinkWatcher

 *

 * Gets the interval (in milliseconds) that the team slave should wait between

 * sending two check packets to the target host.

 *

 * Since: 1.12

 **/

int

nm_team_link_watcher_get_interval(const NMTeamLinkWatcher *watcher)

{

    _CHECK_WATCHER(watcher, 0);

    if (watcher->type == LINK_WATCHER_NSNA_PING)

        return watcher->nsna_ping.interval;

    if (watcher->type == LINK_WATCHER_ARP_PING)

        return watcher->arp_ping.interval;

    return -1;

}

/**

 * nm_team_link_watcher_get_missed_max:

 * @watcher: the #NMTeamLinkWatcher

 *

 * Gets the number of missed replies after which the link is considered down.

 *

 * Since: 1.12

 **/

int

nm_team_link_watcher_get_missed_max(const NMTeamLinkWatcher *watcher)

{

    _CHECK_WATCHER(watcher, 0);

    if (watcher->type == LINK_WATCHER_NSNA_PING)

        return watcher->nsna_ping.missed_max;

    if (watcher->type == LINK_WATCHER_ARP_PING)

        return watcher->arp_ping.missed_max;

    return -1;

}

/**

 * nm_team_link_watcher_get_vlanid:

 * @watcher: the #NMTeamLinkWatcher

 *

 * Gets the VLAN tag ID to be used to outgoing link probes

 *

 * Since: 1.16

 **/

int

nm_team_link_watcher_get_vlanid(const NMTeamLinkWatcher *watcher)

{

    _CHECK_WATCHER(watcher, -1);

    if (watcher->type == LINK_WATCHER_ARP_PING)

        return watcher->arp_ping.vlanid;

    return -1;

}

/**

 * nm_team_link_watcher_get_target_host:

 * @watcher: the #NMTeamLinkWatcher

 *

 * Gets the host name/ip address to be used as destination for the link probing

 * packets.

 *

 * Since: 1.12

 **/

const char *

nm_team_link_watcher_get_target_host(const NMTeamLinkWatcher *watcher)

{

    _CHECK_WATCHER(watcher, NULL);

    if (watcher->type == LINK_WATCHER_NSNA_PING)

        return watcher->nsna_ping.target_host;

    if (watcher->type == LINK_WATCHER_ARP_PING)

        return watcher->arp_ping.target_host;

    return NULL;

}

/**

 * nm_team_link_watcher_get_source_host:

 * @watcher: the #NMTeamLinkWatcher

 *

 * Gets the ip address to be used as source for the link probing packets.

 *

 * Since: 1.12

 **/

const char *

nm_team_link_watcher_get_source_host(const NMTeamLinkWatcher *watcher)

{

    _CHECK_WATCHER(watcher, NULL);

    if (watcher->type == LINK_WATCHER_ARP_PING)

        return watcher->arp_ping.source_host;

    return NULL;

}

/**

 * nm_team_link_watcher_get_flags:

 * @watcher: the #NMTeamLinkWatcher

 *

 * Gets the arp ping watcher flags.

 *

 * Since: 1.12

 **/

NMTeamLinkWatcherArpPingFlags

nm_team_link_watcher_get_flags(const NMTeamLinkWatcher *watcher)

{

    _CHECK_WATCHER(watcher, 0);

    if (watcher->type == LINK_WATCHER_ARP_PING)

        return watcher->arp_ping.flags;

    return 0;

}

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

static GParamSpec *obj_properties[_NM_TEAM_ATTRIBUTE_MASTER_NUM] = {

    NULL,

};

typedef struct {

    NMTeamSetting *team_setting;

} NMSettingTeamPrivate;

G_DEFINE_TYPE(NMSettingTeam, nm_setting_team, NM_TYPE_SETTING)

#define NM_SETTING_TEAM_GET_PRIVATE(o) \

    (G_TYPE_INSTANCE_GET_PRIVATE((o), NM_TYPE_SETTING_TEAM, NMSettingTeamPrivate))

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

NMTeamSetting *

_nm_setting_team_get_team_setting(NMSettingTeam *setting)

{

    return NM_SETTING_TEAM_GET_PRIVATE(setting)->team_setting;

}

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

#define _maybe_changed(self, changed)                                                 \

    nm_team_setting_maybe_changed(NM_SETTING(_NM_ENSURE_TYPE(NMSettingTeam *, self)), \

                                  (const GParamSpec *const *) obj_properties,         \

                                  (changed))

#define _maybe_changed_with_assert(self, changed) \

    G_STMT_START                                  \

    {                                             \

        if (!_maybe_changed((self), (changed)))   \

            nm_assert_not_reached();              \

    }                                             \

    G_STMT_END

/**

 * nm_setting_team_get_config:

 * @setting: the #NMSettingTeam

 *

 * Returns: the #NMSettingTeam:config property of the setting

 **/

const char *

nm_setting_team_get_config(NMSettingTeam *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_TEAM(setting), NULL);

    return nm_team_setting_config_get(NM_SETTING_TEAM_GET_PRIVATE(setting)->team_setting);

}

/**

 * nm_setting_team_get_notify_peers_count:

 * @setting: the #NMSettingTeam

 *

 * Returns: the ##NMSettingTeam:notify-peers-count property of the setting

 *

 * Since: 1.12

 **/

int

nm_setting_team_get_notify_peers_count(NMSettingTeam *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_TEAM(setting), 0);

    return NM_SETTING_TEAM_GET_PRIVATE(setting)->team_setting->d.master.notify_peers_count;

}

/**

 * nm_setting_team_get_notify_peers_interval:

 * @setting: the #NMSettingTeam

 *

 * Returns: the ##NMSettingTeam:notify-peers-interval property of the setting

 *

 * Since: 1.12

 **/

int

nm_setting_team_get_notify_peers_interval(NMSettingTeam *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_TEAM(setting), 0);

    return NM_SETTING_TEAM_GET_PRIVATE(setting)->team_setting->d.master.notify_peers_interval;

}

/**

 * nm_setting_team_get_mcast_rejoin_count:

 * @setting: the #NMSettingTeam

 *

 * Returns: the ##NMSettingTeam:mcast-rejoin-count property of the setting

 *

 * Since: 1.12

 **/

int

nm_setting_team_get_mcast_rejoin_count(NMSettingTeam *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_TEAM(setting), 0);

    return NM_SETTING_TEAM_GET_PRIVATE(setting)->team_setting->d.master.mcast_rejoin_count;

}

/**

 * nm_setting_team_get_mcast_rejoin_interval:

 * @setting: the #NMSettingTeam

 *

 * Returns: the ##NMSettingTeam:mcast-rejoin-interval property of the setting

 *

 * Since: 1.12

 **/

int

nm_setting_team_get_mcast_rejoin_interval(NMSettingTeam *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_TEAM(setting), 0);

    return NM_SETTING_TEAM_GET_PRIVATE(setting)->team_setting->d.master.mcast_rejoin_interval;

}

/**

 * nm_setting_team_get_runner:

 * @setting: the #NMSettingTeam

 *

 * Returns: the ##NMSettingTeam:runner property of the setting

 *

 * Since: 1.12

 **/

const char *

nm_setting_team_get_runner(NMSettingTeam *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_TEAM(setting), NULL);

    return NM_SETTING_TEAM_GET_PRIVATE(setting)->team_setting->d.master.runner;

}

/**

 * nm_setting_team_get_runner_hwaddr_policy:

 * @setting: the #NMSettingTeam

 *

 * Returns: the ##NMSettingTeam:runner-hwaddr-policy property of the setting

 *

 * Since: 1.12

 **/

const char *

nm_setting_team_get_runner_hwaddr_policy(NMSettingTeam *setting)

{

    g_return_val_if_fail(NM_IS_SETTING_TEAM(setting), NULL);

    return NM_SETTING_TEAM_GET_PRIVATE(setting)->team_setting->d.master.runner_hwaddr_policy;

}

/**

 * nm_setting_team_get_runner_tx_balancer:

 * @setting: the #NMSettingTeam

 *

 * Returns: the ##NMSettingTeam:runner-tx-balancer property of the setting