/* SPDX-License-Identifier: GPL-2.0+ */

/*

 * Copyright (C) 2012 - 2017 Red Hat, Inc.

 */

#include "nm-default.h"

#include "nm-fake-platform.h"

#include <unistd.h>

#include <netinet/icmp6.h>

#include <netinet/in.h>

#include <linux/if.h>

#include <linux/rtnetlink.h>

#include "nm-utils.h"

#include "nm-core-utils.h"

#include "nm-platform-utils.h"

#include "nm-platform-private.h"

#include "nmp-object.h"

#include "nm-test-utils-core.h"

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

typedef struct {

    const NMPObject *obj;

    char *           udi;

    struct in6_addr  ip6_lladdr;

} NMFakePlatformLink;

typedef struct {

    GHashTable *options;

    GArray *    links;

} NMFakePlatformPrivate;

struct _NMFakePlatform {

    NMPlatform            parent;

    NMFakePlatformPrivate _priv;

};

struct _NMFakePlatformClass {

    NMPlatformClass parent;

};

G_DEFINE_TYPE(NMFakePlatform, nm_fake_platform, NM_TYPE_PLATFORM)

#define NM_FAKE_PLATFORM_GET_PRIVATE(self) \

    _NM_GET_PRIVATE(self, NMFakePlatform, NM_IS_FAKE_PLATFORM, NMPlatform)

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

#define _NMLOG_PREFIX_NAME "platform-fake"

#define _NMLOG_DOMAIN      LOGD_PLATFORM

#define _NMLOG(level, ...) _LOG(level, _NMLOG_DOMAIN, platform, __VA_ARGS__)

#define _LOG(level, domain, self, ...)                                                        \

    G_STMT_START                                                                              \

    {                                                                                         \

        const NMLogLevel  __level  = (level);                                                 \

        const NMLogDomain __domain = (domain);                                                \

                                                                                              \

        if (nm_logging_enabled(__level, __domain)) {                                          \

            char              __prefix[32];                                                   \

            const char *      __p_prefix = _NMLOG_PREFIX_NAME;                                \

            NMPlatform *const __self     = (self);                                            \

                                                                                              \

            if (__self && nm_platform_get_log_with_ptr(self)) {                               \

                g_snprintf(__prefix, sizeof(__prefix), "%s[%p]", _NMLOG_PREFIX_NAME, __self); \

                __p_prefix = __prefix;                                                        \

            }                                                                                 \

            _nm_log(__level,                                                                  \

                    __domain,                                                                 \

                    0,                                                                        \

                    NULL,                                                                     \

                    NULL,                                                                     \

                    "%s: " _NM_UTILS_MACRO_FIRST(__VA_ARGS__),                                \

                    __p_prefix _NM_UTILS_MACRO_REST(__VA_ARGS__));                            \

        }                                                                                     \

    }                                                                                         \

    G_STMT_END

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

static void link_changed(NMPlatform *        platform,

                         NMFakePlatformLink *device,

                         NMPCacheOpsType     cache_op,

                         const NMPObject *   obj_old);

static gboolean ipx_address_delete(NMPlatform *  platform,

                                   int           addr_family,

                                   int           ifindex,

                                   gconstpointer addr,

                                   const guint8 *plen,

                                   gconstpointer peer_addr);

static gboolean

ipx_route_delete(NMPlatform *platform, int addr_family, int ifindex, const NMPObject *obj);

static gboolean ip6_address_add(NMPlatform *    platform,

                                int             ifindex,

                                struct in6_addr addr,

                                guint8          plen,

                                struct in6_addr peer_addr,

                                guint32         lifetime,

                                guint32         preferred,

                                guint           flags);

static gboolean

ip6_address_delete(NMPlatform *platform, int ifindex, struct in6_addr addr, guint8 plen);

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

#define ASSERT_SYSCTL_ARGS(pathid, dirfd, path)                                                  \

    G_STMT_START                                                                                 \

    {                                                                                            \

        const char *const _pathid = (pathid);                                                    \

        const int         _dirfd  = (dirfd);                                                     \

        const char *const _path   = (path);                                                      \

                                                                                                 \

        g_assert(_path &&_path[0]);                                                              \

        g_assert(!strstr(_path, "/../"));                                                        \

        if (_dirfd < 0) {                                                                        \

            g_assert(!_pathid);                                                                  \

            g_assert(_path[0] == '/');                                                           \

            g_assert(g_str_has_prefix(_path, "/proc/sys/") || g_str_has_prefix(_path, "/sys/")); \

        } else {                                                                                 \

            g_assert_not_reached();                                                              \

        }                                                                                        \

    }                                                                                            \

    G_STMT_END

