/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2018 Red Hat, Inc.
 */

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

#include "nm-setting-sriov.h"

#include "nm-setting-private.h"
#include "nm-utils-private.h"

/**
 * SECTION:nm-setting-sriov
 * @short_description: Describes SR-IOV connection properties
 * @include: nm-setting-sriov.h
 **/

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

NM_GOBJECT_PROPERTIES_DEFINE(NMSettingSriov, PROP_TOTAL_VFS, PROP_VFS, PROP_AUTOPROBE_DRIVERS, );

/**
 * NMSettingSriov:
 *
 * SR-IOV settings
 *
 * Since: 1.14
 */
struct _NMSettingSriov {
    NMSetting  parent;
    GPtrArray *vfs;
    guint      total_vfs;
    NMTernary  autoprobe_drivers;
};

struct _NMSettingSriovClass {
    NMSettingClass parent;
};

G_DEFINE_TYPE(NMSettingSriov, nm_setting_sriov, NM_TYPE_SETTING)

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

G_DEFINE_BOXED_TYPE(NMSriovVF, nm_sriov_vf, nm_sriov_vf_dup, nm_sriov_vf_unref)

struct _NMSriovVF {
    guint       refcount;
    guint       index;
    GHashTable *attributes;
    GHashTable *vlans;
    guint *     vlan_ids;
};

typedef struct {
    guint                 id;
    guint                 qos;
    NMSriovVFVlanProtocol protocol;
} VFVlan;

static guint
_vf_vlan_hash(gconstpointer ptr)
{
    return nm_hash_val(1348254767u, *((guint *) ptr));
}

static gboolean
_vf_vlan_equal(gconstpointer a, gconstpointer b)
{
    return *((guint *) a) == *((guint *) b);
}

static GHashTable *
_vf_vlan_create_hash(void)
{
    G_STATIC_ASSERT_EXPR(G_STRUCT_OFFSET(VFVlan, id) == 0);
    return g_hash_table_new_full(_vf_vlan_hash, _vf_vlan_equal, NULL, nm_g_slice_free_fcn(VFVlan));
}

/**
 * nm_sriov_vf_new:
 * @index: the VF index
 *
 * Creates a new #NMSriovVF object.
 *
 * Returns: (transfer full): the new #NMSriovVF object.
 *
 * Since: 1.14
 **/
NMSriovVF *
nm_sriov_vf_new(guint index)
{
    NMSriovVF *vf;

    vf  = g_slice_new(NMSriovVF);
    *vf = (NMSriovVF){
        .refcount   = 1,
        .index      = index,
        .attributes = g_hash_table_new_full(nm_str_hash,
                                            g_str_equal,
                                            g_free,
                                            (GDestroyNotify) g_variant_unref),
    };
    return vf;
}

/**
 * nm_sriov_vf_ref:
 * @vf: the #NMSriovVF
 *
 * Increases the reference count of the object.
 *
 * Since: 1.14
 **/
void
nm_sriov_vf_ref(NMSriovVF *vf)
{
    g_return_if_fail(vf);
    g_return_if_fail(vf->refcount > 0);

    vf->refcount++;
}

/**
 * nm_sriov_vf_unref:
 * @vf: the #NMSriovVF
 *
 * Decreases the reference count of the object.  If the reference count
 * reaches zero, the object will be destroyed.
 *
 * Since: 1.14
 **/
void
nm_sriov_vf_unref(NMSriovVF *vf)
{
    g_return_if_fail(vf);
    g_return_if_fail(vf->refcount > 0);

    vf->refcount--;
    if (vf->refcount == 0) {
        g_hash_table_unref(vf->attributes);
        if (vf->vlans)
            g_hash_table_unref(vf->vlans);
        g_free(vf->vlan_ids);
        nm_g_slice_free(vf);
    }
}

/**
 * nm_sriov_vf_equal:
 * @vf: the #NMSriovVF
 * @other: the #NMSriovVF to compare @vf to.
 *
 * Determines if two #NMSriovVF objects have the same index,
 * attributes and VLANs.
 *
 * Returns: %TRUE if the objects contain the same values, %FALSE
 *    if they do not.
 *
 * Since: 1.14
 **/
gboolean
nm_sriov_vf_equal(const NMSriovVF *vf, const NMSriovVF *other)
{
    GHashTableIter iter;
    const char *   key;
    GVariant *     value, *value2;
    VFVlan *       vlan, *vlan2;
    guint          n_vlans;

    g_return_val_if_fail(vf, FALSE);
    g_return_val_if_fail(vf->refcount > 0, FALSE);
    g_return_val_if_fail(other, FALSE);
    g_return_val_if_fail(other->refcount > 0, FALSE);

    if (vf == other)
        return TRUE;

    if (vf->index != other->index)
        return FALSE;

    if (g_hash_table_size(vf->attributes) != g_hash_table_size(other->attributes))
        return FALSE;
    g_hash_table_iter_init(&iter, vf->attributes);
    while (g_hash_table_iter_next(&iter, (gpointer *) &key, (gpointer *) &value)) {
        value2 = g_hash_table_lookup(other->attributes, key);
        if (!value2)
            return FALSE;
        if (!g_variant_equal(value, value2))
            return FALSE;
    }

    n_vlans = vf->vlans ? g_hash_table_size(vf->vlans) : 0u;
    if (n_vlans != (other->vlans ? g_hash_table_size(other->vlans) : 0u))
        return FALSE;
    if (n_vlans > 0) {
        g_hash_table_iter_init(&iter, vf->vlans);
        while (g_hash_table_iter_next(&iter, (gpointer *) &vlan, NULL)) {
            vlan2 = g_hash_table_lookup(other->vlans, vlan);
            if (!vlan2)
                return FALSE;
            if (vlan->qos != vlan2->qos || vlan->protocol != vlan2->protocol)
                return FALSE;
        }
    }

    return TRUE;
}

