internal.h

/*
 * SPDX-FileCopyrightText: 2017 Freie Universität Berlin
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#pragma once

 
#include "compiler_hints.h"
#include "modules.h"
#include "net/gnrc/netif.h"
#include "net/l2util.h"
#include "net/netopt.h"
 
#ifdef MODULE_GNRC_IPV6_NIB
#include "net/gnrc/ipv6/nib/conf.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif

#define GNRC_NETIF_PKTQ_DEQUEUE_MSG     (0x1233)

void gnrc_netif_acquire(gnrc_netif_t *netif);

void gnrc_netif_release(gnrc_netif_t *netif);
 
#if IS_USED(MODULE_GNRC_NETIF_IPV6) || DOXYGEN
int gnrc_netif_ipv6_addr_add_internal(gnrc_netif_t *netif,
                                      const ipv6_addr_t *addr,
                                      unsigned pfx_len, uint8_t flags);

void gnrc_netif_ipv6_addr_remove_internal(gnrc_netif_t *netif,
                                          const ipv6_addr_t *addr);

int gnrc_netif_ipv6_addr_idx(gnrc_netif_t *netif,
                             const ipv6_addr_t *addr);

static inline uint8_t gnrc_netif_ipv6_addr_get_state(const gnrc_netif_t *netif,
                                                     int idx)
{
    return netif->ipv6.addrs_flags[idx] & GNRC_NETIF_IPV6_ADDRS_FLAGS_STATE_MASK;
}

static inline uint8_t gnrc_netif_ipv6_addr_dad_trans(const gnrc_netif_t *netif,
                                                     int idx)
{
    return netif->ipv6.addrs_flags[idx] & GNRC_NETIF_IPV6_ADDRS_FLAGS_STATE_TENTATIVE;
}

int gnrc_netif_ipv6_addr_match(gnrc_netif_t *netif,
                               const ipv6_addr_t *addr);

ipv6_addr_t *gnrc_netif_ipv6_addr_best_src(gnrc_netif_t *netif,
                                           const ipv6_addr_t *dst,
                                           bool ll_only);

gnrc_netif_t *gnrc_netif_get_by_ipv6_addr(const ipv6_addr_t *addr);

gnrc_netif_t *gnrc_netif_get_by_prefix(const ipv6_addr_t *prefix);

int gnrc_netif_ipv6_group_join_internal(gnrc_netif_t *netif,
                                        const ipv6_addr_t *addr);

void gnrc_netif_ipv6_group_leave_internal(gnrc_netif_t *netif,
                                          const ipv6_addr_t *addr);

int gnrc_netif_ipv6_group_idx(gnrc_netif_t *netif,
                              const ipv6_addr_t *addr);

static inline void gnrc_netif_ipv6_bus_post(gnrc_netif_t *netif, int type,
                                            const void *ctx)
{
#ifdef MODULE_GNRC_NETIF_BUS
    msg_bus_post(&netif->bus[GNRC_NETIF_BUS_IPV6], type, ctx);
#else
    (void) netif;
    (void) type;
    (void) ctx;
#endif
}
#endif  /* IS_USED(MODULE_GNRC_NETIF_IPV6) || defined(DOXYGEN) */

static inline bool gnrc_netif_is_rtr(const gnrc_netif_t *netif)
{
    if (IS_USED(MODULE_GNRC_IPV6_ROUTER)) {
        return (netif->flags & GNRC_NETIF_FLAGS_IPV6_FORWARDING);
    }
    else {
        return false;
    }
}

static inline bool gnrc_netif_is_rtr_adv(const gnrc_netif_t *netif)
{
    if (IS_USED(MODULE_GNRC_IPV6_ROUTER)) {
        return (netif->flags & GNRC_NETIF_FLAGS_IPV6_RTR_ADV);
    }
    else {
        return false;
    }
}

bool gnrc_netif_dev_is_6lo(const gnrc_netif_t *netif);

static inline bool gnrc_netif_is_6lo(const gnrc_netif_t *netif)
{
    if ((!gnrc_netif_highlander() &&
       IS_USED(MODULE_GNRC_SIXLOWPAN)) || \
       IS_USED(MODULE_GNRC_SIXLOENC)) {
        return gnrc_netif_dev_is_6lo(netif);
    }
    else if (gnrc_netif_highlander() && IS_USED(MODULE_GNRC_SIXLOWPAN)) {
        return true;
    }
    else {
        return false;
    }
}

static inline bool gnrc_netif_is_6ln(const gnrc_netif_t *netif)
{
    if (IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_6LN)) {
        return (netif->flags & GNRC_NETIF_FLAGS_6LN);
    }
    else {
        return false;
    }
}

