/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2016 - 2017 Red Hat, Inc.
 */

#include <stdlib.h>
#include <unistd.h>
#include <syslog.h>
#include <arpa/inet.h>
#include <linux/if.h>
#include <linux/if_link.h>
#include <linux/ip6_tunnel.h>

#include "libnm-platform/nm-platform.h"
#include "libnm-platform/nmp-object.h"
#include "platform/nm-fake-platform.h"
#include "libnm-platform/nm-linux-platform.h"

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

#define DEVICE_NAME "nm-test-device"

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

#define nmtstp_normalize_jiffies_time(requested_value, kernel_value)                             \
    ({                                                                                           \
        typeof(kernel_value)  _kernel_value    = (kernel_value);                                 \
        typeof(_kernel_value) _requested_value = (requested_value);                              \
                                                                                                 \
        /* kernel stores some values (like bridge's forward_delay) in jiffies. When converting
         * back and forth (clock_t_to_jiffies()/jiffies_to_clock_t()), the value reported back
         * to user space may have rounding errors (of +/- 1), depending on CONFIG_HZ setting.
         *
         * Normalize the requested_value to the kernel_value, if it look as if a rounding
         * error happens. If the difference is larger than +/- 1, no normalization happens! */   \
                                                                                                 \
        ((_requested_value >= (NM_MAX(_kernel_value, 1) - 1))                                    \
         && (_requested_value <= (NM_MIN(_kernel_value, ~((typeof(_kernel_value)) 0) - 1) + 1))) \
            ? _kernel_value                                                                      \
            : _requested_value;                                                                  \
    })

#define _NMLOG_PREFIX_NAME "platform-test"
#define _NMLOG_DOMAIN      LOGD_PLATFORM
#define _NMLOG(level, ...) _LOG(level, _NMLOG_DOMAIN, __VA_ARGS__)

#define _LOG(level, domain, ...)                                                             \
    G_STMT_START                                                                             \
    {                                                                                        \
        const NMLogLevel  __level  = (level);                                                \
        const NMLogDomain __domain = (domain);                                               \
                                                                                             \
        if (nm_logging_enabled(__level, __domain)) {                                         \
            gint64 _ts = nm_utils_get_monotonic_timestamp_nsec();                            \
                                                                                             \
            _nm_log(__level,                                                                 \
                    __domain,                                                                \
                    0,                                                                       \
                    NULL,                                                                    \
                    NULL,                                                                    \
                    "%s[%ld.%09ld]: " _NM_UTILS_MACRO_FIRST(__VA_ARGS__),                    \
                    _NMLOG_PREFIX_NAME,                                                      \
                    (long) (_ts / NM_UTILS_NSEC_PER_SEC),                                    \
                    (long) (_ts % NM_UTILS_NSEC_PER_SEC) _NM_UTILS_MACRO_REST(__VA_ARGS__)); \
        }                                                                                    \
    }                                                                                        \
    G_STMT_END

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

gboolean nmtstp_is_root_test(void);
gboolean nmtstp_is_sysfs_writable(void);

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

typedef struct _NMTstpNamespaceHandle NMTstpNamespaceHandle;

NMTstpNamespaceHandle *nmtstp_namespace_create(int flags, GError **error);

void  nmtstp_namespace_handle_release(NMTstpNamespaceHandle *handle);
pid_t nmtstp_namespace_handle_get_pid(NMTstpNamespaceHandle *handle);

int nmtstp_namespace_get_fd_for_process(pid_t pid, const char *ns_name);

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

void nmtstp_netns_select_random(NMPlatform **platforms, gsize n_platforms, NMPNetns **netns);

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

typedef struct {
    gulong                     handler_id;
    const char *               name;
    NMPlatformSignalChangeType change_type;
    int                        received_count;
    GMainLoop *                loop;
    int                        ifindex;
    const char *               ifname;
} SignalData;

SignalData *add_signal_full(const char *               name,
                            NMPlatformSignalChangeType change_type,
                            GCallback                  callback,
                            int                        ifindex,
                            const char *               ifname);
#define add_signal(name, change_type, callback) \
    add_signal_full(name, change_type, (GCallback) callback, 0, NULL)
#define add_signal_ifindex(name, change_type, callback, ifindex) \
    add_signal_full(name, change_type, (GCallback) callback, ifindex, NULL)
