summaryrefslogtreecommitdiffstats
path: root/ldpd/interface.c
diff options
context:
space:
mode:
Diffstat (limited to 'ldpd/interface.c')
-rw-r--r--ldpd/interface.c983
1 files changed, 983 insertions, 0 deletions
diff --git a/ldpd/interface.c b/ldpd/interface.c
new file mode 100644
index 0000000..392e254
--- /dev/null
+++ b/ldpd/interface.c
@@ -0,0 +1,983 @@
+/* $OpenBSD$ */
+
+/*
+ * Copyright (c) 2013, 2016 Renato Westphal <renato@openbsd.org>
+ * Copyright (c) 2005 Claudio Jeker <claudio@openbsd.org>
+ * Copyright (c) 2004, 2005, 2008 Esben Norby <norby@openbsd.org>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <zebra.h>
+
+#include "ldpd.h"
+#include "ldpe.h"
+#include "log.h"
+#include "ldp_debug.h"
+
+#include "sockopt.h"
+
+static __inline int iface_compare(const struct iface *, const struct iface *);
+static struct if_addr *if_addr_new(struct kaddr *);
+static struct if_addr *if_addr_lookup(struct if_addr_head *, struct kaddr *);
+static int if_start(struct iface *, int);
+static int if_reset(struct iface *, int);
+static void if_update_af(struct iface_af *);
+static void if_hello_timer(struct thread *thread);
+static void if_start_hello_timer(struct iface_af *);
+static void if_stop_hello_timer(struct iface_af *);
+static int if_join_ipv4_group(struct iface *, struct in_addr *);
+static int if_leave_ipv4_group(struct iface *, struct in_addr *);
+static int if_join_ipv6_group(struct iface *, struct in6_addr *);
+static int if_leave_ipv6_group(struct iface *, struct in6_addr *);
+
+static int ldp_sync_fsm_init(struct iface *iface, int state);
+static int ldp_sync_act_iface_start_sync(struct iface *iface);
+static void iface_wait_for_ldp_sync_timer(struct thread *thread);
+static void start_wait_for_ldp_sync_timer(struct iface *iface);
+static void stop_wait_for_ldp_sync_timer(struct iface *iface);
+static int ldp_sync_act_ldp_start_sync(struct iface *iface);
+static int ldp_sync_act_ldp_complete_sync(struct iface *iface);
+static int iface_to_oper_nbr_count(struct iface *iface, unsigned int type);
+static void ldp_sync_get_peer_ldp_id(struct iface *iface,
+ struct in_addr *peer_ldp_id);
+
+RB_GENERATE(iface_head, iface, entry, iface_compare)
+
+static __inline int
+iface_compare(const struct iface *a, const struct iface *b)
+{
+ return if_cmp_name_func(a->name, b->name);
+}
+
+struct iface *
+if_new(const char *name)
+{
+ struct iface *iface;
+
+ if ((iface = calloc(1, sizeof(*iface))) == NULL)
+ fatal("if_new: calloc");
+
+ strlcpy(iface->name, name, sizeof(iface->name));
+
+ /* ipv4 */
+ iface->ipv4.af = AF_INET;
+ iface->ipv4.iface = iface;
+ iface->ipv4.enabled = 0;
+
+ /* ipv6 */
+ iface->ipv6.af = AF_INET6;
+ iface->ipv6.iface = iface;
+ iface->ipv6.enabled = 0;
+
+ return (iface);
+}
+
+void
+ldpe_if_init(struct iface *iface)
+{
+ log_debug("%s: interface %s", __func__, iface->name);
+
+ LIST_INIT(&iface->addr_list);
+
+ /* ipv4 */
+ iface->ipv4.iface = iface;
+ iface->ipv4.state = IF_STA_DOWN;
+ RB_INIT(ia_adj_head, &iface->ipv4.adj_tree);
+
+ /* ipv6 */
+ iface->ipv6.iface = iface;
+ iface->ipv6.state = IF_STA_DOWN;
+ RB_INIT(ia_adj_head, &iface->ipv6.adj_tree);
+
+ /* LGP IGP Sync */
+ ldp_sync_fsm_init(iface, LDP_SYNC_STA_NOT_ACH);
+}
+
+void
+ldpe_if_exit(struct iface *iface)
+{
+ struct if_addr *if_addr;
+
+ log_debug("%s: interface %s", __func__, iface->name);
+
+ ldp_sync_fsm(iface, LDP_SYNC_EVT_CONFIG_LDP_OFF);
+
+ if (iface->ipv4.state == IF_STA_ACTIVE)
+ if_reset(iface, AF_INET);
+ if (iface->ipv6.state == IF_STA_ACTIVE)
+ if_reset(iface, AF_INET6);
+
+ while ((if_addr = LIST_FIRST(&iface->addr_list)) != NULL) {
+ LIST_REMOVE(if_addr, entry);
+ assert(if_addr != LIST_FIRST(&iface->addr_list));
+ free(if_addr);
+ }
+}
+
+struct iface *
+if_lookup(struct ldpd_conf *xconf, ifindex_t ifindex)
+{
+ struct iface *iface;
+
+ RB_FOREACH(iface, iface_head, &xconf->iface_tree)
+ if (iface->ifindex == ifindex)
+ return (iface);
+
+ return (NULL);
+}
+
+struct iface *
+if_lookup_name(struct ldpd_conf *xconf, const char *ifname)
+{
+ struct iface iface;
+ strlcpy(iface.name, ifname, sizeof(iface.name));
+ return (RB_FIND(iface_head, &xconf->iface_tree, &iface));
+}
+
+void
+if_update_info(struct iface *iface, struct kif *kif)
+{
+ /* get type */
+ if (kif->flags & IFF_POINTOPOINT)
+ iface->type = IF_TYPE_POINTOPOINT;
+ if (kif->flags & IFF_BROADCAST &&
+ kif->flags & IFF_MULTICAST)
+ iface->type = IF_TYPE_BROADCAST;
+
+ if (ldpd_process == PROC_LDP_ENGINE && iface->operative &&
+ !kif->operative)
+ ldp_sync_fsm(iface, LDP_SYNC_EVT_IFACE_SHUTDOWN);
+
+ /* get index and flags */
+ iface->ifindex = kif->ifindex;
+ iface->operative = kif->operative;
+}
+
+struct iface_af *
+iface_af_get(struct iface *iface, int af)
+{
+ switch (af) {
+ case AF_INET:
+ return (&iface->ipv4);
+ case AF_INET6:
+ return (&iface->ipv6);
+ default:
+ fatalx("iface_af_get: unknown af");
+ }
+}
+
+static struct if_addr *
+if_addr_new(struct kaddr *ka)
+{
+ struct if_addr *if_addr;
+
+ if ((if_addr = calloc(1, sizeof(*if_addr))) == NULL)
+ fatal(__func__);
+
+ if_addr->af = ka->af;
+ if_addr->addr = ka->addr;
+ if_addr->prefixlen = ka->prefixlen;
+ if_addr->dstbrd = ka->dstbrd;
+
+ return (if_addr);
+}
+
+static struct if_addr *
+if_addr_lookup(struct if_addr_head *addr_list, struct kaddr *ka)
+{
+ struct if_addr *if_addr;
+ int af = ka->af;
+
+ LIST_FOREACH(if_addr, addr_list, entry)
+ if (!ldp_addrcmp(af, &if_addr->addr, &ka->addr) &&
+ if_addr->prefixlen == ka->prefixlen &&
+ !ldp_addrcmp(af, &if_addr->dstbrd, &ka->dstbrd))
+ return (if_addr);
+
+ return (NULL);
+}
+
+void
+if_addr_add(struct kaddr *ka)
+{
+ struct iface *iface;
+ struct if_addr *if_addr;
+ struct nbr *nbr;
+
+ if (if_addr_lookup(&global.addr_list, ka) == NULL) {
+ if_addr = if_addr_new(ka);
+
+ LIST_INSERT_HEAD(&global.addr_list, if_addr, entry);
+ RB_FOREACH(nbr, nbr_id_head, &nbrs_by_id) {
+ if (nbr->state != NBR_STA_OPER)
+ continue;
+ if (if_addr->af == AF_INET && !nbr->v4_enabled)
+ continue;
+ if (if_addr->af == AF_INET6 && !nbr->v6_enabled)
+ continue;
+
+ send_address_single(nbr, if_addr, 0);
+ }
+ }
+
+ iface = if_lookup_name(leconf, ka->ifname);
+ if (iface) {
+ if (ka->af == AF_INET6 && IN6_IS_ADDR_LINKLOCAL(&ka->addr.v6))
+ iface->linklocal = ka->addr.v6;
+
+ if (if_addr_lookup(&iface->addr_list, ka) == NULL) {
+ if_addr = if_addr_new(ka);
+ LIST_INSERT_HEAD(&iface->addr_list, if_addr, entry);
+ ldp_if_update(iface, if_addr->af);
+ }
+ }
+}
+
+void
+if_addr_del(struct kaddr *ka)
+{
+ struct iface *iface;
+ struct if_addr *if_addr;
+ struct nbr *nbr;
+
+ iface = if_lookup_name(leconf, ka->ifname);
+ if (iface) {
+ if (ka->af == AF_INET6 &&
+ IN6_ARE_ADDR_EQUAL(&iface->linklocal, &ka->addr.v6))
+ memset(&iface->linklocal, 0, sizeof(iface->linklocal));
+
+ if_addr = if_addr_lookup(&iface->addr_list, ka);
+ if (if_addr) {
+ LIST_REMOVE(if_addr, entry);
+ ldp_if_update(iface, if_addr->af);
+ free(if_addr);
+ }
+ }
+
+ if_addr = if_addr_lookup(&global.addr_list, ka);
+ if (if_addr) {
+ RB_FOREACH(nbr, nbr_id_head, &nbrs_by_id) {
+ if (nbr->state != NBR_STA_OPER)
+ continue;
+ if (if_addr->af == AF_INET && !nbr->v4_enabled)
+ continue;
+ if (if_addr->af == AF_INET6 && !nbr->v6_enabled)
+ continue;
+ send_address_single(nbr, if_addr, 1);
+ }
+ LIST_REMOVE(if_addr, entry);
+ free(if_addr);
+ }
+}
+
+static int
+if_start(struct iface *iface, int af)
+{
+ struct iface_af *ia;
+ struct timeval now;
+
+ log_debug("%s: %s address-family %s", __func__, iface->name,
+ af_name(af));
+
+ ia = iface_af_get(iface, af);
+
+ gettimeofday(&now, NULL);
+ ia->uptime = now.tv_sec;
+
+ switch (af) {
+ case AF_INET:
+ if (if_join_ipv4_group(iface, &global.mcast_addr_v4))
+ return (-1);
+ break;
+ case AF_INET6:
+ if (if_join_ipv6_group(iface, &global.mcast_addr_v6))
+ return (-1);
+ break;
+ default:
+ fatalx("if_start: unknown af");
+ }
+
+ send_hello(HELLO_LINK, ia, NULL);
+ if_start_hello_timer(ia);
+ ia->state = IF_STA_ACTIVE;
+
+ return (0);
+}
+
+static int
+if_reset(struct iface *iface, int af)
+{
+ struct iface_af *ia;
+ struct adj *adj;
+
+ log_debug("%s: %s address-family %s", __func__, iface->name,
+ af_name(af));
+
+ ia = iface_af_get(iface, af);
+ if_stop_hello_timer(ia);
+
+ while (!RB_EMPTY(ia_adj_head, &ia->adj_tree)) {
+ adj = RB_ROOT(ia_adj_head, &ia->adj_tree);
+
+ adj_del(adj, S_SHUTDOWN);
+ }
+
+ /* try to cleanup */
+ switch (af) {
+ case AF_INET:
+ if (global.ipv4.ldp_disc_socket != -1)
+ if_leave_ipv4_group(iface, &global.mcast_addr_v4);
+ break;
+ case AF_INET6:
+ if (global.ipv6.ldp_disc_socket != -1)
+ if_leave_ipv6_group(iface, &global.mcast_addr_v6);
+ break;
+ default:
+ fatalx("if_reset: unknown af");
+ }
+
+ ia->state = IF_STA_DOWN;
+
+ return (0);
+}
+
+static void
+if_update_af(struct iface_af *ia)
+{
+ int addr_ok = 0, socket_ok, rtr_id_ok;
+ struct if_addr *if_addr;
+
+ switch (ia->af) {
+ case AF_INET:
+ /*
+ * NOTE: for LDPv4, each interface should have at least one
+ * valid IP address otherwise they can not be enabled.
+ */
+ LIST_FOREACH(if_addr, &ia->iface->addr_list, entry) {
+ if (if_addr->af == AF_INET) {
+ addr_ok = 1;
+ break;
+ }
+ }
+ break;
+ case AF_INET6:
+ /* for IPv6 the link-local address is enough. */
+ if (IN6_IS_ADDR_LINKLOCAL(&ia->iface->linklocal))
+ addr_ok = 1;
+ break;
+ default:
+ fatalx("if_update_af: unknown af");
+ }
+
+ if ((ldp_af_global_get(&global, ia->af))->ldp_disc_socket != -1)
+ socket_ok = 1;
+ else
+ socket_ok = 0;
+
+ if (ldp_rtr_id_get(leconf) != INADDR_ANY)
+ rtr_id_ok = 1;
+ else
+ rtr_id_ok = 0;
+
+ if (ia->state == IF_STA_DOWN) {
+ if (!ia->enabled || !ia->iface->operative || !addr_ok ||
+ !socket_ok || !rtr_id_ok)
+ return;
+
+ if_start(ia->iface, ia->af);
+ } else if (ia->state == IF_STA_ACTIVE) {
+ if (ia->enabled && ia->iface->operative && addr_ok &&
+ socket_ok && rtr_id_ok)
+ return;
+
+ if_reset(ia->iface, ia->af);
+ }
+}
+
+void
+ldp_if_update(struct iface *iface, int af)
+{
+ if (af == AF_INET || af == AF_UNSPEC)
+ if_update_af(&iface->ipv4);
+ if (af == AF_INET6 || af == AF_UNSPEC)
+ if_update_af(&iface->ipv6);
+}
+
+void
+if_update_all(int af)
+{
+ struct iface *iface;
+
+ RB_FOREACH(iface, iface_head, &leconf->iface_tree)
+ ldp_if_update(iface, af);
+}
+
+uint16_t
+if_get_hello_holdtime(struct iface_af *ia)
+{
+ if (ia->hello_holdtime != 0)
+ return (ia->hello_holdtime);
+
+ if ((ldp_af_conf_get(leconf, ia->af))->lhello_holdtime != 0)
+ return ((ldp_af_conf_get(leconf, ia->af))->lhello_holdtime);
+
+ return (leconf->lhello_holdtime);
+}
+
+uint16_t
+if_get_hello_interval(struct iface_af *ia)
+{
+ if (ia->hello_interval != 0)
+ return (ia->hello_interval);
+
+ if ((ldp_af_conf_get(leconf, ia->af))->lhello_interval != 0)
+ return ((ldp_af_conf_get(leconf, ia->af))->lhello_interval);
+
+ return (leconf->lhello_interval);
+}
+
+uint16_t
+if_get_wait_for_sync_interval(void)
+{
+ return (leconf->wait_for_sync_interval);
+}
+
+/* timers */
+/* ARGSUSED */
+static void if_hello_timer(struct thread *thread)
+{
+ struct iface_af *ia = THREAD_ARG(thread);
+
+ ia->hello_timer = NULL;
+ send_hello(HELLO_LINK, ia, NULL);
+ if_start_hello_timer(ia);
+}
+
+static void
+if_start_hello_timer(struct iface_af *ia)
+{
+ THREAD_OFF(ia->hello_timer);
+ thread_add_timer(master, if_hello_timer, ia, if_get_hello_interval(ia),
+ &ia->hello_timer);
+}
+
+static void
+if_stop_hello_timer(struct iface_af *ia)
+{
+ THREAD_OFF(ia->hello_timer);
+}
+
+struct ctl_iface *
+if_to_ctl(struct iface_af *ia)
+{
+ static struct ctl_iface ictl;
+ struct timeval now;
+ struct adj *adj;
+
+ ictl.af = ia->af;
+ memcpy(ictl.name, ia->iface->name, sizeof(ictl.name));
+ ictl.ifindex = ia->iface->ifindex;
+ ictl.state = ia->state;
+ ictl.type = ia->iface->type;
+ ictl.hello_holdtime = if_get_hello_holdtime(ia);
+ ictl.hello_interval = if_get_hello_interval(ia);
+
+ gettimeofday(&now, NULL);
+ if (ia->state != IF_STA_DOWN &&
+ ia->uptime != 0) {
+ ictl.uptime = now.tv_sec - ia->uptime;
+ } else
+ ictl.uptime = 0;
+
+ ictl.adj_cnt = 0;
+ RB_FOREACH(adj, ia_adj_head, &ia->adj_tree)
+ ictl.adj_cnt++;
+
+ return (&ictl);
+}
+
+static void
+ldp_sync_get_peer_ldp_id(struct iface *iface, struct in_addr *peer_ldp_id)
+{
+ struct iface_af *ia;
+ struct adj *adj;
+
+ if (iface->ipv4.state == IF_STA_ACTIVE) {
+ ia = iface_af_get(iface, AF_INET);
+ RB_FOREACH(adj, ia_adj_head, &ia->adj_tree)
+ if (adj->nbr && adj->nbr->state == NBR_STA_OPER) {
+ *peer_ldp_id = adj->nbr->id;
+ return;
+ }
+ }
+
+ if (iface->ipv6.state == IF_STA_ACTIVE) {
+ ia = iface_af_get(iface, AF_INET6);
+ RB_FOREACH(adj, ia_adj_head, &ia->adj_tree)
+ if (adj->nbr && adj->nbr->state == NBR_STA_OPER) {
+ *peer_ldp_id = adj->nbr->id;
+ return;
+ }
+ }
+}
+
+struct ctl_ldp_sync *
+ldp_sync_to_ctl(struct iface *iface)
+{
+ static struct ctl_ldp_sync ictl;
+
+ memcpy(ictl.name, iface->name, sizeof(ictl.name));
+ ictl.ifindex = iface->ifindex;
+ ictl.in_sync = (iface->ldp_sync.state == LDP_SYNC_STA_ACH);
+ ictl.wait_time = if_get_wait_for_sync_interval();
+ ictl.timer_running = iface->ldp_sync.wait_for_sync_timer ? true : false;
+
+ ictl.wait_time_remaining =
+ thread_timer_remain_second(iface->ldp_sync.wait_for_sync_timer);
+
+ memset(&ictl.peer_ldp_id, 0, sizeof(ictl.peer_ldp_id));
+
+ ldp_sync_get_peer_ldp_id(iface, &ictl.peer_ldp_id);
+
+ return (&ictl);
+}
+
+/* multicast membership sockopts */
+in_addr_t
+if_get_ipv4_addr(struct iface *iface)
+{
+ struct if_addr *if_addr;
+
+ LIST_FOREACH(if_addr, &iface->addr_list, entry)
+ if (if_addr->af == AF_INET)
+ return (if_addr->addr.v4.s_addr);
+
+ return (INADDR_ANY);
+}
+
+static int
+if_join_ipv4_group(struct iface *iface, struct in_addr *addr)
+{
+ struct in_addr if_addr;
+
+ log_debug("%s: interface %s addr %pI4", __func__, iface->name,
+ addr);
+
+ if_addr.s_addr = if_get_ipv4_addr(iface);
+
+ if (setsockopt_ipv4_multicast(global.ipv4.ldp_disc_socket,
+ IP_ADD_MEMBERSHIP, if_addr, addr->s_addr, iface->ifindex) < 0) {
+ log_warn("%s: error IP_ADD_MEMBERSHIP, interface %s address %pI4",
+ __func__, iface->name, addr);
+ return (-1);
+ }
+ return (0);
+}
+
+static int
+if_leave_ipv4_group(struct iface *iface, struct in_addr *addr)
+{
+ struct in_addr if_addr;
+
+ log_debug("%s: interface %s addr %pI4", __func__, iface->name,
+ addr);
+
+ if_addr.s_addr = if_get_ipv4_addr(iface);
+
+ if (setsockopt_ipv4_multicast(global.ipv4.ldp_disc_socket,
+ IP_DROP_MEMBERSHIP, if_addr, addr->s_addr, iface->ifindex) < 0) {
+ log_warn("%s: error IP_DROP_MEMBERSHIP, interface %s address %pI4", __func__, iface->name, addr);
+ return (-1);
+ }
+
+ return (0);
+}
+
+static int
+if_join_ipv6_group(struct iface *iface, struct in6_addr *addr)
+{
+ struct ipv6_mreq mreq;
+
+ log_debug("%s: interface %s addr %s", __func__, iface->name,
+ log_in6addr(addr));
+
+ mreq.ipv6mr_multiaddr = *addr;
+ mreq.ipv6mr_interface = iface->ifindex;
+
+ if (setsockopt(global.ipv6.ldp_disc_socket, IPPROTO_IPV6,
+ IPV6_JOIN_GROUP, &mreq, sizeof(mreq)) < 0) {
+ log_warn("%s: error IPV6_JOIN_GROUP, interface %s address %s",
+ __func__, iface->name, log_in6addr(addr));
+ return (-1);
+ }
+
+ return (0);
+}
+
+static int
+if_leave_ipv6_group(struct iface *iface, struct in6_addr *addr)
+{
+ struct ipv6_mreq mreq;
+
+ log_debug("%s: interface %s addr %s", __func__, iface->name,
+ log_in6addr(addr));
+
+ mreq.ipv6mr_multiaddr = *addr;
+ mreq.ipv6mr_interface = iface->ifindex;
+
+ if (setsockopt(global.ipv6.ldp_disc_socket, IPPROTO_IPV6,
+ IPV6_LEAVE_GROUP, (void *)&mreq, sizeof(mreq)) < 0) {
+ log_warn("%s: error IPV6_LEAVE_GROUP, interface %s address %s",
+ __func__, iface->name, log_in6addr(addr));
+ return (-1);
+ }
+
+ return (0);
+}
+
+const struct {
+ int state;
+ enum ldp_sync_event event;
+ enum ldp_sync_action action;
+ int new_state;
+} ldp_sync_fsm_tbl[] = {
+ /* current state event that happened action to take resulting state */
+/* LDP IGP Sync not achieved */
+ {LDP_SYNC_STA_NOT_ACH, LDP_SYNC_EVT_LDP_SYNC_START, LDP_SYNC_ACT_LDP_START_SYNC, 0},
+ {LDP_SYNC_STA_NOT_ACH, LDP_SYNC_EVT_LDP_SYNC_COMPLETE, LDP_SYNC_ACT_LDP_COMPLETE_SYNC, LDP_SYNC_STA_ACH},
+ {LDP_SYNC_STA_NOT_ACH, LDP_SYNC_EVT_CONFIG_LDP_OFF, LDP_SYNC_ACT_CONFIG_LDP_OFF, 0},
+ {LDP_SYNC_STA_NOT_ACH, LDP_SYNC_EVT_IFACE_SHUTDOWN, LDP_SYNC_ACT_IFACE_SHUTDOWN, 0},
+ {LDP_SYNC_STA_NOT_ACH, LDP_SYNC_EVT_SESSION_CLOSE, LDP_SYNC_ACT_NOTHING, 0},
+ {LDP_SYNC_STA_NOT_ACH, LDP_SYNC_EVT_ADJ_DEL, LDP_SYNC_ACT_NOTHING, 0},
+ {LDP_SYNC_STA_NOT_ACH, LDP_SYNC_EVT_ADJ_NEW, LDP_SYNC_ACT_NOTHING, 0},
+/* LDP IGP Sync achieved */
+ {LDP_SYNC_STA_ACH, LDP_SYNC_EVT_CONFIG_LDP_OFF, LDP_SYNC_ACT_CONFIG_LDP_OFF, LDP_SYNC_STA_NOT_ACH},
+ {LDP_SYNC_STA_ACH, LDP_SYNC_EVT_LDP_SYNC_COMPLETE, LDP_SYNC_ACT_NOTHING, 0},
+ {LDP_SYNC_STA_ACH, LDP_SYNC_EVT_LDP_SYNC_START, LDP_SYNC_ACT_NOTHING, 0},
+ {LDP_SYNC_STA_ACH, LDP_SYNC_EVT_IFACE_SHUTDOWN, LDP_SYNC_ACT_IFACE_SHUTDOWN, LDP_SYNC_STA_NOT_ACH},
+ {LDP_SYNC_STA_ACH, LDP_SYNC_EVT_SESSION_CLOSE, LDP_SYNC_ACT_IFACE_START_SYNC, LDP_SYNC_STA_NOT_ACH},
+ {LDP_SYNC_STA_ACH, LDP_SYNC_EVT_ADJ_DEL, LDP_SYNC_ACT_IFACE_START_SYNC, LDP_SYNC_STA_NOT_ACH},
+ {LDP_SYNC_STA_ACH, LDP_SYNC_EVT_ADJ_NEW, LDP_SYNC_ACT_NOTHING, 0},
+ {-1, LDP_SYNC_EVT_NOTHING, LDP_SYNC_ACT_NOTHING, 0},
+};
+
+const char * const ldp_sync_event_names[] = {
+ "NOTHING",
+ "LDP SYNC START",
+ "LDP SYNC COMPLETE",
+ "CONFIG LDP OFF",
+ "IFACE SYNC START (ADJ DEL)",
+ "IFACE SYNC START (ADJ NEW)",
+ "IFACE SYNC START (SESSION CLOSE)",
+ "IFACE SYNC START (CONFIG LDP ON)",
+ "IFACE SHUTDOWN",
+ "N/A"
+};
+
+const char * const ldp_sync_action_names[] = {
+ "NOTHING",
+ "IFACE SYNC START",
+ "LDP START SYNC",
+ "LDP COMPLETE SYNC",
+ "CONFIG LDP OFF",
+ "IFACE SHUTDOWN",
+ "N/A"
+};
+
+const char *
+ldp_sync_state_name(int state)
+{
+ switch (state) {
+ case LDP_SYNC_STA_NOT_ACH:
+ return ("NOT ACHIEVED");
+ case LDP_SYNC_STA_ACH:
+ return ("ACHIEVED");
+ default:
+ return ("UNKNOWN");
+ }
+}
+
+static int
+send_ldp_sync_state_update(char *name, int ifindex, int sync_start)
+{
+ debug_evt_ldp_sync("%s: interface %s (%d), sync_start=%d",
+ __func__, name, ifindex, sync_start);
+
+ struct ldp_igp_sync_if_state state;
+
+ state.ifindex = ifindex;
+ state.sync_start = sync_start;
+
+ return ldpe_imsg_compose_parent(IMSG_LDP_SYNC_IF_STATE_UPDATE,
+ getpid(), &state, sizeof(state));
+}
+
+static int
+ldp_sync_act_iface_start_sync(struct iface *iface)
+{
+ send_ldp_sync_state_update(iface->name, iface->ifindex, true);
+
+ return (0);
+}
+
+static void iface_wait_for_ldp_sync_timer(struct thread *thread)
+{
+ struct iface *iface = THREAD_ARG(thread);
+
+ ldp_sync_fsm(iface, LDP_SYNC_EVT_LDP_SYNC_COMPLETE);
+}
+
+static void start_wait_for_ldp_sync_timer(struct iface *iface)
+{
+ if (iface->ldp_sync.wait_for_sync_timer)
+ return;
+
+ THREAD_OFF(iface->ldp_sync.wait_for_sync_timer);
+ thread_add_timer(master, iface_wait_for_ldp_sync_timer, iface,
+ if_get_wait_for_sync_interval(),
+ &iface->ldp_sync.wait_for_sync_timer);
+}
+
+static void stop_wait_for_ldp_sync_timer(struct iface *iface)
+{
+ THREAD_OFF(iface->ldp_sync.wait_for_sync_timer);
+}
+
+static int
+ldp_sync_act_ldp_start_sync(struct iface *iface)
+{
+ start_wait_for_ldp_sync_timer(iface);
+
+ return 0;
+}
+
+static int
+ldp_sync_act_ldp_complete_sync(struct iface *iface)
+{
+ send_ldp_sync_state_update(iface->name, iface->ifindex, false);
+
+ return 0;
+}
+
+static int
+iface_to_oper_nbr_count(struct iface *iface, unsigned int type)
+{
+ int oper_nbr_count = 0;
+ struct adj *adj;
+
+ RB_FOREACH(adj, ia_adj_head, &iface->ipv4.adj_tree) {
+ if (type == adj->source.type && adj->nbr &&
+ adj->nbr->state == NBR_STA_OPER)
+ oper_nbr_count++;
+ }
+
+ RB_FOREACH(adj, ia_adj_head, &iface->ipv6.adj_tree) {
+ if (type == adj->source.type && adj->nbr &&
+ adj->nbr->state == NBR_STA_OPER)
+ oper_nbr_count++;
+ }
+
+ return oper_nbr_count;
+}
+
+int
+ldp_sync_fsm_adj_event(struct adj *adj, enum ldp_sync_event event)
+{
+ if (adj->source.type != HELLO_LINK)
+ return -1;
+
+ struct iface *iface = adj->source.link.ia->iface;
+
+ if (!iface->operative)
+ return 0;
+
+ if (event == LDP_SYNC_EVT_ADJ_NEW) {
+ struct nbr *nbr = adj->nbr;
+ if (nbr && nbr->state == NBR_STA_OPER) {
+ event = LDP_SYNC_EVT_LDP_SYNC_START;
+ }
+ } else if (event == LDP_SYNC_EVT_ADJ_DEL) {
+ /* Ignore if an operational neighbor exists.
+ */
+ int oper_nbr_count = iface_to_oper_nbr_count(iface, HELLO_LINK);
+ if (oper_nbr_count > 0)
+ return 0;
+ }
+
+ debug_evt_ldp_sync("%s: event %s, "
+ "adj iface %s (%d) lsr-id %pI4 "
+ "source address %s transport address %s",
+ __func__, ldp_sync_event_names[event],
+ adj->source.link.ia->iface->name,
+ adj->source.link.ia->iface->ifindex,
+ &adj->lsr_id,
+ log_addr(adj_get_af(adj), &adj->source.link.src_addr),
+ log_addr(adj_get_af(adj), &adj->trans_addr));
+
+ return ldp_sync_fsm(iface, event);
+}
+
+int
+ldp_sync_fsm_nbr_event(struct nbr *nbr, enum ldp_sync_event event)
+{
+ struct adj *adj;
+ struct iface *iface = NULL;
+ RB_FOREACH(adj, nbr_adj_head, &nbr->adj_tree) {
+ if (HELLO_LINK != adj->source.type)
+ continue;
+
+ iface = adj->source.link.ia->iface;
+
+ if (!iface || !iface->operative)
+ continue;
+
+ int oper_nbr_count = iface_to_oper_nbr_count(iface, HELLO_LINK);
+
+ if (event == LDP_SYNC_EVT_SESSION_CLOSE && oper_nbr_count > 0)
+ /* Ignore if an operational neighbor exists.
+ */
+ continue;
+
+ debug_evt_ldp_sync("%s: event %s, iface %s, lsr-id %pI4",
+ __func__, ldp_sync_event_names[event],
+ iface->name, &nbr->id);
+
+ ldp_sync_fsm(iface, event);
+ }
+
+ return 0;
+}
+
+int
+ldp_sync_fsm_state_req(struct ldp_igp_sync_if_state_req *state_req)
+{
+ debug_evt_ldp_sync("%s: interface %s (%d) proto %s",
+ __func__, state_req->name, state_req->ifindex,
+ zebra_route_string(state_req->proto));
+
+ struct iface *iface = if_lookup_name(leconf, state_req->name);
+
+ if (!iface) {
+ debug_evt_ldp_sync("%s: Warning: Ignoring LDP IGP SYNC "
+ "interface state request for interface %s (%d). "
+ "Interface does not exist in LDP.",
+ __func__, state_req->name, state_req->ifindex);
+
+ return 0;
+ }
+
+ return send_ldp_sync_state_update(state_req->name,
+ state_req->ifindex,
+ (iface->ldp_sync.state != LDP_SYNC_STA_ACH));
+}
+
+static int
+ldp_sync_fsm_init(struct iface *iface, int state)
+{
+ int old_state = iface->ldp_sync.state;
+
+ iface->ldp_sync.state = state;
+ stop_wait_for_ldp_sync_timer(iface);
+
+ send_ldp_sync_state_update(iface->name, iface->ifindex,
+ (iface->ldp_sync.state != LDP_SYNC_STA_ACH));
+
+ if (old_state != iface->ldp_sync.state) {
+ debug_evt_ldp_sync("%s: resulted in "
+ "changing state for interface %s (%d) from %s to %s",
+ __func__,
+ iface->name, iface->ifindex,
+ ldp_sync_state_name(old_state),
+ ldp_sync_state_name(iface->ldp_sync.state));
+ }
+
+ return 0;
+}
+
+int
+ldp_sync_fsm(struct iface *iface, enum ldp_sync_event event)
+{
+ int old_state = iface->ldp_sync.state;
+ int new_state = 0;
+ int i;
+
+ for (i = 0; ldp_sync_fsm_tbl[i].state != -1; i++)
+ if ((ldp_sync_fsm_tbl[i].state & old_state) &&
+ (ldp_sync_fsm_tbl[i].event == event)) {
+ new_state = ldp_sync_fsm_tbl[i].new_state;
+ break;
+ }
+
+ if (ldp_sync_fsm_tbl[i].state == -1) {
+ /* event outside of the defined fsm, ignore it. */
+ log_warnx("%s: interface %s, event %s not expected in "
+ "state %s ", __func__, iface->name,
+ ldp_sync_event_names[event],
+ ldp_sync_state_name(old_state));
+ return (0);
+ }
+
+ if (new_state != 0)
+ iface->ldp_sync.state = new_state;
+
+ switch (ldp_sync_fsm_tbl[i].action) {
+ case LDP_SYNC_ACT_IFACE_START_SYNC:
+ ldp_sync_act_iface_start_sync(iface);
+ break;
+ case LDP_SYNC_ACT_LDP_START_SYNC:
+ ldp_sync_act_ldp_start_sync(iface);
+ break;
+ case LDP_SYNC_ACT_LDP_COMPLETE_SYNC:
+ ldp_sync_act_ldp_complete_sync(iface);
+ break;
+ case LDP_SYNC_ACT_CONFIG_LDP_OFF:
+ ldp_sync_fsm_init(iface, LDP_SYNC_STA_NOT_ACH);
+ break;
+ case LDP_SYNC_ACT_IFACE_SHUTDOWN:
+ ldp_sync_fsm_init(iface, iface->ldp_sync.state);
+ break;
+ case LDP_SYNC_ACT_NOTHING:
+ /* do nothing */
+ break;
+ }
+
+ if (old_state != iface->ldp_sync.state) {
+
+ debug_evt_ldp_sync("%s: event %s resulted in action %s "
+ "for interface %s, changing state from %s to %s",
+ __func__, ldp_sync_event_names[event],
+ ldp_sync_action_names[ldp_sync_fsm_tbl[i].action],
+ iface->name, ldp_sync_state_name(old_state),
+ ldp_sync_state_name(iface->ldp_sync.state));
+
+ } else {
+ debug_evt_ldp_sync("%s: event %s resulted in action %s "
+ "for interface %s, remaining in state %s",
+ __func__, ldp_sync_event_names[event],
+ ldp_sync_action_names[ldp_sync_fsm_tbl[i].action],
+ iface->name,
+ ldp_sync_state_name(iface->ldp_sync.state));
+ }
+
+ return (0);
+}
+
+void
+ldp_sync_fsm_reset_all(void)
+{
+ struct iface *iface;
+
+ RB_FOREACH(iface, iface_head, &leconf->iface_tree)
+ ldp_sync_fsm(iface, LDP_SYNC_EVT_CONFIG_LDP_OFF);
+}