static void
vf_add_vlan(NMSriovVF *vf, guint vlan_id, guint qos, NMSriovVFVlanProtocol protocol)
{
    VFVlan *vlan;

    vlan  = g_slice_new(VFVlan);
    *vlan = (VFVlan){
        .id       = vlan_id,
        .qos      = qos,
        .protocol = protocol,
    };

    if (!vf->vlans)
        vf->vlans = _vf_vlan_create_hash();

    g_hash_table_add(vf->vlans, vlan);
    nm_clear_g_free(&vf->vlan_ids);
}

/**
 * nm_sriov_vf_dup:
 * @vf: the #NMSriovVF
 *
 * Creates a copy of @vf.
 *
 * Returns: (transfer full): a copy of @vf
 *
 * Since: 1.14
 **/
NMSriovVF *
nm_sriov_vf_dup(const NMSriovVF *vf)
{
    NMSriovVF *    copy;
    GHashTableIter iter;
    const char *   name;
    GVariant *     variant;
    VFVlan *       vlan;

    g_return_val_if_fail(vf, NULL);
    g_return_val_if_fail(vf->refcount > 0, NULL);

    copy = nm_sriov_vf_new(vf->index);

    g_hash_table_iter_init(&iter, vf->attributes);
    while (g_hash_table_iter_next(&iter, (gpointer *) &name, (gpointer *) &variant))
        nm_sriov_vf_set_attribute(copy, name, variant);

    if (vf->vlans) {
        g_hash_table_iter_init(&iter, vf->vlans);
        while (g_hash_table_iter_next(&iter, (gpointer *) &vlan, NULL))
            vf_add_vlan(copy, vlan->id, vlan->qos, vlan->protocol);
    }

    return copy;
}

/**
 * nm_sriov_vf_get_index:
 * @vf: the #NMSriovVF
 *
 * Gets the index property of this VF object.
 *
 * Returns: the VF index
 *
 * Since: 1.14
 **/
guint
nm_sriov_vf_get_index(const NMSriovVF *vf)
{
    g_return_val_if_fail(vf, 0);
    g_return_val_if_fail(vf->refcount > 0, 0);

    return vf->index;
}

/**
 * nm_sriov_vf_set_attribute:
 * @vf: the #NMSriovVF
 * @name: the name of a route attribute
 * @value: (transfer none) (allow-none): the value
 *
 * Sets the named attribute on @vf to the given value.
 *
 * Since: 1.14
 **/
void
nm_sriov_vf_set_attribute(NMSriovVF *vf, const char *name, GVariant *value)
{
    g_return_if_fail(vf);
    g_return_if_fail(vf->refcount > 0);
    g_return_if_fail(name && *name != '\0');
    g_return_if_fail(!nm_streq(name, "index"));

    if (value) {
        g_hash_table_insert(vf->attributes, g_strdup(name), g_variant_ref_sink(value));
    } else
        g_hash_table_remove(vf->attributes, name);
}

/**
 * nm_sriov_vf_get_attribute_names:
 * @vf: the #NMSriovVF
 *
 * Gets an array of attribute names defined on @vf.
 *
 * Returns: (transfer container): a %NULL-terminated array of attribute names
 *
 * Since: 1.14
 **/
const char **
nm_sriov_vf_get_attribute_names(const NMSriovVF *vf)
{
    g_return_val_if_fail(vf, NULL);
    g_return_val_if_fail(vf->refcount > 0, NULL);

    return nm_utils_strdict_get_keys(vf->attributes, TRUE, NULL);
}

/**
 * nm_sriov_vf_get_attribute:
 * @vf: the #NMSriovVF
 * @name: the name of a VF attribute
 *
 * Gets the value of the attribute with name @name on @vf
 *
 * Returns: (transfer none): the value of the attribute with name @name on
 *   @vf, or %NULL if @vf has no such attribute.
 *
 * Since: 1.14
 **/
GVariant *
nm_sriov_vf_get_attribute(const NMSriovVF *vf, const char *name)
{
    g_return_val_if_fail(vf, NULL);
    g_return_val_if_fail(vf->refcount > 0, NULL);
    g_return_val_if_fail(name && *name != '\0', NULL);

    return g_hash_table_lookup(vf->attributes, name);
}

const NMVariantAttributeSpec *const _nm_sriov_vf_attribute_spec[] = {
    NM_VARIANT_ATTRIBUTE_SPEC_DEFINE(NM_SRIOV_VF_ATTRIBUTE_MAC,
                                     G_VARIANT_TYPE_STRING,
                                     .str_type = 'm', ),
    NM_VARIANT_ATTRIBUTE_SPEC_DEFINE(NM_SRIOV_VF_ATTRIBUTE_SPOOF_CHECK, G_VARIANT_TYPE_BOOLEAN, ),
    NM_VARIANT_ATTRIBUTE_SPEC_DEFINE(NM_SRIOV_VF_ATTRIBUTE_TRUST, G_VARIANT_TYPE_BOOLEAN, ),
    NM_VARIANT_ATTRIBUTE_SPEC_DEFINE(NM_SRIOV_VF_ATTRIBUTE_MIN_TX_RATE, G_VARIANT_TYPE_UINT32, ),
    NM_VARIANT_ATTRIBUTE_SPEC_DEFINE(NM_SRIOV_VF_ATTRIBUTE_MAX_TX_RATE, G_VARIANT_TYPE_UINT32, ),
    /* D-Bus only, synthetic attributes */
    NM_VARIANT_ATTRIBUTE_SPEC_DEFINE("vlans", G_VARIANT_TYPE_STRING, .str_type = 'd', ),
    NULL,
};