#define add_signal_ifname(name, change_type, callback, ifname) \
    add_signal_full(name, change_type, (GCallback) callback, 0, ifname)
void _accept_signal(const char *file, int line, const char *func, SignalData *data);
void
_accept_signals(const char *file, int line, const char *func, SignalData *data, int min, int max);
void _wait_signal(const char *file, int line, const char *func, SignalData *data);
void _accept_or_wait_signal(const char *file, int line, const char *func, SignalData *data);
void _ensure_no_signal(const char *file, int line, const char *func, SignalData *data);
void _free_signal(const char *file, int line, const char *func, SignalData *data);
#define accept_signal(data) _accept_signal(__FILE__, __LINE__, G_STRFUNC, data)
#define accept_signals(data, min, max) \
    _accept_signals(__FILE__, __LINE__, G_STRFUNC, data, min, max)
#define wait_signal(data)           _wait_signal(__FILE__, __LINE__, G_STRFUNC, data)
#define accept_or_wait_signal(data) _accept_or_wait_signal(__FILE__, __LINE__, G_STRFUNC, data)
#define ensure_no_signal(data)      _ensure_no_signal(__FILE__, __LINE__, G_STRFUNC, data)
#define free_signal(data)           _free_signal(__FILE__, __LINE__, G_STRFUNC, data)

void link_callback(NMPlatform *    platform,
                   int             obj_type_i,
                   int             ifindex,
                   NMPlatformLink *received,
                   int             change_type_i,
                   SignalData *    data);

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

int nmtstp_run_command(const char *format, ...) _nm_printf(1, 2);
#define nmtstp_run_command_check(...)                            \
    do {                                                         \
        g_assert_cmpint(nmtstp_run_command(__VA_ARGS__), ==, 0); \
    } while (0)

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

guint                 nmtstp_wait_for_signal(NMPlatform *platform, gint64 timeout_msec);
guint                 nmtstp_wait_for_signal_until(NMPlatform *platform, gint64 until_ms);
const NMPlatformLink *nmtstp_wait_for_link(NMPlatform *platform,
                                           const char *ifname,
                                           NMLinkType  expected_link_type,
                                           gint64      timeout_msec);
const NMPlatformLink *nmtstp_wait_for_link_until(NMPlatform *platform,
                                                 const char *ifname,
                                                 NMLinkType  expected_link_type,
                                                 gint64      until_ms);

#define nmtstp_assert_wait_for_signal(platform, timeout_msec)    \
    G_STMT_START                                                 \
    {                                                            \
        if (nmtstp_wait_for_signal(platform, timeout_msec) == 0) \
            g_assert_not_reached();                              \
    }                                                            \
    G_STMT_END

#define nmtstp_assert_wait_for_signal_until(platform, until_ms)    \
    G_STMT_START                                                   \
    {                                                              \
        if (nmtstp_wait_for_signal_until(platform, until_ms) == 0) \
            g_assert_not_reached();                                \
    }                                                              \
    G_STMT_END

#define nmtstp_assert_wait_for_link(platform, ifname, expected_link_type, timeout_msec) \
    nmtst_assert_nonnull(nmtstp_wait_for_link(platform, ifname, expected_link_type, timeout_msec))

#define nmtstp_assert_wait_for_link_until(platform, ifname, expected_link_type, until_ms) \
    nmtst_assert_nonnull(nmtstp_wait_for_link_until(platform, ifname, expected_link_type, until_ms))

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

int      nmtstp_run_command_check_external_global(void);
gboolean nmtstp_run_command_check_external(int external_command);

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

const NMPlatformIP4Route *_nmtstp_assert_ip4_route_exists(const char *file,
                                                          guint       line,
                                                          const char *func,
                                                          NMPlatform *platform,
                                                          int         c_exists,
                                                          const char *ifname,
                                                          guint32     network,
                                                          int         plen,
                                                          guint32     metric,
                                                          guint8      tos);
#define nmtstp_assert_ip4_route_exists(platform, c_exists, ifname, network, plen, metric, tos) \
    _nmtstp_assert_ip4_route_exists(__FILE__,                                                  \
                                    __LINE__,                                                  \
                                    G_STRFUNC,                                                 \
                                    platform,                                                  \
                                    c_exists,                                                  \
                                    ifname,                                                    \
                                    network,                                                   \
                                    plen,                                                      \
                                    metric,                                                    \
                                    tos)

