while ((seg->length - written) > AS_SEGMENT_MAX) {
assegment_header_put(s, seg->type,
AS_SEGMENT_MAX);
- assegment_data_put(s, seg->as, AS_SEGMENT_MAX,
+ assegment_data_put(s, (seg->as + written), AS_SEGMENT_MAX,
use32bit);
written += AS_SEGMENT_MAX;
bytes += ASSEGMENT_SIZE(AS_SEGMENT_MAX,
}
}
+/* BGP own address structure */
+struct bgp_addr {
+ struct in_addr addr;
+ struct list *ifp_name_list;
+};
+
+static void show_address_entry(struct hash_backet *backet, void *args)
+{
+ struct vty *vty = (struct vty *)args;
+ struct bgp_addr *addr = (struct bgp_addr *)backet->data;
+ char *name;
+ struct listnode *node;
+
+ vty_out(vty, "addr: %s, count: %d : ", inet_ntoa(addr->addr),
+ addr->ifp_name_list->count);
+
+ for (ALL_LIST_ELEMENTS_RO(addr->ifp_name_list, node, name)) {
+ vty_out(vty, " %s,", name);
+ }
+
+ vty_out(vty, "\n");
+}
+
+void bgp_nexthop_show_address_hash(struct vty *vty, struct bgp *bgp)
+{
+ hash_iterate(bgp->address_hash,
+ (void (*)(struct hash_backet *, void *))show_address_entry,
+ vty);
+}
+
+static void bgp_address_hash_string_del(void *val)
+{
+ char *data = val;
+
+ XFREE(MTYPE_TMP, data);
+}
+
static void *bgp_address_hash_alloc(void *p)
{
const struct in_addr *val = (const struct in_addr *)p;
struct bgp_addr *addr;
addr = XMALLOC(MTYPE_BGP_ADDR, sizeof(struct bgp_addr));
- addr->refcnt = 0;
addr->addr.s_addr = val->s_addr;
+ addr->ifp_name_list = list_new();
+ addr->ifp_name_list->del = bgp_address_hash_string_del;
+
return addr;
}
-static void bgp_address_hash_free(void *addr)
+static void bgp_address_hash_free(void *data)
{
+ struct bgp_addr *addr = data;
+
+ list_delete_and_null(&addr->ifp_name_list);
XFREE(MTYPE_BGP_ADDR, addr);
}
bgp->address_hash = NULL;
}
-static void bgp_address_add(struct bgp *bgp, struct prefix *p)
+static void bgp_address_add(struct bgp *bgp, struct connected *ifc,
+ struct prefix *p)
{
struct bgp_addr tmp;
struct bgp_addr *addr;
+ struct listnode *node;
+ char *name;
tmp.addr = p->u.prefix4;
addr = hash_get(bgp->address_hash, &tmp, bgp_address_hash_alloc);
- if (!addr)
- return;
- addr->refcnt++;
+ for (ALL_LIST_ELEMENTS_RO(addr->ifp_name_list, node, name)) {
+ if (strcmp(ifc->ifp->name, name) == 0)
+ break;
+ }
+ if (!node) {
+ name = XSTRDUP(MTYPE_TMP, ifc->ifp->name);
+ listnode_add(addr->ifp_name_list, name);
+ }
}
-static void bgp_address_del(struct bgp *bgp, struct prefix *p)
+static void bgp_address_del(struct bgp *bgp, struct connected *ifc,
+ struct prefix *p)
{
struct bgp_addr tmp;
struct bgp_addr *addr;
+ struct listnode *node;
+ char *name;
tmp.addr = p->u.prefix4;
if (addr == NULL)
return;
- addr->refcnt--;
+ for (ALL_LIST_ELEMENTS_RO(addr->ifp_name_list, node, name)) {
+ if (strcmp(ifc->ifp->name, name) == 0)
+ break;
+ }
- if (addr->refcnt == 0) {
+ if (node)
+ list_delete_node(addr->ifp_name_list, node);
+
+ if (addr->ifp_name_list->count == 0) {
hash_release(bgp->address_hash, addr);
+ list_delete_and_null(&addr->ifp_name_list);
XFREE(MTYPE_BGP_ADDR, addr);
}
}
if (prefix_ipv4_any((struct prefix_ipv4 *)&p))
return;
- bgp_address_add(bgp, addr);
+ bgp_address_add(bgp, ifc, addr);
rn = bgp_node_get(bgp->connected_table[AFI_IP],
(struct prefix *)&p);
if (prefix_ipv4_any((struct prefix_ipv4 *)&p))
return;
- bgp_address_del(bgp, addr);
+ bgp_address_del(bgp, ifc, addr);
rn = bgp_node_lookup(bgp->connected_table[AFI_IP], &p);
} else if (addr->family == AF_INET6) {
struct bgp *bgp;
};
-/* BGP own address structure */
-struct bgp_addr {
- struct in_addr addr;
- int refcnt;
-};
-
/* Own tunnel-ip address structure */
struct tip_addr {
struct in_addr addr;
extern void bgp_tip_hash_init(struct bgp *bgp);
extern void bgp_tip_hash_destroy(struct bgp *bgp);
+extern void bgp_nexthop_show_address_hash(struct vty *vty, struct bgp *bgp);
#endif /* _QUAGGA_BGP_NEXTHOP_H */
bnc->change_flags |= BGP_NEXTHOP_CHANGED;
if (nhr.nexthop_num) {
+ struct peer *peer = bnc->nht_info;
+
/* notify bgp fsm if nbr ip goes from invalid->valid */
if (!bnc->nexthop_num)
UNSET_FLAG(bnc->flags, BGP_NEXTHOP_PEER_NOTIFIED);
nexthop = nexthop_from_zapi_nexthop(&nhr.nexthops[i]);
+ /*
+ * Turn on RA for the v6 nexthops
+ * we receive from bgp. This is to allow us
+ * to work with v4 routing over v6 nexthops
+ */
+ if (peer &&
+ CHECK_FLAG(peer->flags, PEER_FLAG_CAPABILITY_ENHE)
+ && nhr.prefix.family == AF_INET6) {
+ struct interface *ifp;
+
+ ifp = if_lookup_by_index(nexthop->ifindex,
+ nexthop->vrf_id);
+ zclient_send_interface_radv_req(
+ zclient, nexthop->vrf_id, ifp, true,
+ BGP_UNNUM_DEFAULT_RA_INTERVAL);
+ }
/* There is at least one label-switched path */
if (nexthop->nh_label &&
nexthop->nh_label->num_labels) {
*/
if (CHECK_FLAG(peer->flags, PEER_FLAG_CAPABILITY_ENHE)
&& peer->su.sa.sa_family == AF_INET6
- && IN6_IS_ADDR_LINKLOCAL(&peer->su.sin6.sin6_addr)
&& afi == AFI_IP
&& (safi == SAFI_UNICAST
|| safi == SAFI_LABELED_UNICAST)) {
return CMD_SUCCESS;
}
-static void show_address_entry(struct hash_backet *backet, void *args)
-{
- struct vty *vty = (struct vty *)args;
- struct bgp_addr *addr = (struct bgp_addr *)backet->data;
-
- vty_out(vty, "addr: %s, count: %d\n", inet_ntoa(addr->addr),
- addr->refcnt);
-}
static void show_tip_entry(struct hash_backet *backet, void *args)
{
static void bgp_show_martian_nexthops(struct vty *vty, struct bgp *bgp)
{
vty_out(vty, "self nexthop database:\n");
- hash_iterate(bgp->address_hash,
- (void (*)(struct hash_backet *, void *))show_address_entry,
- vty);
+ bgp_nexthop_show_address_hash(vty, bgp);
vty_out(vty, "Tunnel-ip database:\n");
hash_iterate(bgp->tip_hash,
specified number of hops away will be allowed to become neighbors. This
command is mutually exclusive with *ebgp-multihop*.
+.. index:: [no] neighbor PEER capability extended-nexthop
+.. clicmd:: [no] neighbor PEER capability extended-nexthop
+
+ Allow bgp to negotiate the extended-nexthop capability with it's peer.
+ If you are peering over a v6 LL address then this capability is turned
+ on automatically. If you are peering over a v6 Global Address then
+ turning on this command will allow BGP to install v4 routes with
+ v6 nexthops if you do not have v4 configured on interfaces.
+
.. index:: [no] bgp fast-external-failover
.. clicmd:: [no] bgp fast-external-failover
struct prefix dest_addr;
- dest_addr.family = AF_INET;
- dest_addr.u.prefix4 = ei->connected->address->u.prefix4;
- dest_addr.prefixlen = ei->connected->address->prefixlen;
+ dest_addr = *ei->address;
apply_mask(&dest_addr);
pe = eigrp_topology_table_lookup_ipv4(eigrp->topology_table,
&dest_addr);
eigrp_hello_send(ei, EIGRP_HELLO_GRACEFUL_SHUTDOWN, NULL);
}
- dest_addr = *ei->connected->address;
+ dest_addr = *ei->address;
apply_mask(&dest_addr);
pe = eigrp_topology_table_lookup_ipv4(eigrp->topology_table,
&dest_addr);
#include "eigrpd/eigrp_vty.h"
#include "eigrpd/eigrp_network.h"
-static int eigrp_network_match_iface(const struct connected *,
- const struct prefix *);
+static int eigrp_network_match_iface(const struct prefix *connected_prefix,
+ const struct prefix *prefix);
static void eigrp_network_run_interface(struct eigrp *, struct prefix *,
struct interface *);
/* Check whether interface matches given network
* returns: 1, true. 0, false
*/
-static int eigrp_network_match_iface(const struct connected *co,
+static int eigrp_network_match_iface(const struct prefix *co_prefix,
const struct prefix *net)
{
/* new approach: more elegant and conceptually clean */
- return prefix_match_network_statement(net, CONNECTED_PREFIX(co));
+ return prefix_match_network_statement(net, co_prefix);
}
static void eigrp_network_run_interface(struct eigrp *eigrp, struct prefix *p,
continue;
if (p->family == co->address->family && !ifp->info
- && eigrp_network_match_iface(co, p)) {
+ && eigrp_network_match_iface(co->address, p)) {
ei = eigrp_if_new(eigrp, ifp, co->address);
- ei->connected = co;
/* Relate eigrp interface to eigrp instance. */
ei->eigrp = eigrp;
/* Find interfaces that not configured already. */
for (ALL_LIST_ELEMENTS(eigrp->eiflist, node, nnode, ei)) {
- int found = 0;
- struct connected *co = ei->connected;
+ bool found = false;
for (rn = route_top(eigrp->networks); rn; rn = route_next(rn)) {
if (rn->info == NULL)
continue;
- if (eigrp_network_match_iface(co, &rn->p)) {
- found = 1;
+ if (eigrp_network_match_iface(ei->address, &rn->p)) {
+ found = true;
route_unlock_node(rn);
break;
}
}
- if (found == 0) {
+ if (!found) {
eigrp_if_free(ei, INTERFACE_DOWN_BY_VTY);
}
}
uint8_t type;
struct prefix *address; /* Interface prefix */
- struct connected *connected; /* Pointer to connected */
/* Neighbor information. */
struct list *nbrs; /* EIGRP Neighbor List */
* Freeing topology table list
*/
void eigrp_topology_free(struct route_table *table)
-{
- route_table_finish(table);
-}
-
-/*
- * Deleting all topology nodes in table
- */
-void eigrp_topology_cleanup(struct route_table *table)
{
eigrp_topology_delete_all(table);
+ route_table_finish(table);
}
/*
struct eigrp_prefix_entry *pe)
{
struct eigrp *eigrp = eigrp_lookup();
+ struct eigrp_nexthop_entry *ne;
+ struct listnode *node, *nnode;
struct route_node *rn;
if (!eigrp)
*/
listnode_delete(eigrp->topology_changes_internalIPV4, pe);
+ for (ALL_LIST_ELEMENTS(pe->entries, node, nnode, ne))
+ eigrp_nexthop_entry_delete(pe, ne);
list_delete_and_null(&pe->entries);
list_delete_and_null(&pe->rij);
eigrp_zebra_route_delete(pe->destination);
+ prefix_free(pe->destination);
rn->info = NULL;
route_unlock_node(rn); // Lookup above
}
}
-/*
- * Return 0 if topology is not empty
- * otherwise return 1
- */
-unsigned int eigrp_topology_table_isempty(struct list *topology)
-{
- if (topology->count)
- return 1;
- else
- return 0;
-}
-
struct eigrp_prefix_entry *
eigrp_topology_table_lookup_ipv4(struct route_table *table,
struct prefix *address)
extern struct eigrp_prefix_entry *eigrp_prefix_entry_new(void);
extern struct eigrp_nexthop_entry *eigrp_nexthop_entry_new(void);
extern void eigrp_topology_free(struct route_table *table);
-extern void eigrp_topology_cleanup(struct route_table *table);
extern void eigrp_prefix_entry_add(struct route_table *table,
struct eigrp_prefix_entry *pe);
extern void eigrp_nexthop_entry_add(struct eigrp_prefix_entry *,
extern void eigrp_nexthop_entry_delete(struct eigrp_prefix_entry *,
struct eigrp_nexthop_entry *);
extern void eigrp_topology_delete_all(struct route_table *table);
-extern unsigned int eigrp_topology_table_isempty(struct list *);
extern struct eigrp_prefix_entry *
eigrp_topology_table_lookup_ipv4(struct route_table *table, struct prefix *p);
extern struct list *eigrp_topology_get_successor(struct eigrp_prefix_entry *);
struct eigrp_master *eigrp_om;
-static void eigrp_delete(struct eigrp *);
static struct eigrp *eigrp_new(const char *);
-static void eigrp_add(struct eigrp *);
extern struct zclient *zclient;
extern struct in_addr router_id_zebra;
return eigrp;
}
-static void eigrp_add(struct eigrp *eigrp)
-{
- listnode_add(eigrp_om->eigrp, eigrp);
-}
-
-static void eigrp_delete(struct eigrp *eigrp)
-{
- listnode_delete(eigrp_om->eigrp, eigrp);
-}
-
struct eigrp *eigrp_get(const char *AS)
{
struct eigrp *eigrp;
eigrp = eigrp_lookup();
if (eigrp == NULL) {
eigrp = eigrp_new(AS);
- eigrp_add(eigrp);
+ listnode_add(eigrp_om->eigrp, eigrp);
}
return eigrp;
list_delete_and_null(&eigrp->eiflist);
list_delete_and_null(&eigrp->oi_write_q);
- eigrp_topology_cleanup(eigrp->topology_table);
eigrp_topology_free(eigrp->topology_table);
eigrp_nbr_delete(eigrp->neighbor_self);
list_delete_and_null(&eigrp->topology_changes_externalIPV4);
list_delete_and_null(&eigrp->topology_changes_internalIPV4);
- eigrp_delete(eigrp);
+ listnode_delete(eigrp_om->eigrp, eigrp);
+ stream_free(eigrp->ibuf);
XFREE(MTYPE_EIGRP_TOP, eigrp);
}
static struct frr_daemon_info *di = NULL;
-static void frr_guard_daemon(void)
-{
- int fd;
- struct flock lock;
- const char *path = di->pid_file;
-
- fd = open(path, O_RDWR);
- if (fd != -1) {
- memset(&lock, 0, sizeof(lock));
- lock.l_type = F_WRLCK;
- lock.l_whence = SEEK_SET;
- if (fcntl(fd, F_GETLK, &lock) < 0) {
- flog_err_sys(
- EC_LIB_SYSTEM_CALL,
- "Could not do F_GETLK pid_file %s (%s), exiting",
- path, safe_strerror(errno));
- exit(1);
- } else if (lock.l_type == F_WRLCK) {
- flog_err_sys(
- EC_LIB_SYSTEM_CALL,
- "Process %d has a write lock on file %s already! Error: (%s)",
- lock.l_pid, path, safe_strerror(errno));
- exit(1);
- }
- close(fd);
- }
-}
-
void frr_preinit(struct frr_daemon_info *daemon, int argc, char **argv)
{
di = daemon;
zprivs_init(di->privs);
- /* Guard to prevent a second instance of this daemon */
- frr_guard_daemon();
-
master = thread_master_create(NULL);
signal_init(master, di->n_signals, di->signals);
if (fcntl(fd, F_SETLK, &lock) < 0) {
flog_err_sys(EC_LIB_SYSTEM_CALL,
- "Could not lock pid_file %s (%s), exiting",
+ "Could not lock pid_file %s (%s), exiting. Please ensure that the daemon is not already running",
path, safe_strerror(errno));
exit(1);
}
{
struct hash *upd8_hash = NULL;
- if ((upd8_hash = route_map_get_dep_hash(type)))
+ if ((upd8_hash = route_map_get_dep_hash(type))) {
route_map_dep_update(upd8_hash, arg, rmap_name, type);
+
+ if (type == RMAP_EVENT_CALL_ADDED) {
+ /* Execute hook. */
+ if (route_map_master.add_hook)
+ (*route_map_master.add_hook)(rmap_name);
+ } else if (type == RMAP_EVENT_CALL_DELETED) {
+ /* Execute hook. */
+ if (route_map_master.delete_hook)
+ (*route_map_master.delete_hook)(rmap_name);
+ }
+ }
}
void route_map_notify_dependencies(const char *affected_name,
/* Dequeue listnode entry from the list. */
listnode_delete(funclist, functab);
- /* Avoid misjudgement in the next lookup. */
- if (listcount(funclist) == 0)
- funclist->head = funclist->tail = NULL;
-
XFREE(MTYPE_OSPF_OPAQUE_FUNCTAB, functab);
break;
}
/* Dequeue listnode entry from the list. */
listnode_delete(oipt->id_list, oipi);
- /* Avoid misjudgement in the next lookup. */
- if (listcount(oipt->id_list) == 0)
- oipt->id_list->head = oipt->id_list->tail = NULL;
-
/* Disassociate internal control information with the given lsa. */
free_opaque_info_per_id((void *)oipi);
if (found) {
listnode_delete(pce->pce_domain, old);
- /* Avoid misjudgement in the next lookup. */
- if (listcount(pce->pce_domain) == 0)
- pce->pce_domain->head = pce->pce_domain->tail = NULL;
-
/* Finally free the old domain */
XFREE(MTYPE_OSPF_PCE_PARAMS, old);
}
if (found) {
listnode_delete(pce->pce_neighbor, old);
- /* Avoid misjudgement in the next lookup. */
- if (listcount(pce->pce_neighbor) == 0)
- pce->pce_neighbor->head = pce->pce_neighbor->tail =
- NULL;
-
/* Finally free the old domain */
XFREE(MTYPE_OSPF_PCE_PARAMS, old);
}
/* Dequeue listnode entry from the list. */
listnode_delete(iflist, lp);
- /* Avoid misjudgement in the next lookup. */
- if (listcount(iflist) == 0)
- iflist->head = iflist->tail = NULL;
-
XFREE(MTYPE_OSPF_MPLS_TE, lp);
}
if (pim->static_routes)
list_delete_and_null(&pim->static_routes);
- pim_rp_free(pim);
-
pim_upstream_terminate(pim);
+ pim_rp_free(pim);
+
/* Traverse and cleanup rpf_hash */
if (pim->rpf_hash) {
hash_clean(pim->rpf_hash, (void *)pim_rp_list_hash_clean);
#include <zebra.h>
-#include "zebra/rib.h"
-
#include "log.h"
#include "zclient.h"
#include "memory.h"
void pim_upstream_terminate(struct pim_instance *pim)
{
- struct listnode *node, *nnode;
struct pim_upstream *up;
if (pim->upstream_list) {
- for (ALL_LIST_ELEMENTS(pim->upstream_list, node, nnode, up))
+ while (pim->upstream_list->count) {
+ up = listnode_head(pim->upstream_list);
pim_upstream_del(pim, up, __PRETTY_FUNCTION__);
+ }
list_delete_and_null(&pim->upstream_list);
}
#include <zebra.h>
-#include "zebra/rib.h"
-
#include "if.h"
#include "log.h"
#include "prefix.h"
*/
#include <zebra.h>
-#include "zebra/rib.h"
#include "log.h"
#include "prefix.h"
unsigned long zebra_debug_mpls;
unsigned long zebra_debug_vxlan;
unsigned long zebra_debug_pw;
+unsigned long zebra_debug_dplane;
DEFINE_HOOK(zebra_debug_show_debugging, (struct vty *vty), (vty));
vty_out(vty, " Zebra VXLAN debugging is on\n");
if (IS_ZEBRA_DEBUG_PW)
vty_out(vty, " Zebra pseudowire debugging is on\n");
+ if (IS_ZEBRA_DEBUG_DPLANE_DETAIL)
+ vty_out(vty, " Zebra detailed dataplane debugging is on\n");
+ else if (IS_ZEBRA_DEBUG_DPLANE)
+ vty_out(vty, " Zebra dataplane debugging is on\n");
hook_call(zebra_debug_show_debugging, vty);
return CMD_SUCCESS;
return CMD_SUCCESS;
}
+DEFUN (debug_zebra_dplane,
+ debug_zebra_dplane_cmd,
+ "debug zebra dplane [detailed]",
+ DEBUG_STR
+ "Zebra configuration\n"
+ "Debug zebra dataplane events\n"
+ "Detailed debug information\n")
+{
+ int idx = 0;
+ SET_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE);
+
+ if (argv_find(argv, argc, "detailed", &idx))
+ SET_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE_DETAILED);
+
+ return CMD_SUCCESS;
+}
+
DEFUN (no_debug_zebra_events,
no_debug_zebra_events_cmd,
"no debug zebra events",
return CMD_SUCCESS;
}
+DEFUN (no_debug_zebra_dplane,
+ no_debug_zebra_dplane_cmd,
+ "no debug zebra dplane",
+ NO_STR
+ DEBUG_STR
+ "Zebra configuration\n"
+ "Debug zebra dataplane events\n")
+{
+ zebra_debug_dplane = 0;
+ return CMD_SUCCESS;
+}
+
/* Debug node. */
struct cmd_node debug_node = {DEBUG_NODE, "", /* Debug node has no interface. */
1};
vty_out(vty, "debug zebra pseudowires\n");
write++;
}
+
+ if (CHECK_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE_DETAILED)) {
+ vty_out(vty, "debug zebra dplane detailed\n");
+ write++;
+ } else if (CHECK_FLAG(zebra_debug_dplane, ZEBRA_DEBUG_DPLANE)) {
+ vty_out(vty, "debug zebra dplane\n");
+ write++;
+ }
+
return write;
}
zebra_debug_mpls = 0;
zebra_debug_vxlan = 0;
zebra_debug_pw = 0;
+ zebra_debug_dplane = 0;
install_node(&debug_node, config_write_debug);
install_element(ENABLE_NODE, &debug_zebra_kernel_msgdump_cmd);
install_element(ENABLE_NODE, &debug_zebra_rib_cmd);
install_element(ENABLE_NODE, &debug_zebra_fpm_cmd);
+ install_element(ENABLE_NODE, &debug_zebra_dplane_cmd);
install_element(ENABLE_NODE, &no_debug_zebra_events_cmd);
install_element(ENABLE_NODE, &no_debug_zebra_nht_cmd);
install_element(ENABLE_NODE, &no_debug_zebra_mpls_cmd);
install_element(ENABLE_NODE, &no_debug_zebra_kernel_msgdump_cmd);
install_element(ENABLE_NODE, &no_debug_zebra_rib_cmd);
install_element(ENABLE_NODE, &no_debug_zebra_fpm_cmd);
+ install_element(ENABLE_NODE, &no_debug_zebra_dplane_cmd);
install_element(CONFIG_NODE, &debug_zebra_events_cmd);
install_element(CONFIG_NODE, &debug_zebra_nht_cmd);
install_element(CONFIG_NODE, &debug_zebra_kernel_msgdump_cmd);
install_element(CONFIG_NODE, &debug_zebra_rib_cmd);
install_element(CONFIG_NODE, &debug_zebra_fpm_cmd);
+ install_element(CONFIG_NODE, &debug_zebra_dplane_cmd);
install_element(CONFIG_NODE, &no_debug_zebra_events_cmd);
install_element(CONFIG_NODE, &no_debug_zebra_nht_cmd);
install_element(CONFIG_NODE, &no_debug_zebra_mpls_cmd);
install_element(CONFIG_NODE, &no_debug_zebra_kernel_msgdump_cmd);
install_element(CONFIG_NODE, &no_debug_zebra_rib_cmd);
install_element(CONFIG_NODE, &no_debug_zebra_fpm_cmd);
+ install_element(CONFIG_NODE, &no_debug_zebra_dplane_cmd);
}
#define ZEBRA_DEBUG_PW 0x01
+#define ZEBRA_DEBUG_DPLANE 0x01
+#define ZEBRA_DEBUG_DPLANE_DETAILED 0x02
+
/* Debug related macro. */
#define IS_ZEBRA_DEBUG_EVENT (zebra_debug_event & ZEBRA_DEBUG_EVENT)
#define IS_ZEBRA_DEBUG_VXLAN (zebra_debug_vxlan & ZEBRA_DEBUG_VXLAN)
#define IS_ZEBRA_DEBUG_PW (zebra_debug_pw & ZEBRA_DEBUG_PW)
+#define IS_ZEBRA_DEBUG_DPLANE (zebra_debug_dplane & ZEBRA_DEBUG_DPLANE)
+#define IS_ZEBRA_DEBUG_DPLANE_DETAIL \
+ (zebra_debug_dplane & ZEBRA_DEBUG_DPLANE_DETAILED)
+
extern unsigned long zebra_debug_event;
extern unsigned long zebra_debug_packet;
extern unsigned long zebra_debug_kernel;
extern unsigned long zebra_debug_mpls;
extern unsigned long zebra_debug_vxlan;
extern unsigned long zebra_debug_pw;
+extern unsigned long zebra_debug_dplane;
extern void zebra_debug_init(void);
}
/* Request for specific interface or address information from the kernel */
-static int netlink_request_intf_addr(struct zebra_ns *zns, int family, int type,
- uint32_t filter_mask)
+static int netlink_request_intf_addr(struct nlsock *netlink_cmd, int family,
+ int type, uint32_t filter_mask)
{
struct {
struct nlmsghdr n;
if (filter_mask)
addattr32(&req.n, sizeof(req), IFLA_EXT_MASK, filter_mask);
- return netlink_request(&zns->netlink_cmd, &req.n);
+ return netlink_request(netlink_cmd, &req.n);
}
/* Interface lookup by netlink socket. */
int interface_lookup_netlink(struct zebra_ns *zns)
{
int ret;
+ struct zebra_dplane_info dp_info;
+ struct nlsock *netlink_cmd = &zns->netlink_cmd;
+
+ /* Capture key info from ns struct */
+ zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
/* Get interface information. */
- ret = netlink_request_intf_addr(zns, AF_PACKET, RTM_GETLINK, 0);
+ ret = netlink_request_intf_addr(netlink_cmd, AF_PACKET, RTM_GETLINK, 0);
if (ret < 0)
return ret;
- ret = netlink_parse_info(netlink_interface, &zns->netlink_cmd, zns, 0,
+ ret = netlink_parse_info(netlink_interface, netlink_cmd, &dp_info, 0,
1);
if (ret < 0)
return ret;
/* Get interface information - for bridge interfaces. */
- ret = netlink_request_intf_addr(zns, AF_BRIDGE, RTM_GETLINK,
+ ret = netlink_request_intf_addr(netlink_cmd, AF_BRIDGE, RTM_GETLINK,
RTEXT_FILTER_BRVLAN);
if (ret < 0)
return ret;
- ret = netlink_parse_info(netlink_interface, &zns->netlink_cmd, zns, 0,
+ ret = netlink_parse_info(netlink_interface, netlink_cmd, &dp_info, 0,
0);
if (ret < 0)
return ret;
/* Get interface information - for bridge interfaces. */
- ret = netlink_request_intf_addr(zns, AF_BRIDGE, RTM_GETLINK,
+ ret = netlink_request_intf_addr(netlink_cmd, AF_BRIDGE, RTM_GETLINK,
RTEXT_FILTER_BRVLAN);
if (ret < 0)
return ret;
- ret = netlink_parse_info(netlink_interface, &zns->netlink_cmd, zns, 0,
+ ret = netlink_parse_info(netlink_interface, netlink_cmd, &dp_info, 0,
0);
if (ret < 0)
return ret;
zebra_if_update_all_links();
/* Get IPv4 address of the interfaces. */
- ret = netlink_request_intf_addr(zns, AF_INET, RTM_GETADDR, 0);
+ ret = netlink_request_intf_addr(netlink_cmd, AF_INET, RTM_GETADDR, 0);
if (ret < 0)
return ret;
- ret = netlink_parse_info(netlink_interface_addr, &zns->netlink_cmd, zns,
+ ret = netlink_parse_info(netlink_interface_addr, netlink_cmd, &dp_info,
0, 1);
if (ret < 0)
return ret;
/* Get IPv6 address of the interfaces. */
- ret = netlink_request_intf_addr(zns, AF_INET6, RTM_GETADDR, 0);
+ ret = netlink_request_intf_addr(netlink_cmd, AF_INET6, RTM_GETADDR, 0);
if (ret < 0)
return ret;
- ret = netlink_parse_info(netlink_interface_addr, &zns->netlink_cmd, zns,
+ ret = netlink_parse_info(netlink_interface_addr, netlink_cmd, &dp_info,
0, 1);
if (ret < 0)
return ret;
#include "zebra/zebra_vxlan.h"
#include "zebra/zebra_errors.h"
+DEFINE_MTYPE_STATIC(ZEBRA, ZINFO, "Zebra Interface Information")
+
#define ZEBRA_PTM_SUPPORT
DEFINE_HOOK(zebra_if_extra_info, (struct vty * vty, struct interface *ifp),
{
struct zebra_if *zebra_if;
- zebra_if = XCALLOC(MTYPE_TMP, sizeof(struct zebra_if));
+ zebra_if = XCALLOC(MTYPE_ZINFO, sizeof(struct zebra_if));
zebra_if->multicast = IF_ZEBRA_MULTICAST_UNSPEC;
zebra_if->shutdown = IF_ZEBRA_SHUTDOWN_OFF;
}
#endif /* HAVE_RTADV */
+ memset(&zebra_if->neigh_mac[0], 0, 6);
+
/* Initialize installed address chains tree. */
zebra_if->ipv4_subnets =
route_table_init_with_delegate(&zebra_if_table_delegate);
THREAD_OFF(zebra_if->speed_update);
- XFREE(MTYPE_TMP, zebra_if);
+ XFREE(MTYPE_ZINFO, zebra_if);
}
return 0;
mac[5] = address->s6_addr[15];
}
-void if_nbr_ipv6ll_to_ipv4ll_neigh_update(struct interface *ifp,
- struct in6_addr *address, int add)
+static bool mac_is_same(char *mac1, char *mac2)
+{
+ if (mac1[0] == mac2[0] &&
+ mac1[1] == mac2[1] &&
+ mac1[2] == mac2[2] &&
+ mac1[3] == mac2[3] &&
+ mac1[4] == mac2[4] &&
+ mac1[5] == mac2[5])
+ return true;
+ else
+ return false;
+}
+
+void if_nbr_mac_to_ipv4ll_neigh_update(struct interface *ifp,
+ char mac[6],
+ struct in6_addr *address,
+ int add)
{
struct zebra_vrf *zvrf = vrf_info_lookup(ifp->vrf_id);
struct zebra_if *zif = ifp->info;
char buf[16] = "169.254.0.1";
struct in_addr ipv4_ll;
- char mac[6];
ns_id_t ns_id;
inet_pton(AF_INET, buf, &ipv4_ll);
- ipv6_ll_address_to_mac(address, (uint8_t *)mac);
ns_id = zvrf->zns->ns_id;
/*
*
* supported message types are RTM_NEWNEIGH and RTM_DELNEIGH
*/
- kernel_neigh_update(0, ifp->ifindex, ipv4_ll.s_addr, mac, 6, ns_id);
+ if (!mac_is_same(zif->neigh_mac, mac)) {
+ kernel_neigh_update(0, ifp->ifindex, ipv4_ll.s_addr,
+ mac, 6, ns_id);
- /* Add arp record */
- kernel_neigh_update(add, ifp->ifindex, ipv4_ll.s_addr, mac, 6, ns_id);
+ /* Add arp record */
+ kernel_neigh_update(add, ifp->ifindex, ipv4_ll.s_addr,
+ mac, 6, ns_id);
+ }
+
+ memcpy(&zif->neigh_mac[0], &mac[0], 6);
/*
* We need to note whether or not we originated a v6
zvrf->neigh_updates++;
}
+void if_nbr_ipv6ll_to_ipv4ll_neigh_update(struct interface *ifp,
+ struct in6_addr *address, int add)
+{
+
+ char mac[6];
+
+ ipv6_ll_address_to_mac(address, (uint8_t *)mac);
+ if_nbr_mac_to_ipv4ll_neigh_update(ifp, mac, address, add);
+}
+
static void if_nbr_ipv6ll_to_ipv4ll_neigh_add_all(struct interface *ifp)
{
if (listhead(ifp->nbr_connected)) {
* for bgp unnumbered?
*/
bool v6_2_v4_ll_neigh_entry;
+ char neigh_mac[6];
struct in6_addr v6_2_v4_ll_addr6;
};
extern const char *ifindex2ifname_per_ns(struct zebra_ns *, unsigned int);
extern void if_unlink_per_ns(struct interface *);
+extern void if_nbr_mac_to_ipv4ll_neigh_update(struct interface *fip,
+ char mac[6],
+ struct in6_addr *address,
+ int add);
extern void if_nbr_ipv6ll_to_ipv4ll_neigh_update(struct interface *ifp,
struct in6_addr *address,
int add);
static int kernel_read(struct thread *thread)
{
struct zebra_ns *zns = (struct zebra_ns *)THREAD_ARG(thread);
- netlink_parse_info(netlink_information_fetch, &zns->netlink, zns, 5, 0);
+ struct zebra_dplane_info dp_info;
+
+ /* Capture key info from ns struct */
+ zebra_dplane_info_from_zns(&dp_info, zns, false);
+
+ netlink_parse_info(netlink_information_fetch, &zns->netlink, &dp_info,
+ 5, 0);
zns->t_netlink = NULL;
thread_add_read(zebrad.master, kernel_read, zns, zns->netlink.sock,
&zns->t_netlink);
* the filter.
*/
int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
- struct nlsock *nl, struct zebra_ns *zns, int count,
- int startup)
+ struct nlsock *nl, struct zebra_dplane_info *zns,
+ int count, int startup)
{
int status;
int ret = 0;
/* Deal with errors that occur because of races
* in link handling */
- if (nl == &zns->netlink_cmd
+ if (zns->is_cmd
&& ((msg_type == RTM_DELROUTE
&& (-errnum == ENODEV
|| -errnum == ESRCH))
* so do not log these as an error.
*/
if (msg_type == RTM_DELNEIGH
- || (nl == &zns->netlink_cmd
- && msg_type == RTM_NEWROUTE
+ || (zns->is_cmd && msg_type == RTM_NEWROUTE
&& (-errnum == ESRCH
|| -errnum == ENETUNREACH))) {
/* This is known to happen in some
struct iovec iov;
struct msghdr msg;
int save_errno = 0;
+ struct zebra_dplane_info dp_info;
memset(&snl, 0, sizeof snl);
memset(&iov, 0, sizeof iov);
* Get reply from netlink socket.
* The reply should either be an acknowlegement or an error.
*/
- return netlink_parse_info(filter, nl, zns, 0, startup);
+ zebra_dplane_info_from_zns(&dp_info, zns, (nl == &(zns->netlink_cmd)));
+ return netlink_parse_info(filter, nl, &dp_info, 0, startup);
}
/* Issue request message to kernel via netlink socket. GET messages
extern void netlink_read_init(const char *fname);
#endif /* HANDLE_NETLINK_FUZZING */
extern int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
- struct nlsock *nl, struct zebra_ns *zns,
+ struct nlsock *nl, struct zebra_dplane_info *zns,
int count, int startup);
extern int netlink_talk_filter(struct nlmsghdr *h, ns_id_t ns, int startup);
extern int netlink_talk(int (*filter)(struct nlmsghdr *, ns_id_t, int startup),
#include "zebra/rib.h"
#include "zebra/zebra_ns.h"
#include "zebra/zebra_mpls.h"
-
-/*
- * Philosophy Note:
- *
- * Flags being SET/UNSET do not belong in the South Bound
- * Interface. This Setting belongs at the calling level
- * because we can and will have multiple different interfaces
- * and we will have potentially multiple different
- * modules/filters to call. As such Setting/Unsetting
- * success failure should be handled by the caller.
- */
-
-
-enum dp_results {
- DP_INSTALL_SUCCESS,
- DP_INSTALL_FAILURE,
- DP_DELETE_SUCCESS,
- DP_DELETE_FAILURE,
-};
-
-enum dp_req_result {
- DP_REQUEST_QUEUED,
- DP_REQUEST_SUCCESS,
- DP_REQUEST_FAILURE,
-};
+#include "zebra/zebra_dplane.h"
/*
* Install/delete the specified prefix p from the kernel
* semantics so we will end up with a delete than
* a re-add.
*/
-extern enum dp_req_result kernel_route_rib(struct route_node *rn,
- const struct prefix *p,
- const struct prefix *src_p,
- struct route_entry *old,
- struct route_entry *new);
+extern enum zebra_dplane_result kernel_route_rib(struct route_node *rn,
+ const struct prefix *p,
+ const struct prefix *src_p,
+ struct route_entry *old,
+ struct route_entry *new);
/*
* So route install/failure may not be immediately known
extern void kernel_route_rib_pass_fail(struct route_node *rn,
const struct prefix *p,
struct route_entry *re,
- enum dp_results res);
+ enum zebra_dplane_status res);
extern int kernel_address_add_ipv4(struct interface *, struct connected *);
extern int kernel_address_delete_ipv4(struct interface *, struct connected *);
extern int kernel_interface_set_master(struct interface *master,
struct interface *slave);
-extern enum dp_req_result kernel_add_lsp(zebra_lsp_t *lsp);
-extern enum dp_req_result kernel_upd_lsp(zebra_lsp_t *lsp);
-extern enum dp_req_result kernel_del_lsp(zebra_lsp_t *lsp);
+extern enum zebra_dplane_result kernel_add_lsp(zebra_lsp_t *lsp);
+extern enum zebra_dplane_result kernel_upd_lsp(zebra_lsp_t *lsp);
+extern enum zebra_dplane_result kernel_del_lsp(zebra_lsp_t *lsp);
/*
* Add the ability to pass back up the lsp install/delete
* the install/failure to set/unset flags and to notify
* as needed.
*/
-extern void kernel_lsp_pass_fail(zebra_lsp_t *lsp, enum dp_results res);
+extern void kernel_lsp_pass_fail(zebra_lsp_t *lsp, enum zebra_dplane_status res);
extern int mpls_kernel_init(void);
int netlink_route_read(struct zebra_ns *zns)
{
int ret;
+ struct zebra_dplane_info dp_info;
+
+ zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
/* Get IPv4 routing table. */
ret = netlink_request_route(zns, AF_INET, RTM_GETROUTE);
if (ret < 0)
return ret;
ret = netlink_parse_info(netlink_route_change_read_unicast,
- &zns->netlink_cmd, zns, 0, 1);
+ &zns->netlink_cmd, &dp_info, 0, 1);
if (ret < 0)
return ret;
if (ret < 0)
return ret;
ret = netlink_parse_info(netlink_route_change_read_unicast,
- &zns->netlink_cmd, zns, 0, 1);
+ &zns->netlink_cmd, &dp_info, 0, 1);
if (ret < 0)
return ret;
return suc;
}
-enum dp_req_result kernel_route_rib(struct route_node *rn,
- const struct prefix *p,
- const struct prefix *src_p,
- struct route_entry *old,
- struct route_entry *new)
+enum zebra_dplane_result kernel_route_rib(struct route_node *rn,
+ const struct prefix *p,
+ const struct prefix *src_p,
+ struct route_entry *old,
+ struct route_entry *new)
{
int ret = 0;
new, 0);
}
kernel_route_rib_pass_fail(rn, p, new,
- (!ret) ? DP_INSTALL_SUCCESS
- : DP_INSTALL_FAILURE);
- return DP_REQUEST_SUCCESS;
+ (!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
+ : ZEBRA_DPLANE_INSTALL_FAILURE);
+ return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
if (old) {
ret = netlink_route_multipath(RTM_DELROUTE, p, src_p, old, 0);
kernel_route_rib_pass_fail(rn, p, old,
- (!ret) ? DP_DELETE_SUCCESS
- : DP_DELETE_FAILURE);
+ (!ret) ? ZEBRA_DPLANE_DELETE_SUCCESS
+ : ZEBRA_DPLANE_DELETE_FAILURE);
}
- return DP_REQUEST_SUCCESS;
+ return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
int kernel_neigh_update(int add, int ifindex, uint32_t addr, char *lla,
}
/* Request for MAC FDB information from the kernel */
-static int netlink_request_macs(struct zebra_ns *zns, int family, int type,
- ifindex_t master_ifindex)
+static int netlink_request_macs(struct nlsock *netlink_cmd, int family,
+ int type, ifindex_t master_ifindex)
{
struct {
struct nlmsghdr n;
if (master_ifindex)
addattr32(&req.n, sizeof(req), IFLA_MASTER, master_ifindex);
- return netlink_request(&zns->netlink_cmd, &req.n);
+ return netlink_request(netlink_cmd, &req.n);
}
/*
int netlink_macfdb_read(struct zebra_ns *zns)
{
int ret;
+ struct zebra_dplane_info dp_info;
+
+ zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
/* Get bridge FDB table. */
- ret = netlink_request_macs(zns, AF_BRIDGE, RTM_GETNEIGH, 0);
+ ret = netlink_request_macs(&zns->netlink_cmd, AF_BRIDGE, RTM_GETNEIGH,
+ 0);
if (ret < 0)
return ret;
/* We are reading entire table. */
filter_vlan = 0;
- ret = netlink_parse_info(netlink_macfdb_table, &zns->netlink_cmd, zns,
- 0, 1);
+ ret = netlink_parse_info(netlink_macfdb_table, &zns->netlink_cmd,
+ &dp_info, 0, 1);
return ret;
}
struct zebra_if *br_zif;
struct zebra_if *zif;
struct zebra_l2info_vxlan *vxl;
+ struct zebra_dplane_info dp_info;
int ret = 0;
+ zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
/* Save VLAN we're filtering on, if needed. */
br_zif = (struct zebra_if *)br_if->info;
/* Get bridge FDB table for specific bridge - we do the VLAN filtering.
*/
- ret = netlink_request_macs(zns, AF_BRIDGE, RTM_GETNEIGH,
+ ret = netlink_request_macs(&zns->netlink_cmd, AF_BRIDGE, RTM_GETNEIGH,
br_if->ifindex);
if (ret < 0)
return ret;
- ret = netlink_parse_info(netlink_macfdb_table, &zns->netlink_cmd, zns,
- 0, 0);
+ ret = netlink_parse_info(netlink_macfdb_table, &zns->netlink_cmd,
+ &dp_info, 0, 0);
/* Reset VLAN filter. */
filter_vlan = 0;
}
/* Request for IP neighbor information from the kernel */
-static int netlink_request_neigh(struct zebra_ns *zns, int family, int type,
- ifindex_t ifindex)
+static int netlink_request_neigh(struct nlsock *netlink_cmd, int family,
+ int type, ifindex_t ifindex)
{
struct {
struct nlmsghdr n;
if (ifindex)
addattr32(&req.n, sizeof(req), NDA_IFINDEX, ifindex);
- return netlink_request(&zns->netlink_cmd, &req.n);
+ return netlink_request(netlink_cmd, &req.n);
}
/*
int netlink_neigh_read(struct zebra_ns *zns)
{
int ret;
+ struct zebra_dplane_info dp_info;
+
+ zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
/* Get IP neighbor table. */
- ret = netlink_request_neigh(zns, AF_UNSPEC, RTM_GETNEIGH, 0);
+ ret = netlink_request_neigh(&zns->netlink_cmd, AF_UNSPEC, RTM_GETNEIGH,
+ 0);
if (ret < 0)
return ret;
- ret = netlink_parse_info(netlink_neigh_table, &zns->netlink_cmd, zns, 0,
- 1);
+ ret = netlink_parse_info(netlink_neigh_table, &zns->netlink_cmd,
+ &dp_info, 0, 1);
return ret;
}
int netlink_neigh_read_for_vlan(struct zebra_ns *zns, struct interface *vlan_if)
{
int ret = 0;
+ struct zebra_dplane_info dp_info;
+
+ zebra_dplane_info_from_zns(&dp_info, zns, true /*is_cmd*/);
- ret = netlink_request_neigh(zns, AF_UNSPEC, RTM_GETNEIGH,
+ ret = netlink_request_neigh(&zns->netlink_cmd, AF_UNSPEC, RTM_GETNEIGH,
vlan_if->ifindex);
if (ret < 0)
return ret;
- ret = netlink_parse_info(netlink_neigh_table, &zns->netlink_cmd, zns, 0,
- 0);
+ ret = netlink_parse_info(netlink_neigh_table, &zns->netlink_cmd,
+ &dp_info, 0, 0);
return ret;
}
return 0;
}
-enum dp_req_result kernel_route_rib(struct route_node *rn,
- const struct prefix *p,
- const struct prefix *src_p,
- struct route_entry *old,
- struct route_entry *new)
+enum zebra_dplane_result kernel_route_rib(struct route_node *rn,
+ const struct prefix *p,
+ const struct prefix *src_p,
+ struct route_entry *old,
+ struct route_entry *new)
{
int route = 0;
if (src_p && src_p->prefixlen) {
flog_warn(EC_ZEBRA_UNSUPPORTED_V6_SRCDEST,
"%s: IPv6 sourcedest routes unsupported!", __func__);
- return DP_REQUEST_FAILURE;
+ return ZEBRA_DPLANE_REQUEST_FAILURE;
}
frr_elevate_privs(&zserv_privs) {
if (new) {
kernel_route_rib_pass_fail(
rn, p, new,
- (!route) ? DP_INSTALL_SUCCESS
- : DP_INSTALL_FAILURE);
+ (!route) ? ZEBRA_DPLANE_INSTALL_SUCCESS
+ : ZEBRA_DPLANE_INSTALL_FAILURE);
} else {
kernel_route_rib_pass_fail(rn, p, old,
(!route)
- ? DP_DELETE_SUCCESS
- : DP_DELETE_FAILURE);
+ ? ZEBRA_DPLANE_DELETE_SUCCESS
+ : ZEBRA_DPLANE_DELETE_FAILURE);
}
- return DP_REQUEST_SUCCESS;
+ return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
int kernel_neigh_update(int add, int ifindex, uint32_t addr, char *lla,
rtadv_send_packet(zns->rtadv.sock, ifp);
}
+/*
+ * This function processes optional attributes off of
+ * end of a RA packet received. At this point in
+ * time we only care about this in one situation
+ * which is when a interface does not have a LL
+ * v6 address. We still need to be able to install
+ * the mac address for v4 to v6 resolution
+ */
+static void rtadv_process_optional(uint8_t *optional, unsigned int len,
+ struct interface *ifp,
+ struct sockaddr_in6 *addr)
+{
+ char *mac;
+
+ while (len > 0) {
+ struct nd_opt_hdr *opt_hdr = (struct nd_opt_hdr *)optional;
+
+ switch(opt_hdr->nd_opt_type) {
+ case ND_OPT_SOURCE_LINKADDR:
+ mac = (char *)(optional+2);
+ if_nbr_mac_to_ipv4ll_neigh_update(ifp, mac,
+ &addr->sin6_addr, 1);
+ break;
+ default:
+ break;
+ }
+
+ len -= 8 * opt_hdr->nd_opt_len;
+ optional += 8 * opt_hdr->nd_opt_len;
+ }
+}
+
static void rtadv_process_advert(uint8_t *msg, unsigned int len,
struct interface *ifp,
struct sockaddr_in6 *addr)
inet_ntop(AF_INET6, &addr->sin6_addr, addr_str, INET6_ADDRSTRLEN);
if (len < sizeof(struct nd_router_advert)) {
- zlog_debug("%s(%u): Rx RA with invalid length %d from %s",
- ifp->name, ifp->ifindex, len, addr_str);
+ if (IS_ZEBRA_DEBUG_PACKET)
+ zlog_debug("%s(%u): Rx RA with invalid length %d from %s",
+ ifp->name, ifp->ifindex, len, addr_str);
return;
}
+
if (!IN6_IS_ADDR_LINKLOCAL(&addr->sin6_addr)) {
- zlog_debug(
- "%s(%u): Rx RA with non-linklocal source address from %s",
- ifp->name, ifp->ifindex, addr_str);
+ rtadv_process_optional(msg + sizeof(struct nd_router_advert),
+ len - sizeof(struct nd_router_advert),
+ ifp, addr);
+ if (IS_ZEBRA_DEBUG_PACKET)
+ zlog_debug("%s(%u): Rx RA with non-linklocal source address from %s",
+ ifp->name, ifp->ifindex, addr_str);
return;
}
* goes in the rule to denote relative ordering; it may or may not be the
* same as the rule's user-defined sequence number.
*/
-enum dp_req_result kernel_add_pbr_rule(struct zebra_pbr_rule *rule)
+enum zebra_dplane_result kernel_add_pbr_rule(struct zebra_pbr_rule *rule)
{
int ret = 0;
ret = netlink_rule_update(RTM_NEWRULE, rule);
kernel_pbr_rule_add_del_status(rule,
- (!ret) ? DP_INSTALL_SUCCESS
- : DP_INSTALL_FAILURE);
+ (!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
+ : ZEBRA_DPLANE_INSTALL_FAILURE);
- return DP_REQUEST_SUCCESS;
+ return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
/*
* Uninstall specified rule for a specific interface.
*/
-enum dp_req_result kernel_del_pbr_rule(struct zebra_pbr_rule *rule)
+enum zebra_dplane_result kernel_del_pbr_rule(struct zebra_pbr_rule *rule)
{
int ret = 0;
ret = netlink_rule_update(RTM_DELRULE, rule);
kernel_pbr_rule_add_del_status(rule,
- (!ret) ? DP_DELETE_SUCCESS
- : DP_DELETE_FAILURE);
+ (!ret) ? ZEBRA_DPLANE_DELETE_SUCCESS
+ : ZEBRA_DPLANE_DELETE_FAILURE);
- return DP_REQUEST_SUCCESS;
+ return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
/*
#include "zebra/zebra_pbr.h"
#include "zebra/zebra_errors.h"
-enum dp_req_result kernel_add_pbr_rule(struct zebra_pbr_rule *rule)
+enum zebra_dplane_result kernel_add_pbr_rule(struct zebra_pbr_rule *rule)
{
flog_err(EC_LIB_UNAVAILABLE, "%s not Implemented for this platform",
__PRETTY_FUNCTION__);
- return DP_REQUEST_FAILURE;
+ return ZEBRA_DPLANE_REQUEST_FAILURE;
}
-enum dp_req_result kernel_del_pbr_rule(struct zebra_pbr_rule *rule)
+enum zebra_dplane_result kernel_del_pbr_rule(struct zebra_pbr_rule *rule)
{
flog_err(EC_LIB_UNAVAILABLE, "%s not Implemented for this platform",
__PRETTY_FUNCTION__);
- return DP_REQUEST_FAILURE;
+ return ZEBRA_DPLANE_REQUEST_FAILURE;
}
#endif
zebra/rule_socket.c \
zebra/zebra_l2.c \
zebra/zebra_memory.c \
+ zebra/zebra_dplane.c \
zebra/zebra_mpls.c \
zebra/zebra_mpls_netlink.c \
zebra/zebra_mpls_openbsd.c \
zebra/rule_netlink.h \
zebra/zebra_fpm_private.h \
zebra/zebra_l2.h \
+ zebra/zebra_dplane.h \
zebra/zebra_memory.h \
zebra/zebra_mpls.h \
zebra/zebra_mroute.h \
--- /dev/null
+/*
+ * Zebra dataplane layer.
+ * Copyright (c) 2018 Volta Networks, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+#include "zebra_dplane.h"
--- /dev/null
+/*
+ * Zebra dataplane layer api interfaces.
+ * Copyright (c) 2018 Volta Networks, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef _ZEBRA_DPLANE_H
+#define _ZEBRA_DPLANE_H 1
+
+#include "zebra.h"
+#include "zserv.h"
+#include "prefix.h"
+#include "nexthop.h"
+#include "nexthop_group.h"
+
+
+/*
+ * API between the zebra dataplane system and the main zebra processing
+ * context.
+ */
+
+/* Key netlink info from zebra ns */
+struct zebra_dplane_info {
+ ns_id_t ns_id;
+
+#if defined(HAVE_NETLINK)
+ uint32_t nl_pid;
+ bool is_cmd;
+#endif
+};
+
+/* Utility to fill in zns info from main zns struct */
+static inline void
+zebra_dplane_info_from_zns(struct zebra_dplane_info *zns_info,
+ const struct zebra_ns *zns, bool is_cmd)
+{
+ zns_info->ns_id = zns->ns_id;
+
+#if defined(HAVE_NETLINK)
+ zns_info->is_cmd = is_cmd;
+ if (is_cmd) {
+ zns_info->nl_pid = zns->netlink_cmd.snl.nl_pid;
+ } else {
+ zns_info->nl_pid = zns->netlink.snl.nl_pid;
+ }
+#endif /* NETLINK */
+}
+
+/*
+ * Enqueue a route install or update for the dataplane.
+ */
+
+/*
+ * Enqueue a route removal for the dataplane.
+ */
+
+/*
+ * Result codes used when returning status back to the main zebra context.
+ */
+
+/*
+ * Philosophy Note:
+ *
+ * Flags being SET/UNSET do not belong in the South Bound
+ * Interface. This Setting belongs at the calling level
+ * because we can and will have multiple different interfaces
+ * and we will have potentially multiple different
+ * modules/filters to call. As such Setting/Unsetting
+ * success failure should be handled by the caller.
+ */
+enum zebra_dplane_status {
+ ZEBRA_DPLANE_STATUS_NONE = 0,
+ ZEBRA_DPLANE_INSTALL_SUCCESS,
+ ZEBRA_DPLANE_INSTALL_FAILURE,
+ ZEBRA_DPLANE_DELETE_SUCCESS,
+ ZEBRA_DPLANE_DELETE_FAILURE,
+
+};
+
+enum zebra_dplane_result {
+ ZEBRA_DPLANE_REQUEST_QUEUED,
+ ZEBRA_DPLANE_REQUEST_SUCCESS,
+ ZEBRA_DPLANE_REQUEST_FAILURE,
+};
+
+#endif /* _ZEBRA_DPLANE_H */
#include "prefix.h"
#include "zebra/zserv.h"
+#include "zebra/zebra_dplane.h"
#include "zebra/zebra_ns.h"
#include "zebra/zebra_vrf.h"
#include "zebra/kernel_netlink.h"
UNSET_FLAG(lsp->flags, LSP_FLAG_CHANGED);
switch (kernel_add_lsp(lsp)) {
- case DP_REQUEST_QUEUED:
+ case ZEBRA_DPLANE_REQUEST_QUEUED:
flog_err(
EC_ZEBRA_DP_INVALID_RC,
"No current DataPlane interfaces can return this, please fix");
break;
- case DP_REQUEST_FAILURE:
+ case ZEBRA_DPLANE_REQUEST_FAILURE:
break;
- case DP_REQUEST_SUCCESS:
+ case ZEBRA_DPLANE_REQUEST_SUCCESS:
zvrf->lsp_installs++;
break;
}
if (!newbest) {
switch (kernel_del_lsp(lsp)) {
- case DP_REQUEST_QUEUED:
+ case ZEBRA_DPLANE_REQUEST_QUEUED:
flog_err(
EC_ZEBRA_DP_INVALID_RC,
"No current DataPlane interfaces can return this, please fix");
break;
- case DP_REQUEST_FAILURE:
+ case ZEBRA_DPLANE_REQUEST_FAILURE:
break;
- case DP_REQUEST_SUCCESS:
+ case ZEBRA_DPLANE_REQUEST_SUCCESS:
zvrf->lsp_removals++;
break;
}
}
switch (kernel_upd_lsp(lsp)) {
- case DP_REQUEST_QUEUED:
+ case ZEBRA_DPLANE_REQUEST_QUEUED:
flog_err(
EC_ZEBRA_DP_INVALID_RC,
"No current DataPlane interfaces can return this, please fix");
break;
- case DP_REQUEST_FAILURE:
+ case ZEBRA_DPLANE_REQUEST_FAILURE:
break;
- case DP_REQUEST_SUCCESS:
+ case ZEBRA_DPLANE_REQUEST_SUCCESS:
zvrf->lsp_installs++;
break;
}
/* Public functions */
-void kernel_lsp_pass_fail(zebra_lsp_t *lsp, enum dp_results res)
+void kernel_lsp_pass_fail(zebra_lsp_t *lsp, enum zebra_dplane_status res)
{
struct nexthop *nexthop;
zebra_nhlfe_t *nhlfe;
return;
switch (res) {
- case DP_INSTALL_FAILURE:
+ case ZEBRA_DPLANE_INSTALL_FAILURE:
UNSET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
clear_nhlfe_installed(lsp);
flog_warn(EC_ZEBRA_LSP_INSTALL_FAILURE,
"LSP Install Failure: %u", lsp->ile.in_label);
break;
- case DP_INSTALL_SUCCESS:
+ case ZEBRA_DPLANE_INSTALL_SUCCESS:
SET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
for (nhlfe = lsp->nhlfe_list; nhlfe; nhlfe = nhlfe->next) {
nexthop = nhlfe->nexthop;
SET_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB);
}
break;
- case DP_DELETE_SUCCESS:
+ case ZEBRA_DPLANE_DELETE_SUCCESS:
UNSET_FLAG(lsp->flags, LSP_FLAG_INSTALLED);
clear_nhlfe_installed(lsp);
break;
- case DP_DELETE_FAILURE:
+ case ZEBRA_DPLANE_DELETE_FAILURE:
flog_warn(EC_ZEBRA_LSP_DELETE_FAILURE,
"LSP Deletion Failure: %u", lsp->ile.in_label);
break;
+ case ZEBRA_DPLANE_STATUS_NONE:
+ break;
}
}
/*
* Install Label Forwarding entry into the kernel.
*/
-enum dp_req_result kernel_add_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_add_lsp(zebra_lsp_t *lsp)
{
int ret;
if (!lsp || !lsp->best_nhlfe) { // unexpected
- kernel_lsp_pass_fail(lsp, DP_INSTALL_FAILURE);
- return DP_REQUEST_FAILURE;
+ kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_INSTALL_FAILURE);
+ return ZEBRA_DPLANE_REQUEST_FAILURE;
}
ret = netlink_mpls_multipath(RTM_NEWROUTE, lsp);
kernel_lsp_pass_fail(lsp,
- (!ret) ? DP_INSTALL_SUCCESS
- : DP_INSTALL_FAILURE);
+ (!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
+ : ZEBRA_DPLANE_INSTALL_FAILURE);
- return DP_REQUEST_SUCCESS;
+ return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
/*
* through the metric field (before kernel-MPLS). This shouldn't be an issue
* any longer, so REPLACE can be reintroduced.
*/
-enum dp_req_result kernel_upd_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_upd_lsp(zebra_lsp_t *lsp)
{
int ret;
if (!lsp || !lsp->best_nhlfe) { // unexpected
- kernel_lsp_pass_fail(lsp, DP_INSTALL_FAILURE);
- return DP_REQUEST_FAILURE;
+ kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_INSTALL_FAILURE);
+ return ZEBRA_DPLANE_REQUEST_FAILURE;
}
ret = netlink_mpls_multipath(RTM_NEWROUTE, lsp);
kernel_lsp_pass_fail(lsp,
- (!ret) ? DP_INSTALL_SUCCESS
- : DP_INSTALL_FAILURE);
+ (!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
+ : ZEBRA_DPLANE_INSTALL_FAILURE);
- return DP_REQUEST_SUCCESS;
+ return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
/*
* Delete Label Forwarding entry from the kernel.
*/
-enum dp_req_result kernel_del_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_del_lsp(zebra_lsp_t *lsp)
{
int ret;
if (!lsp) { // unexpected
- kernel_lsp_pass_fail(lsp, DP_DELETE_FAILURE);
- return DP_REQUEST_FAILURE;
+ kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_DELETE_FAILURE);
+ return ZEBRA_DPLANE_REQUEST_FAILURE;
}
if (!CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED)) {
- kernel_lsp_pass_fail(lsp, DP_DELETE_FAILURE);
- return DP_REQUEST_FAILURE;
+ kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_DELETE_FAILURE);
+ return ZEBRA_DPLANE_REQUEST_FAILURE;
}
ret = netlink_mpls_multipath(RTM_DELROUTE, lsp);
kernel_lsp_pass_fail(lsp,
- (!ret) ? DP_DELETE_SUCCESS
- : DP_DELETE_FAILURE);
+ (!ret) ? ZEBRA_DPLANE_DELETE_SUCCESS
+ : ZEBRA_DPLANE_DELETE_FAILURE);
- return DP_REQUEST_SUCCESS;
+ return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
int mpls_kernel_init(void)
#if !defined(HAVE_NETLINK) && !defined(OPEN_BSD)
-enum dp_req_result kernel_add_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_add_lsp(zebra_lsp_t *lsp)
{
- return DP_REQUEST_SUCCESS;
+ return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
-enum dp_req_result kernel_upd_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_upd_lsp(zebra_lsp_t *lsp)
{
- return DP_REQUEST_SUCCESS;
+ return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
-enum dp_req_result kernel_del_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_del_lsp(zebra_lsp_t *lsp)
{
- return DP_REQUEST_SUCCESS;
+ return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
int mpls_kernel_init(void)
return (0);
}
-enum dp_req_result kernel_add_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_add_lsp(zebra_lsp_t *lsp)
{
int ret;
if (!lsp || !lsp->best_nhlfe) { // unexpected
- kernel_lsp_pass_fail(lsp, DP_INSTALL_FAILURE);
- return DP_REQUEST_FAILURE;
+ kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_INSTALL_FAILURE);
+ return ZEBRA_DPLANE_REQUEST_FAILURE;
}
ret = kernel_lsp_cmd(RTM_ADD, lsp);
kernel_lsp_pass_fail(lsp,
- (!ret) ? DP_INSTALL_SUCCESS
- : DP_INSTALL_FAILURE);
+ (!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
+ : ZEBRA_DPLANE_INSTALL_FAILURE);
- return DP_REQUEST_SUCCESS;
+ return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
-enum dp_req_result kernel_upd_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_upd_lsp(zebra_lsp_t *lsp)
{
int ret;
if (!lsp || !lsp->best_nhlfe) { // unexpected
- kernel_lsp_pass_fail(lsp, DP_INSTALL_FAILURE);
- return DP_REQUEST_FAILURE;
+ kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_INSTALL_FAILURE);
+ return ZEBRA_DPLANE_REQUEST_FAILURE;
}
ret = kernel_lsp_cmd(RTM_CHANGE, lsp);
kernel_lsp_pass_fail(lsp,
- (!ret) ? DP_INSTALL_SUCCESS
- : DP_INSTALL_FAILURE);
- return DP_REQUEST_SUCCESS;
+ (!ret) ? ZEBRA_DPLANE_INSTALL_SUCCESS
+ : ZEBRA_DPLANE_INSTALL_FAILURE);
+ return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
-enum dp_req_result kernel_del_lsp(zebra_lsp_t *lsp)
+enum zebra_dplane_result kernel_del_lsp(zebra_lsp_t *lsp)
{
int ret;
if (!lsp) { // unexpected
- kernel_lsp_pass_fail(lsp, DP_DELETE_FAILURE);
- return DP_REQUEST_FAILURE;
+ kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_DELETE_FAILURE);
+ return ZEBRA_DPLANE_REQUEST_FAILURE;
}
if (!CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED)) {
- kernel_lsp_pass_fail(lsp, DP_DELETE_FAILURE);
- return DP_REQUEST_FAILURE;
+ kernel_lsp_pass_fail(lsp, ZEBRA_DPLANE_DELETE_FAILURE);
+ return ZEBRA_DPLANE_REQUEST_FAILURE;
}
ret = kernel_lsp_cmd(RTM_DELETE, lsp);
kernel_lsp_pass_fail(lsp,
- (!ret) ? DP_DELETE_SUCCESS
- : DP_DELETE_FAILURE);
+ (!ret) ? ZEBRA_DPLANE_DELETE_SUCCESS
+ : ZEBRA_DPLANE_DELETE_FAILURE);
- return DP_REQUEST_SUCCESS;
+ return ZEBRA_DPLANE_REQUEST_SUCCESS;
}
static int kmpw_install(struct zebra_pw *pw)
#include "log.h"
#include "lib_errors.h"
+#include "zebra/rib.h"
+#include "zebra/zebra_dplane.h"
#if defined(HAVE_NETLINK)
#include <linux/net_namespace.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
-#include "rib.h"
#include "zebra_ns.h"
#include "kernel_netlink.h"
#endif /* defined(HAVE_NETLINK) */
ret = hook_call(zebra_pbr_ipset_wrap_script_update,
zns, 1, ipset);
kernel_pbr_ipset_add_del_status(ipset,
- ret ? DP_INSTALL_SUCCESS
- : DP_INSTALL_FAILURE);
+ ret ? ZEBRA_DPLANE_INSTALL_SUCCESS
+ : ZEBRA_DPLANE_INSTALL_FAILURE);
}
void zebra_pbr_destroy_ipset(struct zebra_ns *zns,
ret = hook_call(zebra_pbr_ipset_entry_wrap_script_update,
zns, 1, ipset);
kernel_pbr_ipset_entry_add_del_status(ipset,
- ret ? DP_INSTALL_SUCCESS
- : DP_INSTALL_FAILURE);
+ ret ? ZEBRA_DPLANE_INSTALL_SUCCESS
+ : ZEBRA_DPLANE_INSTALL_FAILURE);
}
void zebra_pbr_del_ipset_entry(struct zebra_ns *zns,
pbr_iptable_alloc_intern);
ret = hook_call(zebra_pbr_iptable_wrap_script_update, zns, 1, iptable);
kernel_pbr_iptable_add_del_status(iptable,
- ret ? DP_INSTALL_SUCCESS
- : DP_INSTALL_FAILURE);
+ ret ? ZEBRA_DPLANE_INSTALL_SUCCESS
+ : ZEBRA_DPLANE_INSTALL_FAILURE);
}
void zebra_pbr_del_iptable(struct zebra_ns *zns,
* Handle success or failure of rule (un)install in the kernel.
*/
void kernel_pbr_rule_add_del_status(struct zebra_pbr_rule *rule,
- enum dp_results res)
+ enum zebra_dplane_status res)
{
switch (res) {
- case DP_INSTALL_SUCCESS:
+ case ZEBRA_DPLANE_INSTALL_SUCCESS:
zsend_rule_notify_owner(rule, ZAPI_RULE_INSTALLED);
break;
- case DP_INSTALL_FAILURE:
+ case ZEBRA_DPLANE_INSTALL_FAILURE:
zsend_rule_notify_owner(rule, ZAPI_RULE_FAIL_INSTALL);
break;
- case DP_DELETE_SUCCESS:
+ case ZEBRA_DPLANE_DELETE_SUCCESS:
zsend_rule_notify_owner(rule, ZAPI_RULE_REMOVED);
break;
- case DP_DELETE_FAILURE:
+ case ZEBRA_DPLANE_DELETE_FAILURE:
zsend_rule_notify_owner(rule, ZAPI_RULE_FAIL_REMOVE);
break;
+ case ZEBRA_DPLANE_STATUS_NONE:
+ break;
}
}
* Handle success or failure of ipset (un)install in the kernel.
*/
void kernel_pbr_ipset_add_del_status(struct zebra_pbr_ipset *ipset,
- enum dp_results res)
+ enum zebra_dplane_status res)
{
switch (res) {
- case DP_INSTALL_SUCCESS:
+ case ZEBRA_DPLANE_INSTALL_SUCCESS:
zsend_ipset_notify_owner(ipset, ZAPI_IPSET_INSTALLED);
break;
- case DP_INSTALL_FAILURE:
+ case ZEBRA_DPLANE_INSTALL_FAILURE:
zsend_ipset_notify_owner(ipset, ZAPI_IPSET_FAIL_INSTALL);
break;
- case DP_DELETE_SUCCESS:
+ case ZEBRA_DPLANE_DELETE_SUCCESS:
zsend_ipset_notify_owner(ipset, ZAPI_IPSET_REMOVED);
break;
- case DP_DELETE_FAILURE:
+ case ZEBRA_DPLANE_DELETE_FAILURE:
zsend_ipset_notify_owner(ipset, ZAPI_IPSET_FAIL_REMOVE);
break;
+ case ZEBRA_DPLANE_STATUS_NONE:
+ break;
}
}
*/
void kernel_pbr_ipset_entry_add_del_status(
struct zebra_pbr_ipset_entry *ipset,
- enum dp_results res)
+ enum zebra_dplane_status res)
{
switch (res) {
- case DP_INSTALL_SUCCESS:
+ case ZEBRA_DPLANE_INSTALL_SUCCESS:
zsend_ipset_entry_notify_owner(ipset,
ZAPI_IPSET_ENTRY_INSTALLED);
break;
- case DP_INSTALL_FAILURE:
+ case ZEBRA_DPLANE_INSTALL_FAILURE:
zsend_ipset_entry_notify_owner(ipset,
ZAPI_IPSET_ENTRY_FAIL_INSTALL);
break;
- case DP_DELETE_SUCCESS:
+ case ZEBRA_DPLANE_DELETE_SUCCESS:
zsend_ipset_entry_notify_owner(ipset,
ZAPI_IPSET_ENTRY_REMOVED);
break;
- case DP_DELETE_FAILURE:
+ case ZEBRA_DPLANE_DELETE_FAILURE:
zsend_ipset_entry_notify_owner(ipset,
ZAPI_IPSET_ENTRY_FAIL_REMOVE);
break;
+ case ZEBRA_DPLANE_STATUS_NONE:
+ break;
}
}
* Handle success or failure of ipset (un)install in the kernel.
*/
void kernel_pbr_iptable_add_del_status(struct zebra_pbr_iptable *iptable,
- enum dp_results res)
+ enum zebra_dplane_status res)
{
switch (res) {
- case DP_INSTALL_SUCCESS:
+ case ZEBRA_DPLANE_INSTALL_SUCCESS:
zsend_iptable_notify_owner(iptable, ZAPI_IPTABLE_INSTALLED);
break;
- case DP_INSTALL_FAILURE:
+ case ZEBRA_DPLANE_INSTALL_FAILURE:
zsend_iptable_notify_owner(iptable, ZAPI_IPTABLE_FAIL_INSTALL);
break;
- case DP_DELETE_SUCCESS:
+ case ZEBRA_DPLANE_DELETE_SUCCESS:
zsend_iptable_notify_owner(iptable,
ZAPI_IPTABLE_REMOVED);
break;
- case DP_DELETE_FAILURE:
+ case ZEBRA_DPLANE_DELETE_FAILURE:
zsend_iptable_notify_owner(iptable,
ZAPI_IPTABLE_FAIL_REMOVE);
break;
+ case ZEBRA_DPLANE_STATUS_NONE:
+ break;
}
}
* forwarding plane may not coincide, hence the API requires a separate
* rule priority - maps to preference/FRA_PRIORITY on Linux.
*/
-extern enum dp_req_result kernel_add_pbr_rule(struct zebra_pbr_rule *rule);
+extern enum zebra_dplane_result kernel_add_pbr_rule(struct zebra_pbr_rule *rule);
/*
* Uninstall specified rule for a specific interface.
*/
-extern enum dp_req_result kernel_del_pbr_rule(struct zebra_pbr_rule *rule);
+extern enum zebra_dplane_result kernel_del_pbr_rule(struct zebra_pbr_rule *rule);
/*
* Get to know existing PBR rules in the kernel - typically called at startup.
* Handle success or failure of rule (un)install in the kernel.
*/
extern void kernel_pbr_rule_add_del_status(struct zebra_pbr_rule *rule,
- enum dp_results res);
+ enum zebra_dplane_status res);
/*
* Handle success or failure of ipset kinds (un)install in the kernel.
*/
extern void kernel_pbr_ipset_add_del_status(struct zebra_pbr_ipset *ipset,
- enum dp_results res);
+ enum zebra_dplane_status res);
extern void kernel_pbr_ipset_entry_add_del_status(
struct zebra_pbr_ipset_entry *ipset,
- enum dp_results res);
+ enum zebra_dplane_status res);
extern void kernel_pbr_iptable_add_del_status(struct zebra_pbr_iptable *iptable,
- enum dp_results res);
+ enum zebra_dplane_status res);
/*
* Handle rule delete notification from kernel.
void kernel_route_rib_pass_fail(struct route_node *rn, const struct prefix *p,
struct route_entry *re,
- enum dp_results res)
+ enum zebra_dplane_status res)
{
struct nexthop *nexthop;
char buf[PREFIX_STRLEN];
dest = rib_dest_from_rnode(rn);
switch (res) {
- case DP_INSTALL_SUCCESS:
+ case ZEBRA_DPLANE_INSTALL_SUCCESS:
dest->selected_fib = re;
for (ALL_NEXTHOPS(re->ng, nexthop)) {
if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
}
zsend_route_notify_owner(re, p, ZAPI_ROUTE_INSTALLED);
break;
- case DP_INSTALL_FAILURE:
+ case ZEBRA_DPLANE_INSTALL_FAILURE:
/*
* I am not sure this is the right thing to do here
* but the code always set selected_fib before
"%u:%s: Route install failed", re->vrf_id,
prefix2str(p, buf, sizeof(buf)));
break;
- case DP_DELETE_SUCCESS:
+ case ZEBRA_DPLANE_DELETE_SUCCESS:
/*
* The case where selected_fib is not re is
* when we have received a system route
zsend_route_notify_owner(re, p, ZAPI_ROUTE_REMOVED);
break;
- case DP_DELETE_FAILURE:
+ case ZEBRA_DPLANE_DELETE_FAILURE:
/*
* Should we set this to NULL if the
* delete fails?
zsend_route_notify_owner(re, p, ZAPI_ROUTE_REMOVE_FAIL);
break;
+ case ZEBRA_DPLANE_STATUS_NONE:
+ break;
}
}
*/
hook_call(rib_update, rn, "installing in kernel");
switch (kernel_route_rib(rn, p, src_p, old, re)) {
- case DP_REQUEST_QUEUED:
+ case ZEBRA_DPLANE_REQUEST_QUEUED:
flog_err(
EC_ZEBRA_DP_INVALID_RC,
"No current known DataPlane interfaces can return this, please fix");
break;
- case DP_REQUEST_FAILURE:
+ case ZEBRA_DPLANE_REQUEST_FAILURE:
flog_err(
EC_ZEBRA_DP_INSTALL_FAIL,
"No current known Rib Install Failure cases, please fix");
break;
- case DP_REQUEST_SUCCESS:
+ case ZEBRA_DPLANE_REQUEST_SUCCESS:
zvrf->installs++;
break;
}
*/
hook_call(rib_update, rn, "uninstalling from kernel");
switch (kernel_route_rib(rn, p, src_p, re, NULL)) {
- case DP_REQUEST_QUEUED:
+ case ZEBRA_DPLANE_REQUEST_QUEUED:
flog_err(
EC_ZEBRA_DP_INVALID_RC,
"No current known DataPlane interfaces can return this, please fix");
break;
- case DP_REQUEST_FAILURE:
+ case ZEBRA_DPLANE_REQUEST_FAILURE:
flog_err(
EC_ZEBRA_DP_INSTALL_FAIL,
"No current known RIB Install Failure cases, please fix");
break;
- case DP_REQUEST_SUCCESS:
+ case ZEBRA_DPLANE_REQUEST_SUCCESS:
if (zvrf)
zvrf->removals++;
break;
projects / mirror_frr.git / commitdiff