dao_netlink_route.h

Go to the documentation of this file.

/* SPDX-License-Identifier: Marvell-MIT
 * Copyright (c) 2023 Marvell.
 */
 
#ifndef _DAO_LIB_NETLINK_ROUTE_H
#define _DAO_LIB_NETLINK_ROUTE_H
 
#include <linux/rtnetlink.h>
#include <netlink/cache.h>
#include <netlink/route/addr.h>
#include <netlink/route/link.h>
#include <netlink/route/neighbour.h>
#include <netlink/route/route.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define DAO_NETLINK_APP_IF_COOKIE_INITIALIZER (~0u)
 
#define dao_foreach_netlink_neigh_states                                                           \
    _(0, INCOMPLETE) /* NUD_INCOMPLETE */                                                      \
    _(1, REACHABLE)  /* NUD_REACHABLE */                                                       \
    _(2, STALE)      /* NUD_STALE */                                                           \
    _(3, DELAY)      /* NUD_DELAY */                                                           \
    _(4, PROBE)      /* NUD_PROBE */                                                           \
    _(5, FAILED)     /* NUD_FAILED */                                                          \
    _(6, NOARP)      /* NUD_NOARP */                                                           \
    _(7, NONE)       /* NUD_NONE */                                                            \
    _(8, PERMANENT)  /* NUD_PERMANENT */
 
#define dao_foreach_netlink_route_proto                                                            \
    _(0, UNSPEC)   /* RTPROT_UNSPEC */                                                         \
    _(1, REDIRECT) /* RTPROT_REDIRECT */                                                       \
    _(2, KERNEL)   /* RTPROT_KERNEL */                                                         \
    _(3, BOOT)     /* RTPROT_BOOT */                                                           \
    _(4, STATIC)   /* RTPROT_STATIC */
 
typedef enum {
#define _(n, state) DAO_NETLINK_ROUTE_PROTO_##state = RTPROT_##state,
 
    dao_foreach_netlink_route_proto
#undef _
} dao_netlink_route_proto_t;
 
typedef enum dao_netlink_action {
    DAO_NETLINK_ACTION_DEL = 0,     /*< Netlink notification indicates delete object */
    DAO_NETLINK_ACTION_ADD = 1,     /*< Netlink notification indicates add object */
    DAO_NETLINK_ACTION_REPLACE = 2,     /*<Netlink notification indicates replace object */
    DAO_NETLINK_ACTION_UNKNOWN,     /* Netlink notification indicates unknown action */
} dao_netlink_action_t;
 
typedef struct dao_netlink_route_ip_addr {
    int is_ipv4;
 
    int prefixlen;
 
    int app_if_cookie;
 
    int linux_ifindex;
 
    struct in6_addr local_in6_addr;
 
    unsigned int addr_flags;
} dao_netlink_route_ip_addr_t;
 
#define dao_foreach_netlink_route_types                                                            \
    _(0, UNSPEC)      /* RTN_UNSPEC */                                                         \
    _(1, UNICAST)     /* RTN_UNICAST */                                                        \
    _(2, LOCAL)       /* RTN_LOCAL */                                                          \
    _(3, BROADCAST)   /* RTN_BROADCAST */                                                      \
    _(4, ANYCAST)     /* RTN_ANYCAST */                                                        \
    _(5, MULTICAST)   /* RTN_MULTICAST */                                                      \
    _(6, BLACKHOLE)   /* RTN_BLACKHOLE */                                                      \
    _(7, UNREACHABLE) /* RTN_UNREACHABLE */                                                    \
    _(8, PROHIBIT)    /* RTN_PROHIBIT */                                                       \
    _(9, THROW)       /* RTN_THROW */                                                          \
    _(10, NAT)        /* RTN_NAT */                                                            \
    _(11, XRESOLVE)   /* RTN_XRESOLVE */
 
typedef enum {
#define _(n, state) DAO_NETLINK_ROUTE_TYPES_##state = RTN_##state,
 
    dao_foreach_netlink_route_types
#undef _
} dao_netlink_route_types_t;
 
typedef enum {
    DAO_NETLINK_ROUTE_NH_ATTR_ENCAP,
    DAO_NETLINK_ROUTE_NH_ATTR_NEWDST,
    DAO_NETLINK_ROUTE_NH_ATTR_VIA,
    DAO_NETLINK_ROUTE_NH_ATTR_VIA_GW,
    DAO_NETLINK_ROUTE_NH_ATTR_IFINDEX,
    DAO_NETLINK_ROUTE_NH_ATTR_WEIGHT,
    DAO_NETLINK_ROUTE_NH_ATTR_REALMS,
    DAO_NETLINK_ROUTE_NH_ATTR_FLAGS,
} dao_netlink_route_nh_attr_t;
 