const NMPlatformIP4Route *nmtstp_ip4_route_get(NMPlatform *platform,
                                               int         ifindex,
                                               guint32     network,
                                               int         plen,
                                               guint32     metric,
                                               guint8      tos);

const NMPlatformIP6Route *_nmtstp_assert_ip6_route_exists(const char *           file,
                                                          guint                  line,
                                                          const char *           func,
                                                          NMPlatform *           platform,
                                                          int                    c_exists,
                                                          const char *           ifname,
                                                          const struct in6_addr *network,
                                                          guint                  plen,
                                                          guint32                metric,
                                                          const struct in6_addr *src,
                                                          guint8                 src_plen);
#define nmtstp_assert_ip6_route_exists(platform, \
                                       c_exists, \
                                       ifname,   \
                                       network,  \
                                       plen,     \
                                       metric,   \
                                       src,      \
                                       src_plen) \
    _nmtstp_assert_ip6_route_exists(__FILE__,    \
                                    __LINE__,    \
                                    G_STRFUNC,   \
                                    platform,    \
                                    c_exists,    \
                                    ifname,      \
                                    network,     \
                                    plen,        \
                                    metric,      \
                                    src,         \
                                    src_plen)

const NMPlatformIP6Route *nmtstp_ip6_route_get(NMPlatform *           platform,
                                               int                    ifindex,
                                               const struct in6_addr *network,
                                               guint                  plen,
                                               guint32                metric,
                                               const struct in6_addr *src,
                                               guint8                 src_plen);

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

gboolean nmtstp_ip_address_check_lifetime(const NMPlatformIPAddress *addr,
                                          gint64                     now,
                                          guint32                    expected_lifetime,
                                          guint32                    expected_preferred);
void     nmtstp_ip_address_assert_lifetime(const NMPlatformIPAddress *addr,
                                           gint64                     now,
                                           guint32                    expected_lifetime,
                                           guint32                    expected_preferred);

void nmtstp_ip4_address_add(NMPlatform *platform,
                            gboolean    external_command,
                            int         ifindex,
                            in_addr_t   address,
                            int         plen,
                            in_addr_t   peer_address,
                            guint32     lifetime,
                            guint32     preferred,
                            guint32     flags,
                            const char *label);
void nmtstp_ip6_address_add(NMPlatform *    platform,
                            gboolean        external_command,
                            int             ifindex,
                            struct in6_addr address,
                            int             plen,
                            struct in6_addr peer_address,
                            guint32         lifetime,
                            guint32         preferred,
                            guint32         flags);
void nmtstp_ip4_address_del(NMPlatform *platform,
                            gboolean    external_command,
                            int         ifindex,
                            in_addr_t   address,
                            int         plen,
                            in_addr_t   peer_address);
void nmtstp_ip6_address_del(NMPlatform *    platform,
                            gboolean        external_command,
                            int             ifindex,
                            struct in6_addr address,
                            int             plen);

void nmtstp_ip4_route_add(NMPlatform *     platform,
                          int              ifindex,
                          NMIPConfigSource source,
                          in_addr_t        network,
                          guint8           plen,
                          in_addr_t        gateway,
                          in_addr_t        pref_src,
                          guint32          metric,
                          guint32          mss);

void nmtstp_ip6_route_add(NMPlatform *     platform,
                          int              ifindex,
                          NMIPConfigSource source,
                          struct in6_addr  network,
                          guint8           plen,
                          struct in6_addr  gateway,
                          struct in6_addr  pref_src,
                          guint32          metric,
                          guint32          mss);

static inline GPtrArray *
nmtstp_ip4_route_get_all(NMPlatform *platform, int ifindex)
{
    return nm_platform_lookup_object_clone(
        platform,
        NMP_OBJECT_TYPE_IP4_ROUTE,
        ifindex,
        nm_platform_lookup_predicate_routes_main_skip_rtprot_kernel,
        NULL);
}

static inline GPtrArray *
nmtstp_ip6_route_get_all(NMPlatform *platform, int ifindex)
{
    return nm_platform_lookup_object_clone(
        platform,
        NMP_OBJECT_TYPE_IP6_ROUTE,
        ifindex,
        nm_platform_lookup_predicate_routes_main_skip_rtprot_kernel,
        NULL);
}

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