/**
 * nm_sriov_vf_attribute_validate:
 * @name: the attribute name
 * @value: the attribute value
 * @known: (out): on return, whether the attribute name is a known one
 * @error: (allow-none): return location for a #GError, or %NULL
 *
 * Validates a VF attribute, i.e. checks that the attribute is a known one,
 * the value is of the correct type and well-formed.
 *
 * Returns: %TRUE if the attribute is valid, %FALSE otherwise
 *
 * Since: 1.14
 */
gboolean
nm_sriov_vf_attribute_validate(const char *name, GVariant *value, gboolean *known, GError **error)
{
    const NMVariantAttributeSpec *const *iter;
    const NMVariantAttributeSpec *       spec = NULL;

    g_return_val_if_fail(name, FALSE);
    g_return_val_if_fail(value, FALSE);
    g_return_val_if_fail(!error || !*error, FALSE);

    for (iter = _nm_sriov_vf_attribute_spec; *iter; iter++) {
        if (nm_streq(name, (*iter)->name)) {
            spec = *iter;
            break;
        }
    }

    if (!spec || spec->str_type == 'd') {
        NM_SET_OUT(known, FALSE);
        g_set_error_literal(error,
                            NM_CONNECTION_ERROR,
                            NM_CONNECTION_ERROR_FAILED,
                            _("unknown attribute"));
        return FALSE;
    }

    NM_SET_OUT(known, TRUE);

    if (!g_variant_is_of_type(value, spec->type)) {
        g_set_error(error,
                    NM_CONNECTION_ERROR,
                    NM_CONNECTION_ERROR_FAILED,
                    _("invalid attribute type '%s'"),
                    g_variant_get_type_string(value));
        return FALSE;
    }

    if (g_variant_type_equal(spec->type, G_VARIANT_TYPE_STRING)) {
        const char *string;

        switch (spec->str_type) {
        case 'm': /* MAC address */
            string = g_variant_get_string(value, NULL);
            if (!nm_utils_hwaddr_valid(string, -1)) {
                g_set_error(error,
                            NM_CONNECTION_ERROR,
                            NM_CONNECTION_ERROR_FAILED,
                            _("'%s' is not a valid MAC address"),
                            string);
                return FALSE;
            }
            break;
        default:
            break;
        }
    }

    return TRUE;
}

gboolean
_nm_sriov_vf_attribute_validate_all(const NMSriovVF *vf, GError **error)
{
    GHashTableIter iter;
    const char *   name;
    GVariant *     variant;
    GVariant *     min, *max;

    g_return_val_if_fail(vf, FALSE);
    g_return_val_if_fail(vf->refcount > 0, FALSE);

    g_hash_table_iter_init(&iter, vf->attributes);
    while (g_hash_table_iter_next(&iter, (gpointer *) &name, (gpointer *) &variant)) {
        if (!nm_sriov_vf_attribute_validate(name, variant, NULL, error)) {
            g_prefix_error(error, "attribute '%s':", name);
            return FALSE;
        }
    }

    min = g_hash_table_lookup(vf->attributes, NM_SRIOV_VF_ATTRIBUTE_MIN_TX_RATE);
    max = g_hash_table_lookup(vf->attributes, NM_SRIOV_VF_ATTRIBUTE_MAX_TX_RATE);
    if (min && max && g_variant_get_uint32(min) > g_variant_get_uint32(max)) {
        g_set_error(error,
                    NM_CONNECTION_ERROR,
                    NM_CONNECTION_ERROR_FAILED,
                    "min_tx_rate is greater than max_tx_rate");
        return FALSE;
    }

    return TRUE;
}

/**
 * nm_sriov_vf_add_vlan:
 * @vf: the #NMSriovVF
 * @vlan_id: the VLAN id
 *
 * Adds a VLAN to the VF.
 *
 * Returns: %TRUE if the VLAN was added; %FALSE if it already existed
 *
 * Since: 1.14
 **/
gboolean
nm_sriov_vf_add_vlan(NMSriovVF *vf, guint vlan_id)
{
    g_return_val_if_fail(vf, FALSE);
    g_return_val_if_fail(vf->refcount > 0, FALSE);

    if (vf->vlans && g_hash_table_contains(vf->vlans, &vlan_id))
        return FALSE;

    vf_add_vlan(vf, vlan_id, 0, NM_SRIOV_VF_VLAN_PROTOCOL_802_1Q);

    return TRUE;
}

/**
 * nm_sriov_vf_remove_vlan:
 * @vf: the #NMSriovVF
 * @vlan_id: the VLAN id
 *
 * Removes a VLAN from a VF.
 *
 * Returns: %TRUE if the VLAN was removed, %FALSE if the VLAN @vlan_id
 *     did not belong to the VF.
 *
 * Since: 1.14
 */
gboolean
nm_sriov_vf_remove_vlan(NMSriovVF *vf, guint vlan_id)
{
    g_return_val_if_fail(vf, FALSE);
    g_return_val_if_fail(vf->refcount > 0, FALSE);

    if (!vf->vlans || !g_hash_table_remove(vf->vlans, &vlan_id))
        return FALSE;

    nm_clear_g_free(&vf->vlan_ids);
    return TRUE;
}

static int
vlan_id_compare(gconstpointer a, gconstpointer b, gpointer user_data)
{
    guint id_a = *(guint *) a;
    guint id_b = *(guint *) b;

    if (id_a < id_b)
        return -1;
    else if (id_a > id_b)
        return 1;
    else
        return 0;
}