static gboolean

sysctl_set(NMPlatform *platform, const char *pathid, int dirfd, const char *path, const char *value)

{

    NMFakePlatformPrivate *priv = NM_FAKE_PLATFORM_GET_PRIVATE(platform);

    ASSERT_SYSCTL_ARGS(pathid, dirfd, path);

    g_hash_table_insert(priv->options, g_strdup(path), g_strdup(value));

    return TRUE;

}

static char *

sysctl_get(NMPlatform *platform, const char *pathid, int dirfd, const char *path)

{

    NMFakePlatformPrivate *priv = NM_FAKE_PLATFORM_GET_PRIVATE(platform);

    const char *           v;

    ASSERT_SYSCTL_ARGS(pathid, dirfd, path);

    v = g_hash_table_lookup(priv->options, path);

    if (!v) {

        errno = ENOENT;

        return NULL;

    }

    return g_strdup(v);

}

static NMFakePlatformLink *

link_get(NMPlatform *platform, int ifindex)

{

    NMFakePlatformPrivate *priv = NM_FAKE_PLATFORM_GET_PRIVATE(platform);

    NMFakePlatformLink *   device;

    int                    idx;

    if (ifindex <= 0)

        g_return_val_if_reached(NULL);

    idx = ifindex - 1;

    if (idx >= priv->links->len)

        goto not_found;

    device = &g_array_index(priv->links, NMFakePlatformLink, idx);

    if (!device->obj)

        goto not_found;

    g_assert(ifindex == NMP_OBJECT_CAST_LINK(device->obj)->ifindex);

    g_assert(device->obj == nm_platform_link_get_obj(platform, ifindex, FALSE));

    return device;

not_found:

    _LOGD("link not found: %d", ifindex);

    return NULL;

}

static void

link_add_prepare(NMPlatform *platform, NMFakePlatformLink *device, NMPObject *obj_tmp)

{

    gboolean connected;

    /* we must clear the driver, because platform cache wants to set it */

    g_assert(obj_tmp->link.driver == g_intern_string(obj_tmp->link.driver));

    obj_tmp->link.driver = NULL;

    if (NM_IN_SET(obj_tmp->link.type, NM_LINK_TYPE_BRIDGE, NM_LINK_TYPE_BOND)) {

        connected = FALSE;

        if (NM_FLAGS_HAS(obj_tmp->link.n_ifi_flags, IFF_UP)) {

            NMPLookup        lookup;

            NMDedupMultiIter iter;

            const NMPObject *slave_candidate = NULL;

            nmp_cache_iter_for_each (

                &iter,

                nmp_cache_lookup(nm_platform_get_cache(platform),

                                 nmp_lookup_init_obj_type(&lookup, NMP_OBJECT_TYPE_LINK)),

                &slave_candidate) {

                if (nmp_cache_link_connected_for_slave(obj_tmp->link.ifindex, slave_candidate)) {

                    connected = TRUE;

                    break;

                }

            }

        }

    } else

        connected = NM_FLAGS_HAS(obj_tmp->link.n_ifi_flags, IFF_UP);

    obj_tmp->link.n_ifi_flags = NM_FLAGS_ASSIGN(obj_tmp->link.n_ifi_flags, IFF_LOWER_UP, connected);

    obj_tmp->link.connected   = connected;

}

static NMFakePlatformLink *

link_add_pre(NMPlatform *platform,

             const char *name,

             NMLinkType  type,

             const void *address,

             size_t      address_len,

             guint32     mtu)