static inline bool gnrc_netif_is_6lr(const gnrc_netif_t *netif)
{
     /* if flag checkers even evaluate, otherwise just assume their result */
    if (IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_6LR) &&
            (IS_USED(MODULE_GNRC_IPV6_ROUTER) ||
            (!gnrc_netif_highlander()) ||
            !IS_USED(MODULE_GNRC_SIXLOWPAN))) {
        return gnrc_netif_is_rtr(netif) && gnrc_netif_is_6ln(netif);
    }
    else {
        return false;
    }
}

static inline bool gnrc_netif_is_6lbr(const gnrc_netif_t *netif)
{
    if (IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_6LBR)) {
        return (netif->flags & GNRC_NETIF_FLAGS_6LO_ABR) &&
               gnrc_netif_is_6lr(netif);
    }
    else {
        return false;
    }
}

netopt_t gnrc_netif_get_l2addr_opt(const gnrc_netif_t *netif);

ACCESS(read_only, 2, 3)
int gnrc_netif_eui64_from_addr(const gnrc_netif_t *netif,
                               const uint8_t *addr, size_t addr_len,
                               eui64_t *eui64);

static inline int gnrc_netif_get_eui64(gnrc_netif_t *netif, eui64_t *eui64)
{
#if GNRC_NETIF_L2ADDR_MAXLEN > 0
    if (netif->flags & GNRC_NETIF_FLAGS_HAS_L2ADDR) {
        return gnrc_netif_eui64_from_addr(netif,
                                          netif->l2addr, netif->l2addr_len,
                                          eui64);
    }
#endif /* GNRC_NETIF_L2ADDR_MAXLEN > 0 */
    (void)netif;
    (void)eui64;
    return -ENOTSUP;
}

void gnrc_netif_init_6ln(gnrc_netif_t *netif);
 
#if IS_USED(MODULE_GNRC_NETIF_IPV6) || defined(DOXYGEN)
void gnrc_netif_ipv6_init_mtu(gnrc_netif_t *netif);

ACCESS(read_only, 2, 3)
int gnrc_netif_ipv6_iid_from_addr(const gnrc_netif_t *netif,
                                  const uint8_t *addr, size_t addr_len,
                                  eui64_t *iid);

static inline int gnrc_netif_ipv6_iid_to_addr(const gnrc_netif_t *netif,
                                              const eui64_t *iid, uint8_t *addr)
{
    assert(netif->flags & GNRC_NETIF_FLAGS_HAS_L2ADDR);
    return l2util_ipv6_iid_to_addr(netif->device_type, iid, addr);
}

static inline int gnrc_netif_ipv6_get_iid(gnrc_netif_t *netif, eui64_t *iid)
{
#if GNRC_NETIF_L2ADDR_MAXLEN > 0
    if (netif->flags & GNRC_NETIF_FLAGS_HAS_L2ADDR) {
        return gnrc_netif_ipv6_iid_from_addr(netif,
                                             netif->l2addr, netif->l2addr_len,
                                             iid);
    }
#endif /* GNRC_NETIF_L2ADDR_MAXLEN > 0 */
    (void)netif;
    (void)iid;
    return -ENOTSUP;
}

static inline int gnrc_netif_ndp_addr_len_from_l2ao(gnrc_netif_t *netif,
                                                    const ndp_opt_t *opt)
{
    assert(netif->flags & GNRC_NETIF_FLAGS_HAS_L2ADDR);
    return l2util_ndp_addr_len_from_l2ao(netif->device_type, opt);
}

static inline int gnrc_netif_ipv6_group_to_l2_group(gnrc_netif_t *netif,
                                                    const ipv6_addr_t *ipv6_group,
                                                    uint8_t *l2_group)
{
    return l2util_ipv6_group_to_l2_group(netif->device_type, ipv6_group,
                                         l2_group);
}

int gnrc_netif_ipv6_add_prefix(gnrc_netif_t *netif,
                               const ipv6_addr_t *pfx, uint8_t pfx_len,
                               uint32_t valid, uint32_t pref);
#else   /* IS_USED(MODULE_GNRC_NETIF_IPV6) || defined(DOXYGEN) */
#define gnrc_netif_ipv6_init_mtu(netif)                             (void)netif
#define gnrc_netif_ipv6_iid_from_addr(netif, addr, addr_len, iid)   (-ENOTSUP)
#define gnrc_netif_ipv6_iid_to_addr(netif, iid, addr)               (-ENOTSUP)
#define gnrc_netif_ndp_addr_len_from_l2ao(netif, opt)               (-ENOTSUP)
#define gnrc_netif_ipv6_get_iid(netif, iid)                         (-ENOTSUP)
#define gnrc_netif_ipv6_group_to_l2_group(netif, ipv6_group, l2_group)  (-ENOTSUP)
#endif  /* IS_USED(MODULE_GNRC_NETIF_IPV6) || defined(DOXYGEN) */
 
#ifdef __cplusplus
}
#endif