/**
 * nm_sriov_vf_get_vlan_ids:
 * @vf: the #NMSriovVF
 * @length: (out) (allow-none): on return, the number of VLANs configured
 *
 * Returns the VLANs currently configured on the VF.
 *
 * Returns: (transfer none) (array length=length): a list of VLAN ids configured on the VF.
 *
 * Since: 1.14
 */
const guint *
nm_sriov_vf_get_vlan_ids(const NMSriovVF *vf, guint *length)
{
    GHashTableIter iter;
    VFVlan *       vlan;
    guint          num, i;

    g_return_val_if_fail(vf, NULL);
    g_return_val_if_fail(vf->refcount > 0, NULL);

    num = vf->vlans ? g_hash_table_size(vf->vlans) : 0u;
    NM_SET_OUT(length, num);

    if (vf->vlan_ids)
        return vf->vlan_ids;
    if (num == 0)
        return NULL;

    /* vf is const, however, vlan_ids is a mutable field caching the
     * result ("mutable" in C++ terminology) */
    ((NMSriovVF *) vf)->vlan_ids = g_new0(guint, num);

    i = 0;
    g_hash_table_iter_init(&iter, vf->vlans);
    while (g_hash_table_iter_next(&iter, (gpointer *) &vlan, NULL))
        vf->vlan_ids[i++] = vlan->id;

    nm_assert(num == i);

    g_qsort_with_data(vf->vlan_ids, num, sizeof(guint), vlan_id_compare, NULL);

    return vf->vlan_ids;
}

/**
 * nm_sriov_vf_set_vlan_qos:
 * @vf: the #NMSriovVF
 * @vlan_id: the VLAN id
 * @qos: a QoS (priority) value
 *
 * Sets a QoS value for the given VLAN.
 *
 * Since: 1.14
 */
void
nm_sriov_vf_set_vlan_qos(NMSriovVF *vf, guint vlan_id, guint32 qos)
{
    VFVlan *vlan;

    g_return_if_fail(vf);
    g_return_if_fail(vf->refcount > 0);

    if (!vf->vlans || !(vlan = g_hash_table_lookup(vf->vlans, &vlan_id)))
        g_return_if_reached();

    vlan->qos = qos;
}

/**
 * nm_sriov_vf_set_vlan_protocol:
 * @vf: the #NMSriovVF
 * @vlan_id: the VLAN id
 * @protocol: the VLAN protocol
 *
 * Sets the protocol for the given VLAN.
 *
 * Since: 1.14
 */
void
nm_sriov_vf_set_vlan_protocol(NMSriovVF *vf, guint vlan_id, NMSriovVFVlanProtocol protocol)
{
    VFVlan *vlan;

    g_return_if_fail(vf);
    g_return_if_fail(vf->refcount > 0);

    if (!vf->vlans || !(vlan = g_hash_table_lookup(vf->vlans, &vlan_id)))
        g_return_if_reached();

    vlan->protocol = protocol;
}

/**
 * nm_sriov_vf_get_vlan_qos:
 * @vf: the #NMSriovVF
 * @vlan_id: the VLAN id
 *
 * Returns the QoS value for the given VLAN.
 *
 * Returns: the QoS value
 *
 * Since: 1.14
 */
guint32
nm_sriov_vf_get_vlan_qos(const NMSriovVF *vf, guint vlan_id)
{
    VFVlan *vlan;

    g_return_val_if_fail(vf, 0);
    g_return_val_if_fail(vf->refcount > 0, 0);

    if (!vf->vlans || !(vlan = g_hash_table_lookup(vf->vlans, &vlan_id)))
        g_return_val_if_reached(0);

    return vlan->qos;
}

/*
 * nm_sriov_vf_get_vlan_protocol:
 * @vf: the #NMSriovVF
 * @vlan_id: the VLAN id
 *
 * Returns the configured protocol for the given VLAN.
 *
 * Returns: the configured protocol
 *
 * Since: 1.14
 */
NMSriovVFVlanProtocol
nm_sriov_vf_get_vlan_protocol(const NMSriovVF *vf, guint vlan_id)
{
    VFVlan *vlan;

    g_return_val_if_fail(vf, NM_SRIOV_VF_VLAN_PROTOCOL_802_1Q);
    g_return_val_if_fail(vf->refcount > 0, NM_SRIOV_VF_VLAN_PROTOCOL_802_1Q);

    if (!vf->vlans || !(vlan = g_hash_table_lookup(vf->vlans, &vlan_id)))
        g_return_val_if_reached(NM_SRIOV_VF_VLAN_PROTOCOL_802_1Q);

    return vlan->protocol;
}

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

/**
 * nm_setting_sriov_get_total_vfs:
 * @setting: the #NMSettingSriov
 *
 * Returns the value contained in the #NMSettingSriov:total-vfs
 * property.
 *
 * Returns: the total number of SR-IOV virtual functions to create
 *
 * Since: 1.14
 **/
guint
nm_setting_sriov_get_total_vfs(NMSettingSriov *setting)
{
    g_return_val_if_fail(NM_IS_SETTING_SRIOV(setting), 0);

    return setting->total_vfs;
}

/**
 * nm_setting_sriov_get_num_vfs:
 * @setting: the #NMSettingSriov
 *
 * Returns: the number of configured VFs
 *
 * Since: 1.14
 **/
guint
nm_setting_sriov_get_num_vfs(NMSettingSriov *setting)
{
    g_return_val_if_fail(NM_IS_SETTING_SRIOV(setting), 0);

    return setting->vfs->len;
}