{

    NMFakePlatformPrivate *priv = NM_FAKE_PLATFORM_GET_PRIVATE(platform);

    NMFakePlatformLink *   device;

    int                    ifindex;

    NMPObject *            o;

    NMPlatformLink *       link;

    gs_free char *         ip6_lladdr = NULL;

    g_assert(!name || strlen(name) < IFNAMSIZ);

    g_array_set_size(priv->links, priv->links->len + 1);

    device  = &g_array_index(priv->links, NMFakePlatformLink, priv->links->len - 1);

    ifindex = priv->links->len;

    memset(device, 0, sizeof(*device));

    o    = nmp_object_new_link(ifindex);

    link = NMP_OBJECT_CAST_LINK(o);

    ip6_lladdr =

        ifindex > 0 ? g_strdup_printf("fe80::fa1e:%0x:%0x", ifindex / 256, ifindex % 256) : NULL;

    link->ifindex     = name ? ifindex : 0;

    link->type        = type;

    link->kind        = g_intern_string(nm_link_type_to_string(type));

    link->mtu         = mtu;

    link->initialized = TRUE;

    if (name)

        strcpy(link->name, name);

    switch (link->type) {

    case NM_LINK_TYPE_DUMMY:

        link->n_ifi_flags = NM_FLAGS_SET(link->n_ifi_flags, IFF_NOARP);

        break;

    default:

        link->n_ifi_flags = NM_FLAGS_UNSET(link->n_ifi_flags, IFF_NOARP);

        break;

    }

    o->_link.netlink.is_in_netlink = TRUE;

    if (address) {

        g_assert(address_len > 0 && address_len <= sizeof(link->l_address.data));

        memcpy(link->l_address.data, address, address_len);

        link->l_address.len = address_len;

    } else

        g_assert(address_len == 0);

    device->obj        = o;

    device->ip6_lladdr = *nmtst_inet6_from_string(ip6_lladdr);

    return device;

}

static int

link_add(NMPlatform *           platform,

         NMLinkType             type,

         const char *           name,

         int                    parent,

         const void *           address,

         size_t                 address_len,

         guint32                mtu,

         gconstpointer          extra_data,

         const NMPlatformLink **out_link)

{

    NMFakePlatformLink * device;

    NMFakePlatformLink * device_veth             = NULL;

    nm_auto_nmpobj const NMPObject *obj_old      = NULL;

    nm_auto_nmpobj const NMPObject *obj_new      = NULL;

    nm_auto_nmpobj const NMPObject *obj_old_veth = NULL;

    nm_auto_nmpobj const NMPObject *obj_new_veth = NULL;

    NMPCacheOpsType                 cache_op;

    NMPCacheOpsType                 cache_op_veth = NMP_CACHE_OPS_UNCHANGED;

    const char *                    veth_peer     = NULL;

    NMPObject *                     dev_obj;

    NMPObject *                     dev_lnk = NULL;

    device = link_add_pre(platform, name, type, address, address_len, mtu);

    g_assert(device);

    dev_obj = (NMPObject *) device->obj;

    if (parent > 0)

        dev_obj->link.parent = parent;

    else

        g_assert(parent == 0);

    g_assert((parent != 0) == NM_IN_SET(type, NM_LINK_TYPE_VLAN));

    switch (type) {

    case NM_LINK_TYPE_BRIDGE:

    {

        const NMPlatformLnkBridge *props = extra_data;

        g_assert(props);

        dev_lnk = nmp_object_new(NMP_OBJECT_TYPE_LNK_BRIDGE, props);

        break;

    }

    case NM_LINK_TYPE_VETH:

        veth_peer = extra_data;

        g_assert(veth_peer);

        device_veth = link_add_pre(platform, veth_peer, type, NULL, 0, 0);

        break;

    case NM_LINK_TYPE_VLAN:

    {

        const NMPlatformLnkVlan *props = extra_data;

        g_assert(props);

        dev_lnk = nmp_object_new(NMP_OBJECT_TYPE_LNK_VLAN, props);

        break;

    }

    case NM_LINK_TYPE_VXLAN:

    {

        const NMPlatformLnkVxlan *props = extra_data;

        g_assert(props);

        dev_lnk = nmp_object_new(NMP_OBJECT_TYPE_LNK_VXLAN, props);

        break;

    }

    default:

        g_assert(!extra_data);

        break;

    }

    if (dev_lnk)

        dev_obj->_link.netlink.lnk = dev_lnk;

    link_add_prepare(platform, device, (NMPObject *) device->obj);

    cache_op = nmp_cache_update_netlink(nm_platform_get_cache(platform),

                                        (NMPObject *) device->obj,

                                        FALSE,

                                        &obj_old,

                                        &obj_new);

    g_assert(cache_op == NMP_CACHE_OPS_ADDED);

    nmp_object_unref(device->obj);

    device->obj = nmp_object_ref(obj_new);

    if (veth_peer) {

        link_add_prepare(platform, device_veth, (NMPObject *) device_veth->obj);

        cache_op_veth = nmp_cache_update_netlink(nm_platform_get_cache(platform),

                                                 (NMPObject *) device_veth->obj,

                                                 FALSE,

                                                 &obj_old_veth,

                                                 &obj_new_veth);

        g_assert(cache_op == NMP_CACHE_OPS_ADDED);

        nmp_object_unref(device->obj);

        device->obj = nmp_object_ref(obj_new);

    }

    if (out_link)

        *out_link = NMP_OBJECT_CAST_LINK(device->obj);

    link_changed(platform, device, cache_op, NULL);

    if (veth_peer)

        link_changed(platform, device_veth, cache_op_veth, NULL);

    return 0;

}

