_nib-internal.h

/*
 * Copyright (C) 2017 Freie Universität Berlin
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#ifndef PRIV_NIB_INTERNAL_H
#define PRIV_NIB_INTERNAL_H
 
#include <assert.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
 
#include "bitfield.h"
#include "evtimer_msg.h"
#include "sched.h"
#include "mutex.h"
#include "net/eui64.h"
#include "kernel_defines.h"
#include "net/ipv6/addr.h"
#ifdef MODULE_GNRC_IPV6
#include "net/gnrc/ipv6.h"
#endif
#include "net/gnrc/ipv6/nib/ft.h"
#include "net/gnrc/ipv6/nib/nc.h"
#include "net/gnrc/ipv6/nib/conf.h"
#include "net/gnrc/pktqueue.h"
#include "net/gnrc/sixlowpan/ctx.h"
#include "net/ndp.h"
#include "random.h"
#include "timex.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define _EMPTY  (0x00)      
#define _NC     (0x01)      
#define _DC     (0x02)      
#define _PL     (0x04)      
#define _DRL    (0x08)      
#define _FT     (0x10)      
#define _DAD    (0x20)      
#define _DST    (0x40)      
#define _PFX_ON_LINK    (0x0001)
#define _PFX_SLAAC      (0x0002)
#define _NIB_IF_MASK        (GNRC_IPV6_NIB_NC_INFO_IFACE_MASK)
 
#define _NIB_IF_POS         (GNRC_IPV6_NIB_NC_INFO_IFACE_POS)
 
#define _NIB_IF_MAX         (_NIB_IF_MASK >> _NIB_IF_POS)
 
typedef struct _nib_onl_entry {
    struct _nib_onl_entry *next;        
#if IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_QUEUE_PKT) || defined(DOXYGEN)
    gnrc_pktqueue_t *pktqueue;
#endif
    ipv6_addr_t ipv6;
#if IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_6LR) || defined(DOXYGEN)
    eui64_t eui64;
#endif
#if IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_ARSM) || defined(DOXYGEN)
    uint8_t l2addr[CONFIG_GNRC_IPV6_NIB_L2ADDR_MAX_LEN];
#endif
    evtimer_msg_event_t nud_timeout;
    evtimer_msg_event_t snd_na;
#if IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_ROUTER) || defined(DOXYGEN)
    evtimer_msg_event_t reply_rs;           
#endif
#if IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_6LR) || defined(DOXYGEN)
    evtimer_msg_event_t addr_reg_timeout;   
#endif
 
    uint16_t info;
 
    uint8_t mode;
#if IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_ARSM) || defined(DOXYGEN)
    uint8_t ns_sent;
 
    uint8_t l2addr_len;
#endif
#if IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_QUEUE_PKT) || defined(DOXYGEN)
    uint8_t pktqueue_len; 
#endif
} _nib_onl_entry_t;
 
typedef struct {
    _nib_onl_entry_t *next_hop; 
    evtimer_msg_event_t rtr_timeout;
} _nib_dr_entry_t;
 
typedef struct {
    _nib_onl_entry_t *next_hop; 
    ipv6_addr_t pfx;            
    evtimer_msg_event_t pfx_timeout;
#if IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_ROUTER)
    evtimer_msg_event_t route_timeout;
#endif
    uint8_t mode;               
    uint8_t pfx_len;            
    uint16_t flags;             
    uint32_t valid_until;       
    uint32_t pref_until;        
} _nib_offl_entry_t;
 
typedef struct {
    ipv6_addr_t addr;               
    uint32_t version;               
    uint32_t valid_until_ms;        
    evtimer_msg_event_t timeout;    
    BITFIELD(pfxs, CONFIG_GNRC_IPV6_NIB_OFFL_NUMOF);
    BITFIELD(ctxs, GNRC_SIXLOWPAN_CTX_SIZE);
} _nib_abr_entry_t;
 
extern evtimer_msg_t _nib_evtimer;
 
extern _nib_dr_entry_t *_prime_def_router;
 
uint32_t _evtimer_lookup(const void *ctx, uint16_t type);
 
static inline void _evtimer_del(evtimer_msg_event_t *event)
{
    evtimer_del(&_nib_evtimer, &event->event);
}
 
static inline void _evtimer_add(void *ctx, int16_t type,
                                evtimer_msg_event_t *event, uint32_t offset)
{
#ifdef MODULE_GNRC_IPV6
    kernel_pid_t target_pid = gnrc_ipv6_pid;
#else
    kernel_pid_t target_pid = KERNEL_PID_LAST;  /* just for testing */