/**
 * nm_setting_sriov_get_vf:
 * @setting: the #NMSettingSriov
 * @idx: index number of the VF to return
 *
 * Returns: (transfer none): the VF at index @idx
 *
 * Since: 1.14
 **/
NMSriovVF *
nm_setting_sriov_get_vf(NMSettingSriov *setting, guint idx)
{
    g_return_val_if_fail(NM_IS_SETTING_SRIOV(setting), NULL);
    g_return_val_if_fail(idx < setting->vfs->len, NULL);

    return setting->vfs->pdata[idx];
}

/**
 * nm_setting_sriov_add_vf:
 * @setting: the #NMSettingSriov
 * @vf: the VF to add
 *
 * Appends a new VF and associated information to the setting.  The
 * given VF is duplicated internally and is not changed by this function.
 *
 * Since: 1.14
 **/
void
nm_setting_sriov_add_vf(NMSettingSriov *setting, NMSriovVF *vf)
{
    g_return_if_fail(NM_IS_SETTING_SRIOV(setting));
    g_return_if_fail(vf);
    g_return_if_fail(vf->refcount > 0);

    g_ptr_array_add(setting->vfs, nm_sriov_vf_dup(vf));
    _notify(setting, PROP_VFS);
}

/**
 * nm_setting_sriov_remove_vf:
 * @setting: the #NMSettingSriov
 * @idx: index number of the VF
 *
 * Removes the VF at index @idx.
 *
 * Since: 1.14
 **/
void
nm_setting_sriov_remove_vf(NMSettingSriov *setting, guint idx)
{
    g_return_if_fail(NM_IS_SETTING_SRIOV(setting));
    g_return_if_fail(idx < setting->vfs->len);

    g_ptr_array_remove_index(setting->vfs, idx);
    _notify(setting, PROP_VFS);
}

/**
 * nm_setting_sriov_remove_vf_by_index:
 * @setting: the #NMSettingSriov
 * @index: the VF index of the VF to remove
 *
 * Removes the VF with VF index @index.
 *
 * Returns: %TRUE if the VF was found and removed; %FALSE if it was not
 *
 * Since: 1.14
 **/
gboolean
nm_setting_sriov_remove_vf_by_index(NMSettingSriov *setting, guint index)
{
    guint i;

    g_return_val_if_fail(NM_IS_SETTING_SRIOV(setting), FALSE);

    for (i = 0; i < setting->vfs->len; i++) {
        if (nm_sriov_vf_get_index(setting->vfs->pdata[i]) == index) {
            g_ptr_array_remove_index(setting->vfs, i);
            _notify(setting, PROP_VFS);
            return TRUE;
        }
    }
    return FALSE;
}

/**
 * nm_setting_sriov_clear_vfs:
 * @setting: the #NMSettingSriov
 *
 * Removes all configured VFs.
 *
 * Since: 1.14
 **/
void
nm_setting_sriov_clear_vfs(NMSettingSriov *setting)
{
    g_return_if_fail(NM_IS_SETTING_SRIOV(setting));

    if (setting->vfs->len != 0) {
        g_ptr_array_set_size(setting->vfs, 0);
        _notify(setting, PROP_VFS);
    }
}

/**
 * nm_setting_sriov_get_autoprobe_drivers:
 * @setting: the #NMSettingSriov
 *
 * Returns the value contained in the #NMSettingSriov:autoprobe-drivers
 * property.
 *
 * Returns: the autoprobe-drivers property value
 *
 * Since: 1.14
 **/
NMTernary
nm_setting_sriov_get_autoprobe_drivers(NMSettingSriov *setting)
{
    g_return_val_if_fail(NM_IS_SETTING_SRIOV(setting), NM_TERNARY_DEFAULT);

    return setting->autoprobe_drivers;
}

static int
vf_index_compare(gconstpointer a, gconstpointer b)
{
    NMSriovVF *vf_a = *(NMSriovVF **) a;
    NMSriovVF *vf_b = *(NMSriovVF **) b;

    if (vf_a->index < vf_b->index)
        return -1;
    else if (vf_a->index > vf_b->index)
        return 1;
    else
        return 0;
}

gboolean
_nm_setting_sriov_sort_vfs(NMSettingSriov *setting)
{
    gboolean need_sort = FALSE;
    guint    i;

    for (i = 1; i < setting->vfs->len; i++) {
        NMSriovVF *vf_prev = setting->vfs->pdata[i - 1];
        NMSriovVF *vf      = setting->vfs->pdata[i];

        if (vf->index <= vf_prev->index) {
            need_sort = TRUE;
            break;
        }
    }

    if (need_sort) {
        g_ptr_array_sort(setting->vfs, vf_index_compare);
        _notify(setting, PROP_VFS);
    }

    return need_sort;
}

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