static NMFakePlatformLink *

link_add_one(NMPlatform *platform,

             const char *name,

             NMLinkType  link_type,

             void (*prepare_fcn)(NMPlatform *        platform,

                                 NMFakePlatformLink *device,

                                 gconstpointer       user_data),

             gconstpointer          user_data,

             const NMPlatformLink **out_link)

{

    NMFakePlatformLink * device;

    nm_auto_nmpobj const NMPObject *obj_old = NULL;

    nm_auto_nmpobj const NMPObject *obj_new = NULL;

    NMPCacheOpsType                 cache_op;

    int                             ifindex;

    device = link_add_pre(platform, name, NM_LINK_TYPE_VLAN, NULL, 0, 0);

    ifindex = NMP_OBJECT_CAST_LINK(device->obj)->ifindex;

    if (prepare_fcn)

        prepare_fcn(platform, device, user_data);

    link_add_prepare(platform, device, (NMPObject *) device->obj);

    cache_op = nmp_cache_update_netlink(nm_platform_get_cache(platform),

                                        (NMPObject *) device->obj,

                                        FALSE,

                                        &obj_old,

                                        &obj_new);

    g_assert(cache_op == NMP_CACHE_OPS_ADDED);

    nmp_object_unref(device->obj);

    device->obj = nmp_object_ref(obj_new);

    link_changed(platform, device, cache_op, obj_old);

    device = link_get(platform, ifindex);

    if (!device)

        g_assert_not_reached();

    NM_SET_OUT(out_link, NMP_OBJECT_CAST_LINK(device->obj));

    return device;

}

static gboolean

link_delete(NMPlatform *platform, int ifindex)

{

    NMFakePlatformLink * device              = link_get(platform, ifindex);

    nm_auto_nmpobj const NMPObject *obj_old  = NULL;

    nm_auto_nmpobj const NMPObject *obj_old2 = NULL;

    NMPCacheOpsType                 cache_op;

    if (!device)

        return FALSE;

    obj_old = g_steal_pointer(&device->obj);

    cache_op = nmp_cache_remove(nm_platform_get_cache(platform), obj_old, FALSE, FALSE, &obj_old2);

    g_assert(cache_op == NMP_CACHE_OPS_REMOVED);

    g_assert(obj_old2);

    g_assert(obj_old == obj_old2);

    /* Remove addresses and routes which belong to the deleted interface */

    ipx_address_delete(platform, AF_INET, ifindex, NULL, NULL, NULL);

    ipx_address_delete(platform, AF_INET6, ifindex, NULL, NULL, NULL);

    ipx_route_delete(platform, AF_INET, ifindex, NULL);

    ipx_route_delete(platform, AF_INET6, ifindex, NULL);

    nm_platform_cache_update_emit_signal(platform, cache_op, obj_old2, NULL);

    return TRUE;

}

static void

link_set_obj(NMPlatform *platform, NMFakePlatformLink *device, NMPObject *obj_tmp)

