netif.h

Go to the documentation of this file.

/*
 * Copyright (C) 2017-20 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.
 */
 
#pragma once

 
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
 
#include "compiler_hints.h"
#include "event.h"
#include "msg.h"
#include "net/gnrc/netapi.h"
#include "net/gnrc/netif/conf.h"
#include "net/gnrc/netif/flags.h"
#include "net/gnrc/pkt.h"
#include "net/ipv6/addr.h"
#include "net/l2util.h"
#include "net/ndp.h"
#include "net/netdev.h"
#include "net/netif.h"
#include "net/netopt.h"
#include "rmutex.h"
#include "sched.h"
 
#ifdef MODULE_GNRC_NETIF_BUS
#  include "msg_bus.h"
#endif
 
#if IS_USED(MODULE_GNRC_NETIF_LORAWAN)
#  include "net/gnrc/netif/lorawan.h"
#endif
 
#if IS_USED(MODULE_GNRC_NETIF_6LO)
#  include "net/gnrc/netif/6lo.h"
#endif
 
#if defined(MODULE_GNRC_NETIF_DEDUP) && (GNRC_NETIF_L2ADDR_MAXLEN > 0)
#  include "net/gnrc/netif/dedup.h"
#endif
 
#if IS_USED(MODULE_GNRC_NETIF_IPV6)
#  include "net/gnrc/netif/ipv6.h"
#endif
 
#if IS_USED(MODULE_GNRC_NETIF_PKTQ)
#  include "net/gnrc/netif/pktq/type.h"
#endif
 
#ifdef MODULE_NETSTATS_L2
#  include "net/netstats.h"
#endif
 
