cnet_netif.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2016-2022 Intel Corporation
 */
 
#ifndef __CNET_NETIF_H
#define __CNET_NETIF_H
 
#include <net/if.h>
#include <cne_atomic.h>
#include <pktdev.h>
#include <cne_inet.h>        // for inet_addr_mask_cmp, inet_ntop4
#include <stddef.h>          // for NULL
#include <stdint.h>          // for uint64_t, uint8_t, uint16_t, uint32_t, int32_t
 
#include "cne_common.h"        // for __cne_cache_aligned
#include "cne_log.h"           // for CNE_LOG, CNE_LOG_DEBUG, CNE_LOG_WARNING
#include "cne_lport.h"         // for lport_stats
#include "cne_vec.h"           // for vec_at_index, vec_pool_free
#include "cnet_const.h"        // for iofunc_t
#include "cne_inet.h"          // for _in_addr, _in6_addr
#include "cnet_stk.h"          // for stk_entry, per_thread_stk, this_stk
#include "mempool.h"           // for mempool_get, mempool_obj_iter, mempool_put
#include "pktmbuf.h"           // for pktmbuf_t
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum { NETIF_IFNAME_TYPE, NETIF_NETDEV_NAME_TYPE };
 
enum { PRIMARY_IPADDR = 0, DEFAULT_FORWARDING_STATE = 1, NUM_IP_ADDRS = 8 };
 
/* Network interface flags */
enum {
    _IFF_UP           = 0x00000001, /* interface link is up */
    _IFF_BROADCAST    = 0x00000002, /* broadcast address valid */
    _IFF_DEBUG        = 0x00000004, /* turn on debugging */
    _IFF_LOOPBACK     = 0x00000008, /* is a loopback net */
    _IFF_POINTOPOINT  = 0x00000010, /* interface is p2p link */
    _IFF_SMART        = 0x00000020, /* interface manages own routes */
    _IFF_RUNNING      = 0x00000040, /* resources allocated */
    _IFF_NOARP        = 0x00000080, /* no address resolution protocol */
    _IFF_PROMISC      = 0x00000100, /* receive all packets */
    _IFF_ALLMULTI     = 0x00000200, /* receive all multicast packets */
    _IFF_OACTIVE      = 0x00000400, /* transmission in progress */
    _IFF_SIMPLEX      = 0x00000800, /* can't hear own transmissions */
    _IFF_LINK0        = 0x00001000, /* forwarding disabled */
    _IFF_LINK1        = 0x00002000, /* per link layer defined bit */
    _IFF_LINK2        = 0x00004000, /* per link layer defined bit */
    _IFF_MULTICAST    = 0x00008000, /* supports multicast */
    _IFF_NOTRAILERS   = 0x00020000, /* avoid use of trailers */
    _IFF_INET_UP      = 0x00040000, /* interface is up for ipv4 */
    _IFF_INET6_UP     = 0x00080000, /* interface is up for ipv6 */
    _IFF_RARP         = 0x00100000, /* RARP enabled on this interface */
    _IFF_DONT_FORWARD = 0x00200000  /* Not allowed to forward packets */
};
 
struct netif;
struct drv_entry;
 
/* Structure to contain all of the IPv4 Addresses */
struct inet4_addr {
    uint16_t valid;
    uint16_t prefixlen;
    struct in_addr ip;
    struct in_addr netmask;
    struct in_addr broadcast;
};
 
struct netif {
    int16_t netif_idx;                         
    uint16_t lpid;                             
    int ifflags;                               
    int ifindex;                               
    uint16_t ip_ident;                         
    uint16_t family;                           
    uint16_t mtu;                              
    char ifname[IF_NAMESIZE + 1];              
    char netdev_name[IF_NAMESIZE + 1];         
    struct drv_entry *drv;                     
    struct rt4_entry *rt_cached;               
    struct inet4_addr ip4_addrs[NUM_IP_ADDRS]; 
    struct ether_addr mac;                     
} __cne_cache_aligned;
 
#define _IFF_UP           0x00000001 
#define _IFF_BROADCAST    0x00000002 
#define _IFF_DEBUG        0x00000004 
#define _IFF_LOOPBACK     0x00000008 
#define _IFF_POINTOPOINT  0x00000010 
#define _IFF_SMART        0x00000020 
#define _IFF_RUNNING      0x00000040 
#define _IFF_NOARP        0x00000080 
#define _IFF_PROMISC      0x00000100 
#define _IFF_ALLMULTI     0x00000200 
#define _IFF_OACTIVE      0x00000400 
#define _IFF_SIMPLEX      0x00000800 
#define _IFF_LINK0        0x00001000 
#define _IFF_LINK1        0x00002000 
#define _IFF_LINK2        0x00004000 
#define _IFF_MULTICAST    0x00008000 
#define _IFF_NOTRAILERS   0x00020000 
#define _IFF_INET_UP      0x00040000 
#define _IFF_INET6_UP     0x00080000 
#define _IFF_RARP         0x00100000 
#define _IFF_DONT_FORWARD 0x00200000 
#define _ipv4_broadcast_compare(_i)                                  \
    do {                                                             \
        if (netif->ip4_addrs[_i].ip.s_addr) {                        \
            if (ip->s_addr == netif->ip4_addrs[_i].broadcast.s_addr) \
                return _i;                                           \
        }                                                            \
    } while (/*CONSTCOND*/ 0)
 