{

    nm_auto_nmpobj const NMPObject *obj_new = NULL;

    nm_auto_nmpobj const NMPObject *obj_old = NULL;

    nm_auto_nmpobj NMPObject *obj_tmp_tmp   = NULL;

    NMPCacheOpsType           cache_op;

    g_assert(device);

    g_assert(NMP_OBJECT_GET_TYPE(device->obj) == NMP_OBJECT_TYPE_LINK);

    if (!obj_tmp) {

        obj_tmp_tmp = nmp_object_clone(device->obj, FALSE);

        obj_tmp     = obj_tmp_tmp;

    }

    g_assert(NMP_OBJECT_GET_TYPE(obj_tmp) == NMP_OBJECT_TYPE_LINK);

    link_add_prepare(platform, device, obj_tmp);

    cache_op = nmp_cache_update_netlink(nm_platform_get_cache(platform),

                                        obj_tmp,

                                        FALSE,

                                        &obj_old,

                                        &obj_new);

    g_assert(NM_IN_SET(cache_op, NMP_CACHE_OPS_UNCHANGED, NMP_CACHE_OPS_UPDATED));

    g_assert(obj_old == device->obj);

    g_assert(obj_new);

    nmp_object_unref(device->obj);

    device->obj = nmp_object_ref(obj_new);

    link_changed(platform, device, cache_op, obj_old);

}

static void

link_set_flags(NMPlatform *platform, NMFakePlatformLink *device, guint n_ifi_flags)

{

    nm_auto_nmpobj NMPObject *obj_tmp = NULL;

    g_assert(device);

    g_assert(NMP_OBJECT_GET_TYPE(device->obj) == NMP_OBJECT_TYPE_LINK);

    obj_tmp                   = nmp_object_clone(device->obj, FALSE);

    obj_tmp->link.n_ifi_flags = n_ifi_flags;

    link_set_obj(platform, device, obj_tmp);

}

static void

link_changed(NMPlatform *        platform,

             NMFakePlatformLink *device,

             NMPCacheOpsType     cache_op,

             const NMPObject *   obj_old)

{

    g_assert(device->obj);

    g_assert(!nmp_cache_link_connected_needs_toggle(nm_platform_get_cache(platform),

                                                    device->obj,

                                                    NULL,

                                                    NULL));

    nm_platform_cache_update_emit_signal(platform, cache_op, obj_old, device->obj);

    if (!IN6_IS_ADDR_UNSPECIFIED(&device->ip6_lladdr)) {

        if (device->obj->link.connected)

            ip6_address_add(platform,

                            device->obj->link.ifindex,

                            device->ip6_lladdr,

                            64,

                            in6addr_any,

                            NM_PLATFORM_LIFETIME_PERMANENT,

                            NM_PLATFORM_LIFETIME_PERMANENT,

                            0);

        else

            ip6_address_delete(platform, device->obj->link.ifindex, device->ip6_lladdr, 64);

    }

    if (device->obj->link.master) {

        NMFakePlatformLink *master;

        master = link_get(platform, device->obj->link.master);

        link_set_obj(platform, master, NULL);

    }

}

static gboolean

link_set_up(NMPlatform *platform, int ifindex, gboolean *out_no_firmware)

{

    NMFakePlatformLink *device = link_get(platform, ifindex);

    if (out_no_firmware)

        *out_no_firmware = FALSE;

    if (!device) {

        _LOGE("failure changing link: netlink error (No such device)");

        return FALSE;

    }

    link_set_flags(platform, device, NM_FLAGS_ASSIGN(device->obj->link.n_ifi_flags, IFF_UP, TRUE));

    return TRUE;

}

static gboolean

link_set_down(NMPlatform *platform, int ifindex)

{

    NMFakePlatformLink *device = link_get(platform, ifindex);

    if (!device) {

        _LOGE("failure changing link: netlink error (No such device)");

        return FALSE;

    }

    link_set_flags(platform, device, NM_FLAGS_UNSET(device->obj->link.n_ifi_flags, IFF_UP));

    return TRUE;

}

static gboolean

link_set_arp(NMPlatform *platform, int ifindex)

{

    NMFakePlatformLink *device = link_get(platform, ifindex);

    if (!device) {

        _LOGE("failure changing link: netlink error (No such device)");

        return FALSE;

    }

    link_set_flags(platform, device, NM_FLAGS_UNSET(device->obj->link.n_ifi_flags, IFF_NOARP));

    return TRUE;

}

static gboolean

link_set_noarp(NMPlatform *platform, int ifindex)

{

    NMFakePlatformLink *device = link_get(platform, ifindex);

    if (!device) {

        _LOGE("failure changing link: netlink error (No such device)");

        return FALSE;

    }

    link_set_flags(platform, device, NM_FLAGS_SET(device->obj->link.n_ifi_flags, IFF_NOARP));

    return TRUE;

}