static GVariant *
vfs_to_dbus(const NMSettInfoSetting *               sett_info,
            guint                                   property_idx,
            NMConnection *                          connection,
            NMSetting *                             setting,
            NMConnectionSerializationFlags          flags,
            const NMConnectionSerializationOptions *options)
{
    gs_unref_ptrarray GPtrArray *vfs = NULL;
    GVariantBuilder              builder;
    guint                        i;

    g_object_get(setting, NM_SETTING_SRIOV_VFS, &vfs, NULL);
    g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));

    if (vfs) {
        for (i = 0; i < vfs->len; i++) {
            gs_free const char **attr_names = NULL;
            NMSriovVF *          vf         = vfs->pdata[i];
            GVariantBuilder      vf_builder;
            const guint *        vlan_ids;
            const char **        name;
            guint                num_vlans = 0;

            g_variant_builder_init(&vf_builder, G_VARIANT_TYPE_VARDICT);
            g_variant_builder_add(&vf_builder,
                                  "{sv}",
                                  "index",
                                  g_variant_new_uint32(nm_sriov_vf_get_index(vf)));

            attr_names = nm_utils_strdict_get_keys(vf->attributes, TRUE, NULL);
            if (attr_names) {
                for (name = attr_names; *name; name++) {
                    g_variant_builder_add(&vf_builder,
                                          "{sv}",
                                          *name,
                                          nm_sriov_vf_get_attribute(vf, *name));
                }
            }

            /* VLANs are translated into an array of maps, where each map has
             * keys 'id', 'qos' and 'proto'. This guarantees enough flexibility
             * to accommodate any future new option. */
            vlan_ids = nm_sriov_vf_get_vlan_ids(vf, &num_vlans);
            if (num_vlans) {
                GVariantBuilder vlans_builder;
                guint           j;

                g_variant_builder_init(&vlans_builder, G_VARIANT_TYPE("aa{sv}"));
                for (j = 0; j < num_vlans; j++) {
                    GVariantBuilder vlan_builder;

                    g_variant_builder_init(&vlan_builder, G_VARIANT_TYPE("a{sv}"));
                    g_variant_builder_add(&vlan_builder,
                                          "{sv}",
                                          "id",
                                          g_variant_new_uint32(vlan_ids[j]));
                    g_variant_builder_add(
                        &vlan_builder,
                        "{sv}",
                        "qos",
                        g_variant_new_uint32(nm_sriov_vf_get_vlan_qos(vf, vlan_ids[j])));
                    g_variant_builder_add(
                        &vlan_builder,
                        "{sv}",
                        "protocol",
                        g_variant_new_uint32(nm_sriov_vf_get_vlan_protocol(vf, vlan_ids[j])));
                    g_variant_builder_add(&vlans_builder, "a{sv}", &vlan_builder);
                }
                g_variant_builder_add(&vf_builder,
                                      "{sv}",
                                      "vlans",
                                      g_variant_builder_end(&vlans_builder));
            }
            g_variant_builder_add(&builder, "a{sv}", &vf_builder);
        }
    }

    return g_variant_builder_end(&builder);
}

static gboolean
vfs_from_dbus(NMSetting *         setting,
              GVariant *          connection_dict,
              const char *        property,
              GVariant *          value,
              NMSettingParseFlags parse_flags,
              GError **           error)
{
    GPtrArray *  vfs;
    GVariantIter vf_iter;
    GVariant *   vf_var;

    g_return_val_if_fail(g_variant_is_of_type(value, G_VARIANT_TYPE("aa{sv}")), FALSE);

    vfs = g_ptr_array_new_with_free_func((GDestroyNotify) nm_sriov_vf_unref);
    g_variant_iter_init(&vf_iter, value);
    while (g_variant_iter_next(&vf_iter, "@a{sv}", &vf_var)) {
        NMSriovVF *  vf;
        guint32      index;
        GVariantIter attr_iter;
        const char * attr_name;
        GVariant *   attr_var, *vlans_var;

        if (!g_variant_lookup(vf_var, "index", "u", &index))
            goto next;

        vf = nm_sriov_vf_new(index);

        g_variant_iter_init(&attr_iter, vf_var);
        while (g_variant_iter_next(&attr_iter, "{&sv}", &attr_name, &attr_var)) {
            if (!NM_IN_STRSET(attr_name, "index", "vlans"))
                nm_sriov_vf_set_attribute(vf, attr_name, attr_var);
            g_variant_unref(attr_var);
        }

        if (g_variant_lookup(vf_var, "vlans", "@aa{sv}", &vlans_var)) {
            GVariantIter vlan_iter;
            GVariant *   vlan_var;

            g_variant_iter_init(&vlan_iter, vlans_var);
            while (g_variant_iter_next(&vlan_iter, "@a{sv}", &vlan_var)) {
                NMSriovVFVlanProtocol proto   = NM_SRIOV_VF_VLAN_PROTOCOL_802_1Q;
                gint64                vlan_id = -1;
                guint                 qos     = 0;

                g_variant_iter_init(&attr_iter, vlan_var);
                while (g_variant_iter_next(&attr_iter, "{&sv}", &attr_name, &attr_var)) {
                    if (nm_streq(attr_name, "id")
                        && g_variant_is_of_type(attr_var, G_VARIANT_TYPE_UINT32))
                        vlan_id = g_variant_get_uint32(attr_var);
                    else if (nm_streq(attr_name, "qos")
                             && g_variant_is_of_type(attr_var, G_VARIANT_TYPE_UINT32))
                        qos = g_variant_get_uint32(attr_var);
                    else if (nm_streq(attr_name, "protocol")
                             && g_variant_is_of_type(attr_var, G_VARIANT_TYPE_UINT32))
                        proto = g_variant_get_uint32(attr_var);
                    g_variant_unref(attr_var);
                }
                if (vlan_id != -1)
                    vf_add_vlan(vf, vlan_id, qos, proto);
                g_variant_unref(vlan_var);
            }
            g_variant_unref(vlans_var);
        }

        g_ptr_array_add(vfs, vf);
next:
        g_variant_unref(vf_var);
    }

    g_object_set(setting, NM_SETTING_SRIOV_VFS, vfs, NULL);
    g_ptr_array_unref(vfs);

    return TRUE;
}

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