static inline int
cnet_ipv4_broadcast(struct netif *netif, struct in_addr *ip)
{
    if (NUM_IP_ADDRS == 4) {
        _ipv4_broadcast_compare(0);
        _ipv4_broadcast_compare(1);
        _ipv4_broadcast_compare(2);
        _ipv4_broadcast_compare(3);
        return -1;
    }
    for (int i = 0; i < NUM_IP_ADDRS; i++)
        _ipv4_broadcast_compare(i);
    return -1;
}
 
#define _ipv4_compare(_i)                         \
    do {                                          \
        struct in_addr *ip2, *mask;               \
        ip2  = &netif->ip4_addrs[_i].ip;          \
        mask = &netif->ip4_addrs[_i].netmask;     \
        if (inet_addr_mask_cmp(&addr, ip2, mask)) \
            return _i;                            \
    } while (/*CONSTCOND*/ 0)
 
static inline int
cnet_ipv4_compare(struct netif *netif, struct in_addr *ip)
{
    struct in_addr addr;
 
    addr.s_addr = ntohl(ip->s_addr);
    if (NUM_IP_ADDRS == 4) {
        _ipv4_compare(0);
        _ipv4_compare(1);
        _ipv4_compare(2);
        _ipv4_compare(3);
        return -1;
    }
    for (int i = 0; i < NUM_IP_ADDRS; i++)
        _ipv4_compare(i);
 
    return -1;
}
 
static inline struct netif *
cnet_netif_from_index(uint8_t idx)
{
    return vec_at_index(this_cnet->netifs, idx);
}
 
static inline struct netif *
cnet_netif_match_subnet(struct in_addr *ipaddr)
{
    struct netif **netif;
 
    vec_foreach (netif, this_cnet->netifs) {
        if (cnet_ipv4_compare(*netif, ipaddr) != -1)
            return *netif;
    }
    return NULL;
}
 
static inline void
cnet_netif_free(struct netif *netif)
{
    if (netif) {
        if (netif->netif_idx >= 0 && netif->netif_idx < CNE_MAX_ETHPORTS)
            vec_at_index(this_cnet->netifs, netif->netif_idx) = NULL;
        free(netif);
    }
}
 
static inline struct netif *
cnet_netif_alloc(uint16_t lpid)
{
    struct netif *netif = NULL;
 
    netif = calloc(1, sizeof(struct netif));
    if (!netif)
        return NULL;
 
    netif->netif_idx = -1;
    netif->ifindex   = -1;
    netif->lpid      = lpid;
    netif->ip_ident  = (uint16_t)(cne_rdtsc() & 0xFFFF);
 
    return netif;
}
 
static inline int
cnet_netif_get_flags(struct netif *netif, uint32_t *flags)
{
    if (!flags || !netif)
        return -1;
 
    *flags = netif->ifflags;
 
    return 0;
}
 
CNDP_API int cnet_netif_register(uint16_t lpid, char *ifname, char *netdev);
 
CNDP_API int cnet_netif_attach_ports(struct cnet *cnet);
 
CNDP_API struct netif *cnet_netif_from_name(const char *name, int typ);
 
CNDP_API int cnet_netif_set_mtu(struct netif *netif, uint16_t mtu);
 
CNDP_API int cnet_netif_foreach(int (*func)(struct netif *netif, void *arg), void *arg);
 
CNDP_API struct inet4_addr *cnet_ipv4_ipaddr_find(struct netif *netif, struct in_addr *ip);
 
CNDP_API int cnet_ipv4_ipaddr_delete(struct netif *netif, struct in_addr *ip);
 
CNDP_API int cnet_ipv4_ipaddr_add(struct netif *netif, struct inet4_addr *ip);
 
CNDP_API int cnet_netif_set_flags(struct netif *netif, uint32_t flags);
 
CNDP_API struct netif *cnet_netif_find_by_name(char *ifname);
 
CNDP_API struct netif *cnet_netif_find_by_ifindex(int ifindex);
 
CNDP_API struct netif *cnet_netif_find_by_netdev(char *netdev_name);
 
CNDP_API struct netif *cnet_netif_find_by_lport(int lport);
 
CNDP_API int cnet_is_ifname_valid(char *ifname);
 
CNDP_API int cnet_is_netdev_valid(char *netdev_name);
 
CNDP_API int cnet_is_ifindex_valid(int ifindex);
 
#ifdef __cplusplus
}
#endif
 
#endif /* __CNET_NETIF_H */