static int

link_set_address(NMPlatform *platform, int ifindex, gconstpointer addr, size_t len)

{

    NMFakePlatformLink *device        = link_get(platform, ifindex);

    nm_auto_nmpobj NMPObject *obj_tmp = NULL;

    if (len == 0 || len > NM_UTILS_HWADDR_LEN_MAX || !addr)

        g_return_val_if_reached(-NME_BUG);

    if (!device)

        return -NME_PL_EXISTS;

    obj_tmp                     = nmp_object_clone(device->obj, FALSE);

    obj_tmp->link.l_address.len = len;

    memset(obj_tmp->link.l_address.data, 0, sizeof(obj_tmp->link.l_address.data));

    memcpy(obj_tmp->link.l_address.data, addr, len);

    link_set_obj(platform, device, obj_tmp);

    return 0;

}

static int

link_set_mtu(NMPlatform *platform, int ifindex, guint32 mtu)

{

    NMFakePlatformLink *device        = link_get(platform, ifindex);

    nm_auto_nmpobj NMPObject *obj_tmp = NULL;

    if (!device) {

        _LOGE("failure changing link: netlink error (No such device)");

        return -NME_PL_EXISTS;

    }

    obj_tmp           = nmp_object_clone(device->obj, FALSE);

    obj_tmp->link.mtu = mtu;

    link_set_obj(platform, device, obj_tmp);

    return 0;

}

static gboolean

link_get_driver_info(NMPlatform *platform,

                     int         ifindex,

                     char **     out_driver_name,

                     char **     out_driver_version,

                     char **     out_fw_version)

{

    if (out_driver_name)

        *out_driver_name = NULL;

    if (out_driver_version)

        *out_driver_version = NULL;

    if (out_fw_version)

        *out_fw_version = NULL;

    return TRUE;

}

static gboolean

link_supports_carrier_detect(NMPlatform *platform, int ifindex)

{

    NMFakePlatformLink *device = link_get(platform, ifindex);

    if (!device)

        return FALSE;

    switch (device->obj->link.type) {

    case NM_LINK_TYPE_DUMMY:

        return FALSE;

    default:

        return TRUE;

    }

}

static gboolean

link_supports_vlans(NMPlatform *platform, int ifindex)

{

    NMFakePlatformLink *device = link_get(platform, ifindex);

    if (!device)

        return FALSE;

    switch (device->obj->link.type) {

    case NM_LINK_TYPE_LOOPBACK:

        return FALSE;

    default:

        return TRUE;

    }

}

static gboolean

link_supports_sriov(NMPlatform *platform, int ifindex)

{

    NMFakePlatformLink *device = link_get(platform, ifindex);

    if (!device)

        return FALSE;

    switch (device->obj->link.type) {

    case NM_LINK_TYPE_LOOPBACK:

        return FALSE;

    default:

        return TRUE;

    }

}

static gboolean

link_enslave(NMPlatform *platform, int master, int slave)

{

    NMFakePlatformLink *device        = link_get(platform, slave);

    NMFakePlatformLink *master_device = link_get(platform, master);

    g_return_val_if_fail(device, FALSE);

    g_return_val_if_fail(master_device, FALSE);

    if (device->obj->link.master != master) {

        nm_auto_nmpobj NMPObject *obj_tmp = NULL;

        obj_tmp              = nmp_object_clone(device->obj, FALSE);

        obj_tmp->link.master = master;

        if (NM_IN_SET(master_device->obj->link.type, NM_LINK_TYPE_BOND, NM_LINK_TYPE_TEAM))

            obj_tmp->link.n_ifi_flags = NM_FLAGS_SET(device->obj->link.n_ifi_flags, IFF_UP);

        link_set_obj(platform, device, obj_tmp);

    }

    return TRUE;

}

static gboolean

link_release(NMPlatform *platform, int master_idx, int slave_idx)

{

    NMFakePlatformLink *master        = link_get(platform, master_idx);

    NMFakePlatformLink *slave         = link_get(platform, slave_idx);

    nm_auto_nmpobj NMPObject *obj_tmp = NULL;

    g_return_val_if_fail(master, FALSE);

    g_return_val_if_fail(slave, FALSE);

    if (slave->obj->link.master != master->obj->link.ifindex)

        return FALSE;

    obj_tmp              = nmp_object_clone(slave->obj, FALSE);

    obj_tmp->link.master = 0;

    link_set_obj(platform, slave, obj_tmp);

    return TRUE;

}

