hdr.h

Go to the documentation of this file.

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

 
#include <errno.h>
#include <string.h>
#include <stdint.h>
 
#include "compiler_hints.h"
#include "net/gnrc/netif/internal.h"
#include "net/gnrc/pkt.h"
#include "net/gnrc/pktbuf.h"
#include "net/gnrc/netif.h"
#include "time_units.h"
 
#ifdef __cplusplus
extern "C" {
#endif

#define GNRC_NETIF_HDR_L2ADDR_MAX_LEN   (8)

#define GNRC_NETIF_HDR_L2ADDR_PRINT_LEN (GNRC_NETIF_HDR_L2ADDR_MAX_LEN * 3)

#define GNRC_NETIF_HDR_NO_RSSI          (INT16_MIN)
#define GNRC_NETIF_HDR_NO_LQI           (0)

#define GNRC_NETIF_HDR_FLAGS_BROADCAST  (0x80)

#define GNRC_NETIF_HDR_FLAGS_MULTICAST  (0x40)

#define GNRC_NETIF_HDR_FLAGS_MORE_DATA  (0x10)

#define GNRC_NETIF_HDR_FLAGS_TIMESTAMP  (0x08)

typedef struct {
    uint8_t src_l2addr_len;     
    uint8_t dst_l2addr_len;     
    kernel_pid_t if_pid;        
    uint8_t flags;              
    uint8_t lqi;
    int16_t rssi;
#if IS_USED(MODULE_GNRC_NETIF_TIMESTAMP) || defined(DOXYGEN)
    uint64_t timestamp;
#endif /* MODULE_GNRC_NETIF_TIMESTAMP */
} gnrc_netif_hdr_t;

static inline void gnrc_netif_hdr_init(gnrc_netif_hdr_t *hdr, uint8_t src_l2addr_len,
                                       uint8_t dst_l2addr_len)
{
    hdr->src_l2addr_len = src_l2addr_len;
    hdr->dst_l2addr_len = dst_l2addr_len;
    hdr->if_pid = KERNEL_PID_UNDEF;
    hdr->rssi = GNRC_NETIF_HDR_NO_RSSI;
    hdr->lqi = GNRC_NETIF_HDR_NO_LQI;
    hdr->flags = 0;
}

static inline size_t gnrc_netif_hdr_sizeof(const gnrc_netif_hdr_t *hdr)
{
    return sizeof(gnrc_netif_hdr_t) + hdr->src_l2addr_len + hdr->dst_l2addr_len;
}

static inline uint8_t *gnrc_netif_hdr_get_src_addr(const gnrc_netif_hdr_t *hdr)
{
    return ((uint8_t *)(hdr + 1));
}

ACCESS(read_only, 2, 3)
static inline void gnrc_netif_hdr_set_src_addr(gnrc_netif_hdr_t *hdr,
                                               const uint8_t *addr,
                                               uint8_t addr_len)
{
    if (addr_len != hdr->src_l2addr_len) {
        return;
    }
 
    memcpy(((uint8_t *)(hdr + 1)), addr, addr_len);
}

static inline uint8_t *gnrc_netif_hdr_get_dst_addr(const gnrc_netif_hdr_t *hdr)
{
    return (((uint8_t *)(hdr + 1)) + hdr->src_l2addr_len);
}

ACCESS(read_only, 2, 3)
static inline void gnrc_netif_hdr_set_dst_addr(gnrc_netif_hdr_t *hdr,
                                               const uint8_t *addr,
                                               uint8_t addr_len)
{
    if (addr_len != hdr->dst_l2addr_len) {
        return;
    }
 
    memcpy(((uint8_t *)(hdr + 1)) + hdr->src_l2addr_len, addr, addr_len);
}

static inline void gnrc_netif_hdr_set_timestamp(gnrc_netif_hdr_t *hdr,
                                                uint64_t timestamp)
{
    (void)hdr;
    (void)timestamp;
#if IS_USED(MODULE_GNRC_NETIF_TIMESTAMP)
    hdr->timestamp = timestamp;
    hdr->flags |= GNRC_NETIF_HDR_FLAGS_TIMESTAMP;
#endif
}

static inline int gnrc_netif_hdr_get_timestamp(const gnrc_netif_hdr_t *hdr,
                                               uint64_t *dest)
{
    (void)hdr;
    (void)dest;
#if IS_USED(MODULE_GNRC_NETIF_TIMESTAMP)
    if (hdr->flags & GNRC_NETIF_HDR_FLAGS_TIMESTAMP) {
        *dest = hdr->timestamp;
        return 0;
    }
#endif
    return -1;
}
 
#if defined(MODULE_GNRC_IPV6) || defined(DOXYGEN)
static inline int gnrc_netif_hdr_ipv6_iid_from_src(const gnrc_netif_t *netif,
                                                   const gnrc_netif_hdr_t *hdr,
                                                   eui64_t *iid)
{
    return gnrc_netif_ipv6_iid_from_addr(netif,
                                         gnrc_netif_hdr_get_src_addr(hdr),
                                         hdr->src_l2addr_len,
                                         iid);
}

static inline int gnrc_netif_hdr_ipv6_iid_from_dst(const gnrc_netif_t *netif,
                                                   const gnrc_netif_hdr_t *hdr,
                                                   eui64_t *iid)
{
    return gnrc_netif_ipv6_iid_from_addr(netif,
                                         gnrc_netif_hdr_get_dst_addr(hdr),
                                         hdr->dst_l2addr_len,
                                         iid);
}
#else   /* defined(MODULE_GNRC_IPV6) || defined(DOXYGEN) */
#define gnrc_netif_hdr_ipv6_iid_from_src(netif, hdr, iid)   (-ENOTSUP);
#define gnrc_netif_hdr_ipv6_iid_from_dst(netif, hdr, iid)   (-ENOTSUP);
#endif  /* defined(MODULE_GNRC_IPV6) || defined(DOXYGEN) */

ACCESS(read_only, 1, 2)
ACCESS(read_only, 3, 4)
gnrc_pktsnip_t *gnrc_netif_hdr_build(const uint8_t *src, uint8_t src_len,
                                     const uint8_t *dst, uint8_t dst_len);

static inline gnrc_netif_t *gnrc_netif_hdr_get_netif(const gnrc_netif_hdr_t *hdr)
{
    assert(hdr != NULL);
    return gnrc_netif_get_by_pid(hdr->if_pid);
}

static inline void gnrc_netif_hdr_set_netif(gnrc_netif_hdr_t *hdr,
                                            const gnrc_netif_t *netif)
{
    hdr->if_pid = (netif != NULL) ? netif->pid : KERNEL_PID_UNDEF;
}

void gnrc_netif_hdr_print(gnrc_netif_hdr_t *hdr);

uint8_t gnrc_netif_hdr_get_flag(gnrc_pktsnip_t* pkt);

int gnrc_netif_hdr_get_dstaddr(gnrc_pktsnip_t* pkt, uint8_t** pointer_to_addr);

int gnrc_netif_hdr_get_srcaddr(gnrc_pktsnip_t* pkt, uint8_t** pointer_to_addr);
 
#ifdef __cplusplus
}
#endif