GArray *nmtstp_platform_ip4_address_get_all(NMPlatform *self, int ifindex);
GArray *nmtstp_platform_ip6_address_get_all(NMPlatform *self, int ifindex);

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

const NMPlatformIPAddress *
nmtstp_platform_ip_address_find(NMPlatform *self, int ifindex, int addr_family, gconstpointer addr);

static inline const NMPlatformIP4Address *
nmtstp_platform_ip4_address_find(NMPlatform *self, int ifindex, in_addr_t addr)
{
    return (const NMPlatformIP4Address *)
        nmtstp_platform_ip_address_find(self, ifindex, AF_INET, &addr);
}

static inline const NMPlatformIP6Address *
nmtstp_platform_ip6_address_find(NMPlatform *self, int ifindex, const struct in6_addr *addr)
{
    return (const NMPlatformIP6Address *)
        nmtstp_platform_ip_address_find(self, ifindex, AF_INET6, addr);
}

void _nmtstp_platform_ip_addresses_assert(const char *       filename,
                                          int                lineno,
                                          NMPlatform *       self,
                                          int                ifindex,
                                          gboolean           force_exact_4,
                                          gboolean           force_exact_6,
                                          gboolean           ignore_ll6,
                                          guint              addrs_len,
                                          const char *const *addrs);