static gboolean
verify(NMSetting *setting, NMConnection *connection, GError **error)
{
    NMSettingSriov *self = NM_SETTING_SRIOV(setting);
    guint           i;

    if (self->vfs->len) {
        gs_unref_hashtable GHashTable *h = NULL;

        h = g_hash_table_new(nm_direct_hash, NULL);
        for (i = 0; i < self->vfs->len; i++) {
            NMSriovVF *   vf            = self->vfs->pdata[i];
            gs_free_error GError *local = NULL;

            if (vf->index >= self->total_vfs) {
                g_set_error(error,
                            NM_CONNECTION_ERROR,
                            NM_CONNECTION_ERROR_INVALID_PROPERTY,
                            _("VF with index %u, but the total number of VFs is %u"),
                            vf->index,
                            self->total_vfs);
                g_prefix_error(error,
                               "%s.%s: ",
                               NM_SETTING_SRIOV_SETTING_NAME,
                               NM_SETTING_SRIOV_VFS);
                return FALSE;
            }

            if (!_nm_sriov_vf_attribute_validate_all(vf, &local)) {
                g_set_error(error,
                            NM_CONNECTION_ERROR,
                            NM_CONNECTION_ERROR_INVALID_PROPERTY,
                            _("invalid VF %u: %s"),
                            vf->index,
                            local->message);
                g_prefix_error(error,
                               "%s.%s: ",
                               NM_SETTING_SRIOV_SETTING_NAME,
                               NM_SETTING_SRIOV_VFS);
                return FALSE;
            }

            if (g_hash_table_contains(h, GUINT_TO_POINTER(vf->index))) {
                g_set_error(error,
                            NM_CONNECTION_ERROR,
                            NM_CONNECTION_ERROR_INVALID_PROPERTY,
                            _("duplicate VF index %u"),
                            vf->index);
                g_prefix_error(error,
                               "%s.%s: ",
                               NM_SETTING_SRIOV_SETTING_NAME,
                               NM_SETTING_SRIOV_VFS);
                return FALSE;
            }

            g_hash_table_add(h, GUINT_TO_POINTER(vf->index));
        }
    }

    /* Failures from here on are NORMALIZABLE... */

    if (self->vfs->len) {
        for (i = 1; i < self->vfs->len; i++) {
            NMSriovVF *vf_prev = self->vfs->pdata[i - 1];
            NMSriovVF *vf      = self->vfs->pdata[i];

            if (vf->index <= vf_prev->index) {
                g_set_error(error,
                            NM_CONNECTION_ERROR,
                            NM_CONNECTION_ERROR_INVALID_PROPERTY,
                            _("VFs %d and %d are not sorted by ascending index"),
                            vf_prev->index,
                            vf->index);
                g_prefix_error(error,
                               "%s.%s: ",
                               NM_SETTING_SRIOV_SETTING_NAME,
                               NM_SETTING_SRIOV_VFS);
                return NM_SETTING_VERIFY_NORMALIZABLE;
            }
        }
    }

    return TRUE;
}

static NMTernary
compare_property(const NMSettInfoSetting *sett_info,
                 guint                    property_idx,
                 NMConnection *           con_a,
                 NMSetting *              set_a,
                 NMConnection *           con_b,
                 NMSetting *              set_b,
                 NMSettingCompareFlags    flags)
{
    NMSettingSriov *a;
    NMSettingSriov *b;
    guint           i;

    if (nm_streq(sett_info->property_infos[property_idx].name, NM_SETTING_SRIOV_VFS)) {
        if (set_b) {
            a = NM_SETTING_SRIOV(set_a);
            b = NM_SETTING_SRIOV(set_b);

            if (a->vfs->len != b->vfs->len)
                return FALSE;
            for (i = 0; i < a->vfs->len; i++) {
                if (!nm_sriov_vf_equal(a->vfs->pdata[i], b->vfs->pdata[i]))
                    return FALSE;
            }
        }
        return TRUE;
    }

    return NM_SETTING_CLASS(nm_setting_sriov_parent_class)
        ->compare_property(sett_info, property_idx, con_a, set_a, con_b, set_b, flags);
}

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

static void
get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
    NMSettingSriov *self = NM_SETTING_SRIOV(object);

    switch (prop_id) {
    case PROP_TOTAL_VFS:
        g_value_set_uint(value, self->total_vfs);
        break;
    case PROP_VFS:
        g_value_take_boxed(value,
                           _nm_utils_copy_array(self->vfs,
                                                (NMUtilsCopyFunc) nm_sriov_vf_dup,
                                                (GDestroyNotify) nm_sriov_vf_unref));
        break;
    case PROP_AUTOPROBE_DRIVERS:
        g_value_set_enum(value, self->autoprobe_drivers);
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
        break;
    }
}

static void
set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
    NMSettingSriov *self = NM_SETTING_SRIOV(object);

    switch (prop_id) {
    case PROP_TOTAL_VFS:
        self->total_vfs = g_value_get_uint(value);
        break;
    case PROP_VFS:
        g_ptr_array_unref(self->vfs);
        self->vfs = _nm_utils_copy_array(g_value_get_boxed(value),
                                         (NMUtilsCopyFunc) nm_sriov_vf_dup,
                                         (GDestroyNotify) nm_sriov_vf_unref);
        break;
    case PROP_AUTOPROBE_DRIVERS:
        self->autoprobe_drivers = g_value_get_enum(value);
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
        break;
    }
}

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

static void
nm_setting_sriov_init(NMSettingSriov *setting)
{
    setting->vfs = g_ptr_array_new_with_free_func((GDestroyNotify) nm_sriov_vf_unref);

    setting->autoprobe_drivers = NM_TERNARY_DEFAULT;
}