static gboolean

link_vlan_change(NMPlatform *            platform,

                 int                     ifindex,

                 NMVlanFlags             flags_mask,

                 NMVlanFlags             flags_set,

                 gboolean                ingress_reset_all,

                 const NMVlanQosMapping *ingress_map,

                 gsize                   n_ingress_map,

                 gboolean                egress_reset_all,

                 const NMVlanQosMapping *egress_map,

                 gsize                   n_egress_map)

{

    return FALSE;

}

struct infiniband_add_data {

    int parent;

    int p_key;

};

static void

_infiniband_add_prepare(NMPlatform *platform, NMFakePlatformLink *device, gconstpointer user_data)

{

    const struct infiniband_add_data *d = user_data;

    NMPObject *                       obj_tmp;

    NMPObject *                       lnk;

    obj_tmp = (NMPObject *) device->obj;

    lnk                       = nmp_object_new(NMP_OBJECT_TYPE_LNK_INFINIBAND, NULL);

    lnk->lnk_infiniband.p_key = d->p_key;

    lnk->lnk_infiniband.mode  = "datagram";

    obj_tmp->link.parent       = d->parent;

    obj_tmp->_link.netlink.lnk = lnk;

}

static gboolean

infiniband_partition_add(NMPlatform *           platform,

                         int                    parent,

                         int                    p_key,

                         const NMPlatformLink **out_link)

{

    NMFakePlatformLink *             parent_device;

    char                             name[IFNAMSIZ];

    const struct infiniband_add_data d = {

        .parent = parent,

        .p_key  = p_key,

    };

    parent_device = link_get(platform, parent);

    g_return_val_if_fail(parent_device != NULL, FALSE);

    nm_utils_new_infiniband_name(name, parent_device->obj->link.name, p_key);

    link_add_one(platform, name, NM_LINK_TYPE_INFINIBAND, _infiniband_add_prepare, &d, out_link);

    return TRUE;

}

static gboolean

infiniband_partition_delete(NMPlatform *platform, int parent, int p_key)

{

    NMFakePlatformLink *parent_device;

    gs_free char *      name = NULL;

    parent_device = link_get(platform, parent);

    g_return_val_if_fail(parent_device != NULL, FALSE);

    nm_utils_new_infiniband_name(name, parent_device->obj->link.name, p_key);

    return link_delete(platform, nm_platform_link_get_ifindex(platform, name));

}

static gboolean

wifi_get_capabilities(NMPlatform *platform, int ifindex, NMDeviceWifiCapabilities *caps)

{

    NMFakePlatformLink *device = link_get(platform, ifindex);

    g_return_val_if_fail(device, FALSE);

    if (device->obj->link.type != NM_LINK_TYPE_WIFI)

        return FALSE;

    if (caps) {

        *caps = (NM_WIFI_DEVICE_CAP_CIPHER_WEP40 | NM_WIFI_DEVICE_CAP_CIPHER_WEP104

                 | NM_WIFI_DEVICE_CAP_CIPHER_TKIP | NM_WIFI_DEVICE_CAP_CIPHER_CCMP

                 | NM_WIFI_DEVICE_CAP_WPA | NM_WIFI_DEVICE_CAP_RSN | NM_WIFI_DEVICE_CAP_AP

                 | NM_WIFI_DEVICE_CAP_ADHOC);

    }

    return TRUE;

}

static gboolean

wifi_get_bssid(NMPlatform *platform, int ifindex, guint8 *bssid)

{

    return FALSE;

}

static guint32

wifi_get_frequency(NMPlatform *platform, int ifindex)

{

    return 0;

}

static int

wifi_get_quality(NMPlatform *platform, int ifindex)

{

    return 0;

}

static guint32

wifi_get_rate(NMPlatform *platform, int ifindex)

{

    return 0;

}

static NM80211Mode

wifi_get_mode(NMPlatform *platform, int ifindex)

{

    return NM_802_11_MODE_UNKNOWN;

}

static void

wifi_set_mode(NMPlatform *platform, int ifindex, NM80211Mode mode)

{

    ;

}

static guint32

wifi_find_frequency(NMPlatform *platform, int ifindex, const guint32 *freqs)

{

    return freqs[0];

}