#endif
    _evtimer_del(event);
    event->event.next = NULL;
    event->event.offset = offset;
    event->msg.type = type;
    event->msg.content.ptr = ctx;
    evtimer_add_msg(&_nib_evtimer, event, target_pid);
}
 
void _nib_init(void);
 
void _nib_acquire(void);
 
void _nib_release(void);
 
static inline unsigned _nib_onl_get_if(const _nib_onl_entry_t *node)
{
    return (node->info & _NIB_IF_MASK) >> _NIB_IF_POS;
}
 
static inline void _nib_onl_set_if(_nib_onl_entry_t *node, unsigned iface)
{
    assert(iface <= _NIB_IF_MAX);
    node->info &= ~(_NIB_IF_MASK);
    node->info |= ((iface << _NIB_IF_POS) & _NIB_IF_MASK);
}
 
_nib_onl_entry_t *_nib_onl_alloc(const ipv6_addr_t *addr, unsigned iface);
 
static inline bool _nib_onl_clear(_nib_onl_entry_t *node)
{
    if (node->mode == _EMPTY) {
        memset(node, 0, sizeof(_nib_onl_entry_t));
        return true;
    }
    return false;
}
 
_nib_onl_entry_t *_nib_onl_iter(const _nib_onl_entry_t *last);
 
_nib_onl_entry_t *_nib_onl_get(const ipv6_addr_t *addr, unsigned iface);
 
static inline _nib_onl_entry_t *_nib_onl_nc_get(const ipv6_addr_t *addr, unsigned iface)
{
    _nib_onl_entry_t *nce = _nib_onl_get(addr, iface);
    if (nce && (nce->mode & _NC)) {
        return nce;
    }
    return NULL;
}
 
_nib_onl_entry_t *_nib_nc_add(const ipv6_addr_t *addr, unsigned iface,
                              uint16_t cstate);
 
void _nib_nc_remove(_nib_onl_entry_t *node);
 
void _nib_nc_get(const _nib_onl_entry_t *node, gnrc_ipv6_nib_nc_t *nce);
 
void _nib_nc_set_reachable(_nib_onl_entry_t *node);
 
static inline _nib_onl_entry_t *_nib_dad_add(const ipv6_addr_t *addr)
{
    assert(addr != NULL);
    _nib_onl_entry_t *node = _nib_onl_alloc(addr, 0);
 
    if (node != NULL) {
        node->mode |= (_DAD);
    }
    return node;
}
 
static inline void _nib_dad_remove(_nib_onl_entry_t *node)
{
    node->mode &= ~(_DAD);
    _nib_onl_clear(node);
}
 
_nib_dr_entry_t *_nib_drl_add(const ipv6_addr_t *addr, unsigned iface);
 
void _nib_drl_remove(_nib_dr_entry_t *nib_dr);
 
_nib_dr_entry_t *_nib_drl_iter(const _nib_dr_entry_t *last);
 
_nib_dr_entry_t *_nib_drl_get(const ipv6_addr_t *router_addr, unsigned iface);
 
void _nib_drl_ft_get(const _nib_dr_entry_t *drl, gnrc_ipv6_nib_ft_t *fte);
 
_nib_dr_entry_t *_nib_drl_get_dr(void);
 
_nib_offl_entry_t *_nib_offl_alloc(const ipv6_addr_t *next_hop, unsigned iface,
                                   const ipv6_addr_t *pfx, unsigned pfx_len);
 
void _nib_offl_clear(_nib_offl_entry_t *dst);
 
_nib_offl_entry_t *_nib_offl_iter(const _nib_offl_entry_t *last);
 