/**
 * nm_setting_sriov_new:
 *
 * Creates a new #NMSettingSriov object with default values.
 *
 * Returns: (transfer full): the new empty #NMSettingSriov object
 *
 * Since: 1.14
 **/
NMSetting *
nm_setting_sriov_new(void)
{
    return g_object_new(NM_TYPE_SETTING_SRIOV, NULL);
}

static void
finalize(GObject *object)
{
    NMSettingSriov *self = NM_SETTING_SRIOV(object);

    g_ptr_array_unref(self->vfs);

    G_OBJECT_CLASS(nm_setting_sriov_parent_class)->finalize(object);
}

static void
nm_setting_sriov_class_init(NMSettingSriovClass *klass)
{
    GObjectClass *  object_class        = G_OBJECT_CLASS(klass);
    NMSettingClass *setting_class       = NM_SETTING_CLASS(klass);
    GArray *        properties_override = _nm_sett_info_property_override_create_array();

    object_class->get_property = get_property;
    object_class->set_property = set_property;
    object_class->finalize     = finalize;

    setting_class->compare_property = compare_property;
    setting_class->verify           = verify;

    /**
     * NMSettingSriov:total-vfs
     *
     * The total number of virtual functions to create.
     *
     * Note that when the sriov setting is present NetworkManager
     * enforces the number of virtual functions on the interface
     * (also when it is zero) during activation and resets it
     * upon deactivation. To prevent any changes to SR-IOV
     * parameters don't add a sriov setting to the connection.
     *
     * Since: 1.14
     **/
    /* ---ifcfg-rh---
     * property: total-vfs
     * variable: SRIOV_TOTAL_VFS(+)
     * description: The total number of virtual functions to create
     * example: SRIOV_TOTAL_VFS=16
     * ---end---
     */
    obj_properties[PROP_TOTAL_VFS] = g_param_spec_uint(
        NM_SETTING_SRIOV_TOTAL_VFS,
        "",
        "",
        0,
        G_MAXUINT32,
        0,
        NM_SETTING_PARAM_FUZZY_IGNORE | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);

    /**
     * NMSettingSriov:vfs: (type GPtrArray(NMSriovVF))
     *
     * Array of virtual function descriptors.
     *
     * Each VF descriptor is a dictionary mapping attribute names
     * to GVariant values. The 'index' entry is mandatory for
     * each VF.
     *
     * When represented as string a VF is in the form:
     *
     *   "INDEX [ATTR=VALUE[ ATTR=VALUE]...]".
     *
     * for example:
     *
     *   "2 mac=00:11:22:33:44:55 spoof-check=true".
     *
     * Multiple VFs can be specified using a comma as separator.
     * Currently, the following attributes are supported: mac,
     * spoof-check, trust, min-tx-rate, max-tx-rate, vlans.
     *
     * The "vlans" attribute is represented as a semicolon-separated
     * list of VLAN descriptors, where each descriptor has the form
     *
     *   "ID[.PRIORITY[.PROTO]]".
     *
     * PROTO can be either 'q' for 802.1Q (the default) or 'ad' for
     * 802.1ad.
     *

     * Since: 1.14
     **/
    /* ---ifcfg-rh---
     * property: vfs
     * variable: SRIOV_VF1(+), SRIOV_VF2(+), ...
     * description: SR-IOV virtual function descriptors
     * example: SRIOV_VF10="mac=00:11:22:33:44:55", ...
     * ---end---
     */
    obj_properties[PROP_VFS] = g_param_spec_boxed(NM_SETTING_SRIOV_VFS,
                                                  "",
                                                  "",
                                                  G_TYPE_PTR_ARRAY,
                                                  G_PARAM_READWRITE | NM_SETTING_PARAM_INFERRABLE
                                                      | G_PARAM_STATIC_STRINGS);
    _nm_properties_override_gobj(properties_override,
                                 obj_properties[PROP_VFS],
                                 NM_SETT_INFO_PROPERT_TYPE_DBUS(NM_G_VARIANT_TYPE("aa{sv}"),
                                                                .to_dbus_fcn   = vfs_to_dbus,
                                                                .from_dbus_fcn = vfs_from_dbus, ));

    /**
     * NMSettingSriov:autoprobe-drivers
     *
     * Whether to autoprobe virtual functions by a compatible driver.
     *
     * If set to %NM_TERNARY_TRUE, the kernel will try to bind VFs to
     * a compatible driver and if this succeeds a new network
     * interface will be instantiated for each VF.
     *
     * If set to %NM_TERNARY_FALSE, VFs will not be claimed and no
     * network interfaces will be created for them.
     *
     * When set to %NM_TERNARY_DEFAULT, the global default is used; in
     * case the global default is unspecified it is assumed to be
     * %NM_TERNARY_TRUE.
     *
     * Since: 1.14
     **/
    /* ---ifcfg-rh---
     * property: autoprobe-drivers
     * variable: SRIOV_AUTOPROBE_DRIVERS(+)
     * default: missing variable means global default
     * description: Whether to autoprobe virtual functions by a compatible driver
     * example: SRIOV_AUTOPROBE_DRIVERS=0,1
     * ---end---
     */
    obj_properties[PROP_AUTOPROBE_DRIVERS] = g_param_spec_enum(
        NM_SETTING_SRIOV_AUTOPROBE_DRIVERS,
        "",
        "",
        NM_TYPE_TERNARY,
        NM_TERNARY_DEFAULT,
        NM_SETTING_PARAM_FUZZY_IGNORE | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);

    g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties);

    _nm_setting_class_commit_full(setting_class,
                                  NM_META_SETTING_TYPE_SRIOV,
                                  NULL,
                                  properties_override);
}