#define nmtstp_platform_ip_addresses_assert(self,                                              \
                                            ifindex,                                           \
                                            force_exact_4,                                     \
                                            force_exact_6,                                     \
                                            ignore_ll6,                                        \
                                            ...)                                               \
    _nmtstp_platform_ip_addresses_assert(__FILE__,                                             \
                                         __LINE__,                                             \
                                         (self),                                               \
                                         (ifindex),                                            \
                                         (force_exact_4),                                      \
                                         (force_exact_6),                                      \
                                         (ignore_ll6),                                         \
                                         NM_NARG(__VA_ARGS__),                                 \
                                         ((const char *const[]){"dummy", ##__VA_ARGS__, NULL}) \
                                             + 1)

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

static inline gboolean
_nmtstp_platform_routing_rules_get_all_predicate(const NMPObject *obj, gpointer user_data)
{
    int addr_family = GPOINTER_TO_INT(user_data);

    g_assert(NMP_OBJECT_GET_TYPE(obj) == NMP_OBJECT_TYPE_ROUTING_RULE);

    return addr_family == AF_UNSPEC
           || NMP_OBJECT_CAST_ROUTING_RULE(obj)->addr_family == addr_family;
}

static inline GPtrArray *
nmtstp_platform_routing_rules_get_all(NMPlatform *platform, int addr_family)
{
    NMPLookup lookup;

    g_assert(NM_IS_PLATFORM(platform));
    g_assert(NM_IN_SET(addr_family, AF_UNSPEC, AF_INET, AF_INET6));

    nmp_lookup_init_obj_type(&lookup, NMP_OBJECT_TYPE_ROUTING_RULE);
    return nm_platform_lookup_clone(platform,
                                    &lookup,
                                    _nmtstp_platform_routing_rules_get_all_predicate,
                                    GINT_TO_POINTER(addr_family));
}

static inline guint
nmtstp_platform_routing_rules_get_count(NMPlatform *platform, int addr_family)
{
    const NMDedupMultiHeadEntry *head_entry;
    NMDedupMultiIter             iter;
    const NMPObject *            obj;
    NMPLookup                    lookup;
    guint                        n;

    g_assert(NM_IS_PLATFORM(platform));
    g_assert(NM_IN_SET(addr_family, AF_UNSPEC, AF_INET, AF_INET6));

    nmp_lookup_init_obj_type(&lookup, NMP_OBJECT_TYPE_ROUTING_RULE);
    head_entry = nm_platform_lookup(platform, &lookup);

    n = 0;
    nmp_cache_iter_for_each (&iter, head_entry, &obj) {
        if (_nmtstp_platform_routing_rules_get_all_predicate(obj, GINT_TO_POINTER(addr_family)))
            n++;
    }
    return n;
}

gboolean nmtstp_platform_ip4_route_delete(NMPlatform *platform,
                                          int         ifindex,
                                          in_addr_t   network,
                                          guint8      plen,
                                          guint32     metric);
gboolean nmtstp_platform_ip6_route_delete(NMPlatform *    platform,
                                          int             ifindex,
                                          struct in6_addr network,
                                          guint8          plen,
                                          guint32         metric);

const NMPlatformLink *
nmtstp_link_get_typed(NMPlatform *platform, int ifindex, const char *name, NMLinkType link_type);
const NMPlatformLink *nmtstp_link_get(NMPlatform *platform, int ifindex, const char *name);

gboolean nmtstp_kernel_support_get(NMPlatformKernelSupportType type);

void
nmtstp_link_set_updown(NMPlatform *platform, gboolean external_command, int ifindex, gboolean up);

const NMPlatformLnkBridge *
nmtstp_link_bridge_normalize_jiffies_time(const NMPlatformLnkBridge *requested,
                                          const NMPlatformLnkBridge *kernel,
                                          NMPlatformLnkBridge *      dst);

const NMPlatformLink *nmtstp_link_bridge_add(NMPlatform *               platform,
                                             gboolean                   external_command,
                                             const char *               name,
                                             const NMPlatformLnkBridge *lnk);
const NMPlatformLink *nmtstp_link_veth_add(NMPlatform *platform,
                                           gboolean    external_command,
                                           const char *name,
                                           const char *peer);
const NMPlatformLink *
nmtstp_link_dummy_add(NMPlatform *platform, gboolean external_command, const char *name);
const NMPlatformLink *nmtstp_link_gre_add(NMPlatform *            platform,
                                          gboolean                external_command,
                                          const char *            name,
                                          const NMPlatformLnkGre *lnk);
const NMPlatformLink *nmtstp_link_ip6tnl_add(NMPlatform *               platform,
                                             gboolean                   external_command,
                                             const char *               name,
                                             const NMPlatformLnkIp6Tnl *lnk);
const NMPlatformLink *nmtstp_link_ip6gre_add(NMPlatform *               platform,
                                             gboolean                   external_command,
                                             const char *               name,
                                             const NMPlatformLnkIp6Tnl *lnk);
const NMPlatformLink *nmtstp_link_ipip_add(NMPlatform *             platform,
                                           gboolean                 external_command,
                                           const char *             name,
                                           const NMPlatformLnkIpIp *lnk);
const NMPlatformLink *nmtstp_link_macvlan_add(NMPlatform *                platform,
                                              gboolean                    external_command,
                                              const char *                name,
                                              int                         parent,
                                              const NMPlatformLnkMacvlan *lnk);
const NMPlatformLink *nmtstp_link_sit_add(NMPlatform *            platform,
                                          gboolean                external_command,
                                          const char *            name,
                                          const NMPlatformLnkSit *lnk);
const NMPlatformLink *nmtstp_link_tun_add(NMPlatform *            platform,
                                          gboolean                external_command,
                                          const char *            name,
                                          const NMPlatformLnkTun *lnk,
                                          int *                   out_fd);
const NMPlatformLink *nmtstp_link_vrf_add(NMPlatform *            platform,
                                          gboolean                external_command,
                                          const char *            name,
                                          const NMPlatformLnkVrf *lnk,
                                          gboolean *              out_not_supported);
const NMPlatformLink *nmtstp_link_vxlan_add(NMPlatform *              platform,
                                            gboolean                  external_command,
                                            const char *              name,
                                            const NMPlatformLnkVxlan *lnk);

void nmtstp_link_delete(NMPlatform *platform,
                        gboolean    external_command,
                        int         ifindex,
                        const char *name,
                        gboolean    require_exist);

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

extern int NMTSTP_ENV1_IFINDEX;
extern int NMTSTP_ENV1_EX;

static inline void
_nmtstp_env1_wrapper_setup(const NmtstTestData *test_data)
{
    int *    p_ifindex;
    gpointer p_ifup;

    nmtst_test_data_unpack(test_data, &p_ifindex, NULL, NULL, NULL, &p_ifup);

    g_assert(p_ifindex && *p_ifindex == -1);

    _LOGT("TEST[%s]: setup", test_data->testpath);

    nmtstp_link_delete(NM_PLATFORM_GET, -1, -1, DEVICE_NAME, FALSE);

    g_assert(NMTST_NM_ERR_SUCCESS(nm_platform_link_dummy_add(NM_PLATFORM_GET, DEVICE_NAME, NULL)));

    *p_ifindex = nm_platform_link_get_ifindex(NM_PLATFORM_GET, DEVICE_NAME);
    g_assert_cmpint(*p_ifindex, >, 0);
    g_assert_cmpint(NMTSTP_ENV1_IFINDEX, ==, -1);

    if (GPOINTER_TO_INT(p_ifup))
        g_assert(nm_platform_link_change_flags(NM_PLATFORM_GET, *p_ifindex, IFF_UP, TRUE) >= 0);

    nm_platform_process_events(NM_PLATFORM_GET);

    NMTSTP_ENV1_IFINDEX = *p_ifindex;
    NMTSTP_ENV1_EX      = nmtstp_run_command_check_external_global();
}

static inline void
_nmtstp_env1_wrapper_run(gconstpointer user_data)
{
    const NmtstTestData *test_data = user_data;
    GTestDataFunc        test_func_data;
    GTestFunc            test_func;
    gconstpointer        d;

    nmtst_test_data_unpack(test_data, NULL, &test_func, &test_func_data, &d, NULL);

    _LOGT("TEST[%s]: run", test_data->testpath);
    if (test_func)
        test_func();
    else
        test_func_data(d);
}

static inline void
_nmtstp_env1_wrapper_teardown(const NmtstTestData *test_data)
{
    int *p_ifindex;

    nmtst_test_data_unpack(test_data, &p_ifindex, NULL, NULL, NULL, NULL);

    g_assert_cmpint(NMTSTP_ENV1_IFINDEX, ==, *p_ifindex);
    NMTSTP_ENV1_IFINDEX = -1;

    _LOGT("TEST[%s]: teardown", test_data->testpath);

    g_assert_cmpint(*p_ifindex, ==, nm_platform_link_get_ifindex(NM_PLATFORM_GET, DEVICE_NAME));
    g_assert(nm_platform_link_delete(NM_PLATFORM_GET, *p_ifindex));

    nm_platform_process_events(NM_PLATFORM_GET);

    _LOGT("TEST[%s]: finished", test_data->testpath);

    *p_ifindex = -1;
}

/* add test function, that set's up a particular environment, consisting
 * of a dummy device with ifindex NMTSTP_ENV1_IFINDEX. */
#define _nmtstp_env1_add_test_func_full(testpath, test_func, test_data_func, arg, ifup) \
    nmtst_add_test_func_full(testpath,                                                  \
                             _nmtstp_env1_wrapper_run,                                  \
                             _nmtstp_env1_wrapper_setup,                                \
                             _nmtstp_env1_wrapper_teardown,                             \
                             ({                                                         \
                                 static int _ifindex = -1;                              \
                                 &_ifindex;                                             \
                             }),                                                        \
                             ({                                                         \
                                 GTestFunc _test_func = (test_func);                    \
                                 _test_func;                                            \
                             }),                                                        \
                             ({                                                         \
                                 GTestDataFunc _test_func = (test_data_func);           \
                                 _test_func;                                            \
                             }),                                                        \
                             (arg),                                                     \
                             ({                                                         \
                                 gboolean _ifup = (ifup);                               \
                                 GINT_TO_POINTER(_ifup);                                \
                             }))

#define nmtstp_env1_add_test_func_data(testpath, test_func, arg, ifup) \
    _nmtstp_env1_add_test_func_full(testpath, NULL, test_func, arg, ifup)

#define nmtstp_env1_add_test_func(testpath, test_func, ifup) \
    _nmtstp_env1_add_test_func_full(testpath, test_func, NULL, NULL, ifup)

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

typedef void (*NMTstpSetupFunc)(void);
extern NMTstpSetupFunc const _nmtstp_setup_platform_func;

void nmtstp_setup_platform(void);

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

typedef struct _NMTstpAcdDefender NMTstpAcdDefender;

NMTstpAcdDefender *
nmtstp_acd_defender_new(int ifindex, in_addr_t ip_addr, const NMEtherAddr *mac_addr);

void nmtstp_acd_defender_destroy(NMTstpAcdDefender *defender);

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

void _nmtstp_init_tests(int *argc, char ***argv);
void _nmtstp_setup_tests(void);
