rte_ip6.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 1982, 1986, 1990, 1993
 *      The Regents of the University of California.
 * Copyright(c) 2010-2014 Intel Corporation.
 * Copyright(c) 2014 6WIND S.A.
 * All rights reserved.
 */

#ifndef _RTE_IP6_H_
#define _RTE_IP6_H_

#include <stdint.h>
#include <string.h>

#ifdef RTE_EXEC_ENV_WINDOWS
#include <ws2tcpip.h>
#else
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/ip6.h>
#endif

#include <rte_byteorder.h>
#include <rte_cksum.h>
#include <rte_ether.h>
#include <rte_mbuf.h>

#ifdef __cplusplus
extern "C" {
#endif

#define RTE_IPV6_ADDR_SIZE 16

#define RTE_IPV6_MAX_DEPTH (RTE_IPV6_ADDR_SIZE * CHAR_BIT)

struct rte_ipv6_addr {
    uint8_t a[RTE_IPV6_ADDR_SIZE];
};

static inline bool
rte_ipv6_addr_eq(const struct rte_ipv6_addr *a, const struct rte_ipv6_addr *b)
{
    return memcmp(a, b, sizeof(*a)) == 0;
}

static inline void
rte_ipv6_addr_mask(struct rte_ipv6_addr *ip, uint8_t depth)
{
    if (depth < RTE_IPV6_MAX_DEPTH) {
        uint8_t d = depth / 8;
        uint8_t mask = ~(UINT8_MAX >> (depth % 8));
        ip->a[d] &= mask;
        d++;
        memset(&ip->a[d], 0, sizeof(*ip) - d);
    }
}

static inline bool
rte_ipv6_addr_eq_prefix(const struct rte_ipv6_addr *a, const struct rte_ipv6_addr *b, uint8_t depth)
{
    if (depth < RTE_IPV6_MAX_DEPTH) {
        uint8_t d = depth / 8;
        uint8_t mask = ~(UINT8_MAX >> (depth % 8));

        if ((a->a[d] ^ b->a[d]) & mask)
            return false;

        return memcmp(a, b, d) == 0;
    }
    return rte_ipv6_addr_eq(a, b);
}

static inline uint8_t
rte_ipv6_mask_depth(const struct rte_ipv6_addr *mask)
{
    uint8_t depth = 0;

    for (unsigned int i = 0; i < RTE_DIM(mask->a); i++) {
        uint8_t m = mask->a[i];
        if (m == 0xff) {
            depth += 8;
        } else {
            while (m & 0x80) {
                m <<= 1;
                depth++;
            }
            break;
        }
    }

    return depth;
}

#if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
#define RTE_IPV6_U16_SPLIT(x) \
    (uint8_t)((uint16_t)(x) & UINT16_C(0xff)), \
    (uint8_t)(((uint16_t)(x) >> 8) & UINT16_C(0xff))
#else
#define RTE_IPV6_U16_SPLIT(x) \
    (uint8_t)(((uint16_t)(x) >> 8) & UINT16_C(0xff)), \
    (uint8_t)((uint16_t)(x) & UINT16_C(0xff))
#endif

#define RTE_IPV6(a, b, c, d, e, f, g, h) \
    {{ \
        RTE_IPV6_U16_SPLIT(a), \
        RTE_IPV6_U16_SPLIT(b), \
        RTE_IPV6_U16_SPLIT(c), \
        RTE_IPV6_U16_SPLIT(d), \
        RTE_IPV6_U16_SPLIT(e), \
        RTE_IPV6_U16_SPLIT(f), \
        RTE_IPV6_U16_SPLIT(g), \
        RTE_IPV6_U16_SPLIT(h) \
    }}

#define RTE_IPV6_ADDR_FMT \
    "%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x:%02x%02x"

#define RTE_IPV6_ADDR_SPLIT(ip) \
    ((uint8_t)(ip)->a[0]), \
    ((uint8_t)(ip)->a[1]), \
    ((uint8_t)(ip)->a[2]), \
    ((uint8_t)(ip)->a[3]), \
    ((uint8_t)(ip)->a[4]), \
    ((uint8_t)(ip)->a[5]), \
    ((uint8_t)(ip)->a[6]), \
    ((uint8_t)(ip)->a[7]), \
    ((uint8_t)(ip)->a[8]), \
    ((uint8_t)(ip)->a[9]), \
    ((uint8_t)(ip)->a[10]), \
    ((uint8_t)(ip)->a[11]), \
    ((uint8_t)(ip)->a[12]), \
    ((uint8_t)(ip)->a[13]), \
    ((uint8_t)(ip)->a[14]), \
    ((uint8_t)(ip)->a[15])

#define RTE_IPV6_MASK_FULL \
    RTE_IPV6(0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff)

#define RTE_IPV6_ADDR_UNSPEC RTE_IPV6(0, 0, 0, 0, 0, 0, 0, 0)

static inline bool
rte_ipv6_addr_is_unspec(const struct rte_ipv6_addr *ip)
{
    const struct rte_ipv6_addr unspec = RTE_IPV6_ADDR_UNSPEC;
    return rte_ipv6_addr_eq(ip, &unspec);
}

#define RTE_IPV6_ADDR_LOOPBACK RTE_IPV6(0, 0, 0, 0, 0, 0, 0, 1)

static inline bool
rte_ipv6_addr_is_loopback(const struct rte_ipv6_addr *ip)
{
    struct rte_ipv6_addr loopback = RTE_IPV6_ADDR_LOOPBACK;
    return rte_ipv6_addr_eq(ip, &loopback);
}

static inline bool
rte_ipv6_addr_is_linklocal(const struct rte_ipv6_addr *ip)
{
    return ip->a[0] == 0xfe && (ip->a[1] & 0xc0) == 0x80;
}

static inline bool
rte_ipv6_addr_is_sitelocal(const struct rte_ipv6_addr *ip)
{
    return ip->a[0] == 0xfe && (ip->a[1] & 0xc0) == 0xc0;
}

static inline bool
rte_ipv6_addr_is_v4compat(const struct rte_ipv6_addr *ip)
{
    const struct rte_ipv6_addr unspec = RTE_IPV6_ADDR_UNSPEC;
    return rte_ipv6_addr_eq_prefix(ip, &unspec, 32) && !rte_ipv6_addr_is_loopback(ip);
}

#define RTE_IPV6_ADDR_PREFIX_V4MAPPED RTE_IPV6(0, 0, 0, 0, 0, 0xffff, 0, 0)

static inline bool
rte_ipv6_addr_is_v4mapped(const struct rte_ipv6_addr *ip)
{
    const struct rte_ipv6_addr prefix = RTE_IPV6_ADDR_PREFIX_V4MAPPED;
    return rte_ipv6_addr_eq_prefix(ip, &prefix, 32);
}

static inline bool
rte_ipv6_addr_is_mcast(const struct rte_ipv6_addr *ip)
{
    return ip->a[0] == 0xff;
}

enum rte_ipv6_mc_scope {
    RTE_IPV6_MC_SCOPE_NONE = 0x00,
    RTE_IPV6_MC_SCOPE_IFACELOCAL = 0x01,
    RTE_IPV6_MC_SCOPE_LINKLOCAL = 0x02,
    RTE_IPV6_MC_SCOPE_SITELOCAL = 0x05,
    RTE_IPV6_MC_SCOPE_ORGLOCAL = 0x08,
    RTE_IPV6_MC_SCOPE_GLOBAL = 0x0e,
} __rte_packed;

static inline enum rte_ipv6_mc_scope
rte_ipv6_mc_scope(const struct rte_ipv6_addr *ip)
{
    if (!rte_ipv6_addr_is_mcast(ip))
        return RTE_IPV6_MC_SCOPE_NONE;
    return (enum rte_ipv6_mc_scope)(ip->a[1] & 0x0f);
}

#define RTE_IPV6_ADDR_ALLNODES_IFACE_LOCAL RTE_IPV6(0xff01, 0, 0, 0, 0, 0, 0, 1)

#define RTE_IPV6_ADDR_ALLNODES_LINK_LOCAL RTE_IPV6(0xff02, 0, 0, 0, 0, 0, 0, 1)

#define RTE_IPV6_ADDR_ALLROUTERS_IFACE_LOCAL RTE_IPV6(0xff01, 0, 0, 0, 0, 0, 0, 2)

#define RTE_IPV6_ADDR_ALLROUTERS_LINK_LOCAL RTE_IPV6(0xff02, 0, 0, 0, 0, 0, 0, 2)

#define RTE_IPV6_ADDR_ALLROUTERS_SITE_LOCAL RTE_IPV6(0xff05, 0, 0, 0, 0, 0, 0, 2)

/*
 * Generate a link-local IPv6 address from an Ethernet address as specified in
 * RFC 2464, section 5.
 *
 * @param[out] ip
 *   The link-local IPv6 address to generate.
 * @param[in] mac
 *   An Ethernet address.
 */
static inline void
rte_ipv6_llocal_from_ethernet(struct rte_ipv6_addr *ip, const struct rte_ether_addr *mac)
{
    ip->a[0] = 0xfe;
    ip->a[1] = 0x80;
    memset(&ip->a[2], 0, 6);
    ip->a[8] = mac->addr_bytes[0];
    ip->a[9] = mac->addr_bytes[1];
    ip->a[10] = mac->addr_bytes[2];
    ip->a[11] = 0xff;
    ip->a[12] = 0xfe;
    ip->a[13] = mac->addr_bytes[3];
    ip->a[14] = mac->addr_bytes[4];
    ip->a[15] = mac->addr_bytes[5];
}

static inline void
rte_ipv6_solnode_from_addr(struct rte_ipv6_addr *sol, const struct rte_ipv6_addr *ip)
{
    sol->a[0] = 0xff;
    sol->a[1] = 0x02;
    memset(&sol->a[2], 0, 9);
    sol->a[11] = 0x01;
    sol->a[12] = 0xff;
    sol->a[13] = ip->a[13];
    sol->a[14] = ip->a[14];
    sol->a[15] = ip->a[15];
}

static inline void
rte_ether_mcast_from_ipv6(struct rte_ether_addr *mac, const struct rte_ipv6_addr *ip)
{
    mac->addr_bytes[0] = 0x33;
    mac->addr_bytes[1] = 0x33;
    mac->addr_bytes[2] = ip->a[12];
    mac->addr_bytes[3] = ip->a[13];
    mac->addr_bytes[4] = ip->a[14];
    mac->addr_bytes[5] = ip->a[15];
}

struct rte_ipv6_hdr {
    union {
        rte_be32_t vtc_flow;        
        __extension__
        struct {
#if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
            uint32_t flow_label:20; 
            uint32_t ecn:2;         
            uint32_t ds:6;          
            uint32_t version:4;     
#elif RTE_BYTE_ORDER == RTE_BIG_ENDIAN
            uint32_t version:4;     
            uint32_t ds:6;          
            uint32_t ecn:2;         
            uint32_t flow_label:20; 
#endif
        };
    };
    rte_be16_t payload_len; 
    uint8_t  proto;     
    uint8_t  hop_limits;    
    struct rte_ipv6_addr src_addr;  
    struct rte_ipv6_addr dst_addr;  
} __rte_packed;

static inline int rte_ipv6_check_version(const struct rte_ipv6_hdr *ip)
{
    uint8_t version = ((const uint8_t *)ip)[0];
    if ((version & 0xf0) != 0x60)
        return -EINVAL;
    return 0;
}

/* IPv6 routing extension type definition. */
#define RTE_IPV6_SRCRT_TYPE_4 4

struct rte_ipv6_routing_ext {
    uint8_t next_hdr;           
    uint8_t hdr_len;            
    uint8_t type;               
    uint8_t segments_left;          
    __extension__
    union {
        rte_be32_t flags;       
        struct {
            uint8_t last_entry; 
            uint8_t flag;       
            rte_be16_t tag;     
        };
    };
    /* Next are 128-bit IPv6 address fields to describe segments. */
} __rte_packed;

/* IPv6 vtc_flow: IPv / TC / flow_label */
#define RTE_IPV6_HDR_FL_SHIFT 0
#define RTE_IPV6_HDR_TC_SHIFT 20
#define RTE_IPV6_HDR_FL_MASK    ((1u << RTE_IPV6_HDR_TC_SHIFT) - 1)
#define RTE_IPV6_HDR_TC_MASK    (0xff << RTE_IPV6_HDR_TC_SHIFT)
#define RTE_IPV6_HDR_DSCP_MASK  (0xfc << RTE_IPV6_HDR_TC_SHIFT)
#define RTE_IPV6_HDR_ECN_MASK   (0x03 << RTE_IPV6_HDR_TC_SHIFT)
#define RTE_IPV6_HDR_ECN_CE RTE_IPV6_HDR_ECN_MASK

#define RTE_IPV6_MIN_MTU 1280 
static inline uint16_t
rte_ipv6_phdr_cksum(const struct rte_ipv6_hdr *ipv6_hdr, uint64_t ol_flags)
{
    uint32_t sum;
    struct {
        rte_be32_t len;   /* L4 length. */
        rte_be32_t proto; /* L4 protocol - top 3 bytes must be zero */
    } psd_hdr;

    psd_hdr.proto = (uint32_t)(ipv6_hdr->proto << 24);
    if (ol_flags & (RTE_MBUF_F_TX_TCP_SEG | RTE_MBUF_F_TX_UDP_SEG))
        psd_hdr.len = 0;
    else
        psd_hdr.len = ipv6_hdr->payload_len;

    sum = __rte_raw_cksum(&ipv6_hdr->src_addr,
        sizeof(ipv6_hdr->src_addr) + sizeof(ipv6_hdr->dst_addr),
        0);
    sum = __rte_raw_cksum(&psd_hdr, sizeof(psd_hdr), sum);
    return __rte_raw_cksum_reduce(sum);
}

static inline uint16_t
__rte_ipv6_udptcp_cksum(const struct rte_ipv6_hdr *ipv6_hdr, const void *l4_hdr)
{
    uint32_t cksum;
    uint32_t l4_len;

    l4_len = rte_be_to_cpu_16(ipv6_hdr->payload_len);

    cksum = rte_raw_cksum(l4_hdr, l4_len);
    cksum += rte_ipv6_phdr_cksum(ipv6_hdr, 0);

    cksum = ((cksum & 0xffff0000) >> 16) + (cksum & 0xffff);

    return (uint16_t)cksum;
}

static inline uint16_t
rte_ipv6_udptcp_cksum(const struct rte_ipv6_hdr *ipv6_hdr, const void *l4_hdr)
{
    uint16_t cksum = __rte_ipv6_udptcp_cksum(ipv6_hdr, l4_hdr);

    cksum = ~cksum;

    /*
     * Per RFC 768: If the computed checksum is zero for UDP,
     * it is transmitted as all ones
     * (the equivalent in one's complement arithmetic).
     */
    if (cksum == 0 && ipv6_hdr->proto == IPPROTO_UDP)
        cksum = 0xffff;

    return cksum;
}

static inline uint16_t
__rte_ipv6_udptcp_cksum_mbuf(const struct rte_mbuf *m,
                 const struct rte_ipv6_hdr *ipv6_hdr,
                 uint16_t l4_off)
{
    uint16_t raw_cksum;
    uint32_t cksum;

    if (unlikely(l4_off > m->pkt_len))
        return 0; /* invalid params, return a dummy value */

    if (rte_raw_cksum_mbuf(m, l4_off, rte_be_to_cpu_16(ipv6_hdr->payload_len), &raw_cksum))
        return 0;

    cksum = raw_cksum + rte_ipv6_phdr_cksum(ipv6_hdr, 0);

    cksum = ((cksum & 0xffff0000) >> 16) + (cksum & 0xffff);

    return (uint16_t)cksum;
}

static inline uint16_t
rte_ipv6_udptcp_cksum_mbuf(const struct rte_mbuf *m,
               const struct rte_ipv6_hdr *ipv6_hdr, uint16_t l4_off)
{
    uint16_t cksum = __rte_ipv6_udptcp_cksum_mbuf(m, ipv6_hdr, l4_off);

    cksum = ~cksum;

    /*
     * Per RFC 768: If the computed checksum is zero for UDP,
     * it is transmitted as all ones
     * (the equivalent in one's complement arithmetic).
     */
    if (cksum == 0 && ipv6_hdr->proto == IPPROTO_UDP)
        cksum = 0xffff;

    return cksum;
}

static inline int
rte_ipv6_udptcp_cksum_verify(const struct rte_ipv6_hdr *ipv6_hdr,
                 const void *l4_hdr)
{
    uint16_t cksum = __rte_ipv6_udptcp_cksum(ipv6_hdr, l4_hdr);

    if (cksum != 0xffff)
        return -1;

    return 0;
}

static inline int
rte_ipv6_udptcp_cksum_mbuf_verify(const struct rte_mbuf *m,
                  const struct rte_ipv6_hdr *ipv6_hdr,
                  uint16_t l4_off)
{
    uint16_t cksum = __rte_ipv6_udptcp_cksum_mbuf(m, ipv6_hdr, l4_off);

    if (cksum != 0xffff)
        return -1;

    return 0;
}

#define RTE_IPV6_EHDR_MF_SHIFT  0
#define RTE_IPV6_EHDR_MF_MASK   1
#define RTE_IPV6_EHDR_FO_SHIFT  3
#define RTE_IPV6_EHDR_FO_MASK   (~((1 << RTE_IPV6_EHDR_FO_SHIFT) - 1))
#define RTE_IPV6_EHDR_FO_ALIGN  (1 << RTE_IPV6_EHDR_FO_SHIFT)

#define RTE_IPV6_FRAG_USED_MASK (RTE_IPV6_EHDR_MF_MASK | RTE_IPV6_EHDR_FO_MASK)

#define RTE_IPV6_GET_MF(x)  ((x) & RTE_IPV6_EHDR_MF_MASK)
#define RTE_IPV6_GET_FO(x)  ((x) >> RTE_IPV6_EHDR_FO_SHIFT)

#define RTE_IPV6_SET_FRAG_DATA(fo, mf)  \
    (((fo) & RTE_IPV6_EHDR_FO_MASK) | ((mf) & RTE_IPV6_EHDR_MF_MASK))

struct rte_ipv6_fragment_ext {
    uint8_t next_header;    
    uint8_t reserved;   
    rte_be16_t frag_data;   
    rte_be32_t id;      
} __rte_packed;

/* IPv6 fragment extension header size */
#define RTE_IPV6_FRAG_HDR_SIZE  sizeof(struct rte_ipv6_fragment_ext)

static inline int
rte_ipv6_get_next_ext(const uint8_t *p, int proto, size_t *ext_len)
{
    int next_proto;

    switch (proto) {
    case IPPROTO_AH:
        next_proto = *p++;
        *ext_len = (*p + 2) * sizeof(uint32_t);
        break;

    case IPPROTO_HOPOPTS:
    case IPPROTO_ROUTING:
    case IPPROTO_DSTOPTS:
        next_proto = *p++;
        *ext_len = (*p + 1) * sizeof(uint64_t);
        break;

    case IPPROTO_FRAGMENT:
        next_proto = *p;
        *ext_len = RTE_IPV6_FRAG_HDR_SIZE;
        break;

    default:
        return -EINVAL;
    }

    return next_proto;
}

#ifdef __cplusplus
}
#endif

#endif /* _RTE_IP6_H_ */