#ifdef __cplusplus
extern "C" {
#endif

#define GNRC_NETIF_EVQ_INDEX_PRIO_HIGH  (0)

#if IS_USED(MODULE_BHP_EVENT)
#define GNRC_NETIF_EVQ_INDEX_PRIO_LOW   (GNRC_NETIF_EVQ_INDEX_PRIO_HIGH + 1)
#else
#define GNRC_NETIF_EVQ_INDEX_PRIO_LOW   GNRC_NETIF_EVQ_INDEX_PRIO_HIGH
#endif

#define GNRC_NETIF_EVQ_NUMOF            (GNRC_NETIF_EVQ_INDEX_PRIO_LOW + 1)

typedef enum {
#ifdef MODULE_GNRC_IPV6
    GNRC_NETIF_BUS_IPV6,                    
#endif
    GNRC_NETIF_BUS_NUMOF
} gnrc_netif_bus_t;

typedef enum {
    GNRC_IPV6_EVENT_ADDR_VALID,
} gnrc_ipv6_event_t;

typedef struct gnrc_netif_ops gnrc_netif_ops_t;

typedef struct {
    netif_t netif;                          
    const gnrc_netif_ops_t *ops;            
    netdev_t *dev;                          
    rmutex_t mutex;                         
#if IS_USED(MODULE_NETSTATS_L2) || defined(DOXYGEN)
    netstats_t stats;                       
#endif
#if IS_USED(MODULE_GNRC_NETIF_LORAWAN) || defined(DOXYGEN)
    gnrc_netif_lorawan_t lorawan;           
#endif
#if IS_USED(MODULE_GNRC_NETIF_IPV6) || defined(DOXYGEN)
    gnrc_netif_ipv6_t ipv6;                 
#endif
#if IS_USED(MODULE_GNRC_NETIF_BUS) || DOXYGEN
    msg_bus_t bus[GNRC_NETIF_BUS_NUMOF];    
#endif
    uint32_t flags;
    event_queue_t evq[GNRC_NETIF_EVQ_NUMOF];
    event_t event_isr;
#if IS_USED(MODULE_NETDEV_NEW_API) || defined(DOXYGEN)
    event_t event_tx_done;
    gnrc_pktsnip_t *tx_pkt;
#endif
#if (GNRC_NETIF_L2ADDR_MAXLEN > 0) || DOXYGEN
    uint8_t l2addr[GNRC_NETIF_L2ADDR_MAXLEN];

    uint8_t l2addr_len;
#if defined(MODULE_GNRC_NETIF_DEDUP) || DOXYGEN
    gnrc_netif_dedup_t last_pkt;
#endif
#endif
#if IS_USED(MODULE_GNRC_NETIF_6LO) || defined(DOXYGEN)
    gnrc_netif_6lo_t sixlo;                 
#endif
#if IS_USED(MODULE_GNRC_NETIF_PKTQ) || defined(DOXYGEN)
    gnrc_netif_pktq_t send_queue;
#endif
    msg_t msg_queue[GNRC_NETIF_MSG_QUEUE_SIZE];
    uint8_t cur_hl;                         
    uint8_t device_type;                    
    kernel_pid_t pid;                       
} gnrc_netif_t;

static inline bool gnrc_netif_netdev_legacy_api(gnrc_netif_t *netif)
{
    if (!IS_USED(MODULE_NETDEV_NEW_API) && !IS_USED(MODULE_NETDEV_LEGACY_API)) {
        /* this should only happen for external netdevs or when no netdev is
         * used (e.g. examples/networking/coap/gcoap can be used without any netdev, as still
         * CoAP requests to ::1 can be send */
        return true;
    }
 
    if (!IS_USED(MODULE_NETDEV_NEW_API)) {
        return true;
    }
 
    if (!IS_USED(MODULE_NETDEV_LEGACY_API)) {
        return false;
    }
 
    /* both legacy and new API netdevs in use, fall back to runtime test: */
    return (netif->dev->driver->confirm_send == NULL);
}

static inline bool gnrc_netif_netdev_new_api(gnrc_netif_t *netif)
{
    return !gnrc_netif_netdev_legacy_api(netif);
}

struct gnrc_netif_ops {
    int (*init)(gnrc_netif_t *netif);

    int (*send)(gnrc_netif_t *netif, gnrc_pktsnip_t *pkt);

    gnrc_pktsnip_t *(*recv)(gnrc_netif_t *netif);

    int (*get)(gnrc_netif_t *netif, gnrc_netapi_opt_t *opt);

    int (*set)(gnrc_netif_t *netif, const gnrc_netapi_opt_t *opt);

    void (*msg_handler)(gnrc_netif_t *netif, msg_t *msg);
};

void gnrc_netif_init_devs(void);

ACCESS(write_only, 2, 3)
int gnrc_netif_create(gnrc_netif_t *netif, char *stack, int stacksize,
                      char priority, const char *name, netdev_t *dev,
                      const gnrc_netif_ops_t *ops);

unsigned gnrc_netif_numof(void);

static inline bool gnrc_netif_highlander(void)
{
    return IS_USED(MODULE_GNRC_NETIF_SINGLE);
}

gnrc_netif_t *gnrc_netif_iter(const gnrc_netif_t *prev);

gnrc_netif_t *gnrc_netif_get_by_pid(kernel_pid_t pid);

static inline int gnrc_netif_ipv6_addrs_get(const gnrc_netif_t *netif,
                                            ipv6_addr_t *addrs,
                                            size_t max_len)
{
    assert(netif != NULL);
    assert(addrs != NULL);
    assert(max_len >= sizeof(ipv6_addr_t));
    return gnrc_netapi_get(netif->pid, NETOPT_IPV6_ADDR, 0, addrs, max_len);
}

static inline int gnrc_netif_ipv6_addr_add(const gnrc_netif_t *netif,
                                           const ipv6_addr_t *addr, unsigned pfx_len,
                                           uint8_t flags)
{
    assert(netif != NULL);
    assert(addr != NULL);
    assert((pfx_len > 0) && (pfx_len <= 128));
    return gnrc_netapi_set(netif->pid, NETOPT_IPV6_ADDR,
                           ((pfx_len << 8U) | flags), addr,
                           sizeof(ipv6_addr_t));
}

static inline int gnrc_netif_ipv6_addr_remove(const gnrc_netif_t *netif,
                                              const ipv6_addr_t *addr)
{
    assert(netif != NULL);
    assert(addr != NULL);
    return gnrc_netapi_set(netif->pid, NETOPT_IPV6_ADDR_REMOVE,
                           0, addr, sizeof(ipv6_addr_t));
}

static inline int gnrc_netif_ipv6_groups_get(const gnrc_netif_t *netif,
                                             ipv6_addr_t *groups,
                                             size_t max_len)
{
    assert(netif != NULL);
    assert(groups != NULL);
    assert(max_len >= sizeof(ipv6_addr_t));
    return gnrc_netapi_get(netif->pid, NETOPT_IPV6_GROUP, 0, groups, max_len);
}

static inline int gnrc_netif_ipv6_group_join(const gnrc_netif_t *netif,
                                             const ipv6_addr_t *group)
{
    assert(netif != NULL);
    assert(group != NULL);
    return gnrc_netapi_set(netif->pid, NETOPT_IPV6_GROUP, 0, group,
                           sizeof(ipv6_addr_t));
}

static inline int gnrc_netif_ipv6_group_leave(const gnrc_netif_t *netif,
                                              const ipv6_addr_t *group)
{
    assert(netif != NULL);
    assert(group != NULL);
    return gnrc_netapi_set(netif->pid, NETOPT_IPV6_GROUP_LEAVE, 0, group,
                           sizeof(ipv6_addr_t));
}

int gnrc_netif_default_init(gnrc_netif_t *netif);

int gnrc_netif_get_from_netdev(gnrc_netif_t *netif, gnrc_netapi_opt_t *opt);

int gnrc_netif_set_from_netdev(gnrc_netif_t *netif,
                               const gnrc_netapi_opt_t *opt);

gnrc_netif_t *gnrc_netif_get_by_type(netdev_type_t type, uint8_t index);

static inline char *gnrc_netif_addr_to_str(const uint8_t *addr, size_t addr_len, char *out)
{
    return l2util_addr_to_str(addr, addr_len, out);
}

static inline size_t gnrc_netif_addr_from_str(const char *str,
                                              uint8_t out[GNRC_NETIF_L2ADDR_MAXLEN])
{
    return l2util_addr_from_str_sized(str, out, GNRC_NETIF_L2ADDR_MAXLEN );
}

static inline int gnrc_netif_send(gnrc_netif_t *netif, gnrc_pktsnip_t *pkt)
{
    return gnrc_netapi_send(netif->pid, pkt);
}
 
#if defined(MODULE_GNRC_NETIF_BUS) || DOXYGEN
static inline msg_bus_t* gnrc_netif_get_bus(gnrc_netif_t *netif,
                                            gnrc_netif_bus_t type)
{
    assert(type < GNRC_NETIF_BUS_NUMOF);
    return &netif->bus[type];
}

bool gnrc_netif_ipv6_wait_for_global_address(gnrc_netif_t *netif,
                                             uint32_t timeout_ms);
#endif /* MODULE_GNRC_NETIF_BUS */
 
#ifdef __cplusplus
}
#endif