bool _nib_offl_is_entry(const _nib_offl_entry_t *entry);
 
static inline _nib_offl_entry_t *_nib_offl_add(const ipv6_addr_t *next_hop,
                                               unsigned iface,
                                               const ipv6_addr_t *pfx,
                                               unsigned pfx_len, uint8_t mode)
{
    _nib_offl_entry_t *nib_offl = _nib_offl_alloc(next_hop, iface, pfx, pfx_len);
 
    if (nib_offl != NULL) {
        nib_offl->mode |= mode;
    }
    return nib_offl;
}
 
static inline void _nib_offl_remove(_nib_offl_entry_t *nib_offl, uint8_t mode)
{
    nib_offl->mode &= ~mode;
    _nib_offl_clear(nib_offl);
}
 
#if IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_DC) || DOXYGEN
static inline _nib_offl_entry_t *_nib_dc_add(const ipv6_addr_t *next_hop,
                                             unsigned iface,
                                             const ipv6_addr_t *dst)
{
    assert((next_hop != NULL) && (dst != NULL));
    return _nib_offl_add(next_hop, iface, dst, IPV6_ADDR_BIT_LEN, _DC);
}
 
static inline void _nib_dc_remove(_nib_offl_entry_t *nib_offl)
{
    _nib_offl_remove(nib_offl, _DC);
}
#endif /* CONFIG_GNRC_IPV6_NIB_DC */
 
_nib_offl_entry_t *_nib_pl_add(unsigned iface,
                               const ipv6_addr_t *pfx,
                               unsigned pfx_len,
                               uint32_t valid_ltime,
                               uint32_t pref_ltime);
 
void _nib_pl_remove(_nib_offl_entry_t *nib_offl);
 
void _nib_offl_remove_prefix(_nib_offl_entry_t *pfx);
 
#if IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_ROUTER) || DOXYGEN
static inline _nib_offl_entry_t *_nib_ft_add(const ipv6_addr_t *next_hop,
                                             unsigned iface,
                                             const ipv6_addr_t *pfx,
                                             unsigned pfx_len)
{
    return _nib_offl_add(next_hop, iface, pfx, pfx_len, _FT);
}
 
static inline void _nib_ft_remove(_nib_offl_entry_t *nib_offl)
{
    _evtimer_del(&nib_offl->route_timeout);
    _nib_offl_remove(nib_offl, _FT);
}
#endif  /* CONFIG_GNRC_IPV6_NIB_ROUTER */
 
#if IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_MULTIHOP_P6C) || defined(DOXYGEN)
_nib_abr_entry_t *_nib_abr_add(const ipv6_addr_t *addr);
 
void _nib_abr_remove(const ipv6_addr_t *addr);
 
void _nib_abr_add_pfx(_nib_abr_entry_t *abr, const _nib_offl_entry_t *offl);
 
_nib_offl_entry_t *_nib_abr_iter_pfx(const _nib_abr_entry_t *abr,
                                     const _nib_offl_entry_t *last);
 
_nib_abr_entry_t *_nib_abr_iter(const _nib_abr_entry_t *last);
#else
#define _nib_abr_iter(abr) NULL
#endif
 
void _nib_ft_get(const _nib_offl_entry_t *dst, gnrc_ipv6_nib_ft_t *fte);
 
int _nib_get_route(const ipv6_addr_t *dst, gnrc_pktsnip_t *ctx,
                   gnrc_ipv6_nib_ft_t *entry);
 
#if IS_ACTIVE(CONFIG_GNRC_IPV6_NIB_QUEUE_PKT) || DOXYGEN
void _nbr_flush_pktqueue(_nib_onl_entry_t *node);
 
gnrc_pktqueue_t *_nbr_pop_pkt(_nib_onl_entry_t *node);
 
void _nbr_push_pkt(_nib_onl_entry_t *node, gnrc_pktqueue_t *pkt);
#else
#define _nbr_flush_pktqueue(node) ((void)node)
#define _nbr_pop_pkt(node) ((void)node, NULL)
#define _nbr_push_pkt(node, pkt) ((void)node, (void)pkt)
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* PRIV_NIB_INTERNAL_H */