typedef enum {
    DAO_NETLINK_ROUTE_NH_F_DEAD = RTNH_F_DEAD,      /*< Nexthop os dead */
    DAO_NETLINK_ROUTE_NH_F_PERVASIVE = RTNH_F_PERVASIVE,    /*< Recursive gateway lookup */
    DAO_NETLINK_ROUTE_NH_F_ONLINK = RTNH_F_ONLINK,      /*< Gateway is forces on link */
} dao_netlink_route_nh_flags_t;
 
typedef struct dao_netlink_route_ip_route {
    int app_if_cookie;
 
    int linux_ifindex;
 
    int is_ipv4;
 
    int is_next_hop;
 
    int is_route_info_valid;
 
    int prefixlen;
    struct in6_addr dst_in6_addr; /*< Route IP address for dst */
 
    /* If is_route_info_valid */
    struct {
        int is_default_route;
        uint32_t route_flags;                  /*< route flags */
        int route_table_id;                    /*< route table id */
        dao_netlink_route_proto_t route_proto; /*< Route proto */
        dao_netlink_route_types_t route_type;  /*< route type */
    };
 
    /* If is_next_hop == 1 */
    struct {
        int via_addr_prefixlen;
        struct in6_addr via_in6_addr;
        dao_netlink_route_nh_attr_t nh_attr;
        dao_netlink_route_nh_flags_t nh_flags;
        uint8_t nh_weights;      /*< If nh_attr == DAO_NETLINK_ROUTE_NH_ATTR_WEIGHT */
        uint16_t nh_from_realms; /*< If nh_attr == DAO_NETLINK_ROUTE_NH_ATTR_REALMS */
        uint16_t nh_to_realms;   /*< If nh_attr == DAO_NETLINK_ROUTE_NH_ATTR_REALMS */
    };
} dao_netlink_route_ip_route_t;
 
typedef enum {
#define _(n, state) DAO_NETLINK_NEIGHBOR_STATE_##state = NUD_##state,
 
    dao_foreach_netlink_neigh_states
#undef _
} dao_netlink_neigh_state_t;
 
#define DAO_NETLINK_NEIGHBOR_STATE_VALID                                                           \
    (DAO_NETLINK_NEIGHBOR_STATE_PERMANENT | DAO_NETLINK_NEIGHBOR_STATE_REACHABLE |             \
     DAO_NETLINK_NEIGHBOR_STATE_NOARP)
 
typedef struct dao_netlink_route_ip_neigh {
    int is_ipv4;
 
    int prefixlen;
 
    int app_if_cookie;
 
    int linux_ifindex;
 
    int neigh_vlan_id;
    dao_netlink_neigh_state_t neigh_state; /*< Neigh state */
    dao_netlink_route_types_t neigh_type;
    struct in6_addr dst_in6_addr;              /*< Peer IP address */
    uint8_t neigh_ll_addr[RTE_ETHER_ADDR_LEN]; /*< Peer ether address */
} dao_netlink_route_ip_neigh_t;
 
typedef struct dao_netlink_route_link {
    int app_if_cookie;
 
    int linux_ifindex;
 
    int is_interface_up;
 
    uint8_t local_ll_addr[RTE_ETHER_ADDR_LEN];
} dao_netlink_route_link_t;
 
typedef struct dao_netlink_route_callback_ops {
    int (*get_app_interface_cookie)(const char *interface_name, int linux_ifindex,
                    uint32_t *cookie);
 
    int (*ip_local_addr_add_del)(dao_netlink_route_ip_addr_t *dao_ip_addr, int is_add);
 
    int (*ip_neigh_add_del)(dao_netlink_route_ip_neigh_t *dao_ip_neigh, int is_add);
 
    int (*link_add_del)(dao_netlink_route_link_t *dao_link, int is_add);
 
    int (*ip_route_add_del)(dao_netlink_route_ip_route_t *dao_ip_route,
                dao_netlink_action_t action);
} dao_netlink_route_callback_ops_t;
 
/* Function declaration */
 
int dao_netlink_route_notifier_run(void);
 
int dao_netlink_route_notifier_register(dao_netlink_route_callback_ops_t *ops,
                    const char *prefix_interface_name);
 
#ifdef __cplusplus
}
#endif
#endif