lib,ldp,zebra: add synchronous zapi session flag

Zebra is currently sending messages on interface add/delete/update,
VRF add/delete, and interface address change - regardless of whether
its clients had requested them.  This is problematic for lde and isis,
which only listens to label chunk messages, and only when it is
waiting for one (synchronous client). The effect is the that messages
accumulate on the lde synchronous message queue.

With this change:
  - Zebra does not send unsolicited messages to synchronous clients.
  - Synchronous clients send a ZEBRA_HELLO to zebra.
    The ZEBRA_HELLO contains a new boolean field: synchronous.
  - LDP and PIM have been updated to send a ZEBRA_HELLO for their
    synchronous clients.

Signed-off-by: Karen Schoener <karen@voltanet.io>
Signed-off-by: Mark Stapp <mjs@voltanet.io>

diff --git a/ldpd/lde.c b/ldpd/lde.c
index 5f94031320c351d34aeb10eb4c70e33229c118f5..f44a702817518a035851ce101ec6ac9835b536c0 100644 (file)
--- a/ldpd/lde.c
+++ b/ldpd/lde.c
@@ -1628,8 +1628,11 @@ lde_address_list_free(struct lde_nbr *ln)
 
 static void zclient_sync_init(unsigned short instance)
 {
+       struct zclient_options options = zclient_options_default;
+       options.synchronous = true;
+
        /* Initialize special zclient for synchronous message exchanges. */
-       zclient_sync = zclient_new(master, &zclient_options_default);
+       zclient_sync = zclient_new(master, &options);
        zclient_sync->sock = -1;
        zclient_sync->redist_default = ZEBRA_ROUTE_LDP;
        zclient_sync->instance = instance;
@@ -1642,6 +1645,12 @@ static void zclient_sync_init(unsigned short instance)
        /* make socket non-blocking */
        sock_set_nonblock(zclient_sync->sock);
 
+       /* Send hello to notify zebra this is a synchronous client */
+       while (zclient_send_hello(zclient_sync) < 0) {
+               log_warnx("Error sending hello for synchronous zclient!");
+               sleep(1);
+       }
+
        /* Connect to label manager */
        while (lm_label_manager_connect(zclient_sync, 0) != 0) {
                log_warnx("Error connecting to label manager!");

diff --git a/lib/zclient.c b/lib/zclient.c
index 179492ee9ec9b91c95df994d2b1a51377a2138e6..865da130debaf53ea3c0b4af0bf8d809ae3f9eb0 100644 (file)
--- a/lib/zclient.c
+++ b/lib/zclient.c
@@ -52,7 +52,8 @@ static void zclient_event(enum event, struct zclient *);
 static void zebra_interface_if_set_value(struct stream *s,
                                         struct interface *ifp);
 
-struct zclient_options zclient_options_default = {.receive_notify = false};
+struct zclient_options zclient_options_default = {.receive_notify = false,
+                                                 .synchronous = false};
 
 struct sockaddr_storage zclient_addr;
 socklen_t zclient_addr_len;
@@ -76,6 +77,7 @@ struct zclient *zclient_new(struct thread_master *master,
        zclient->master = master;
 
        zclient->receive_notify = opt->receive_notify;
+       zclient->synchronous = opt->synchronous;
 
        return zclient;
 }
@@ -365,11 +367,11 @@ static int zebra_message_send(struct zclient *zclient, int command,
        return zclient_send_message(zclient);
 }
 
-static int zebra_hello_send(struct zclient *zclient)
+int zclient_send_hello(struct zclient *zclient)
 {
        struct stream *s;
 
-       if (zclient->redist_default) {
+       if (zclient->redist_default || zclient->synchronous) {
                s = zclient->obuf;
                stream_reset(s);
 
@@ -381,6 +383,10 @@ static int zebra_hello_send(struct zclient *zclient)
                        stream_putc(s, 1);
                else
                        stream_putc(s, 0);
+               if (zclient->synchronous)
+                       stream_putc(s, 1);
+               else
+                       stream_putc(s, 0);
 
                stream_putw_at(s, 0, stream_get_endp(s));
                return zclient_send_message(zclient);
@@ -620,7 +626,7 @@ int zclient_start(struct zclient *zclient)
        /* Create read thread. */
        zclient_event(ZCLIENT_READ, zclient);
 
-       zebra_hello_send(zclient);
+       zclient_send_hello(zclient);
 
        zebra_message_send(zclient, ZEBRA_INTERFACE_ADD, VRF_DEFAULT);
 

diff --git a/lib/zclient.h b/lib/zclient.h
index 38b6030fa32e5ec191a952ab4062e30f44a419a8..9581401520f0de7396a58daac6179bd1e0e8ae69 100644 (file)
--- a/lib/zclient.h
+++ b/lib/zclient.h
@@ -233,6 +233,9 @@ struct zclient {
        /* Do we care about failure events for route install? */
        bool receive_notify;
 
+       /* Is this a synchronous client? */
+       bool synchronous;
+
        /* Socket to zebra daemon. */
        int sock;
 
@@ -554,6 +557,7 @@ enum zebra_neigh_state { ZEBRA_NEIGH_INACTIVE = 0, ZEBRA_NEIGH_ACTIVE = 1 };
 
 struct zclient_options {
        bool receive_notify;
+       bool synchronous;
 };
 
 extern struct zclient_options zclient_options_default;
@@ -775,4 +779,9 @@ extern void zclient_send_mlag_deregister(struct zclient *client);
 extern void zclient_send_mlag_data(struct zclient *client,
                                   struct stream *client_s);
 
+/* Send the hello message.
+ * Returns 0 for success or -1 on an I/O error.
+ */
+extern int zclient_send_hello(struct zclient *client);
+
 #endif /* _ZEBRA_ZCLIENT_H */

diff --git a/pimd/pim_zlookup.c b/pimd/pim_zlookup.c
index 0454c0d69ebe2a64f2d3bbe245a5adade75434ec..f361ec45d87b7bc90e9fbf791424edf26a1427d9 100644 (file)
--- a/pimd/pim_zlookup.c
+++ b/pimd/pim_zlookup.c
@@ -61,6 +61,14 @@ static int zclient_lookup_connect(struct thread *t)
                zlookup->fail = 0; /* reset counter on connection */
        }
 
+       if (zclient_send_hello(zlookup) < 0) {
+               if (close(zlookup->sock)) {
+                       zlog_warn("%s: closing fd=%d: errno=%d %s", __func__,
+                                 zlookup->sock, errno, safe_strerror(errno));
+               }
+               zlookup->sock = -1;
+       }
+
        if (zlookup->sock < 0) {
                /* Since last connect failed, retry within 10 secs */
                zclient_lookup_sched(zlookup, 10);
@@ -125,7 +133,10 @@ void zclient_lookup_free(void)
 
 void zclient_lookup_new(void)
 {
-       zlookup = zclient_new(router->master, &zclient_options_default);
+       struct zclient_options options = zclient_options_default;
+       options.synchronous = true;
+
+       zlookup = zclient_new(router->master, &options);
        if (!zlookup) {
                flog_err(EC_LIB_ZAPI_SOCKET, "%s: zclient_new() failure",
                         __PRETTY_FUNCTION__);
@@ -162,6 +173,7 @@ static int zclient_read_nexthop(struct pim_instance *pim,
 
        if (PIM_DEBUG_PIM_NHT_DETAIL) {
                char addr_str[INET_ADDRSTRLEN];
+
                pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
                zlog_debug("%s: addr=%s(%s)", __PRETTY_FUNCTION__, addr_str,
                           pim->vrf->name);

diff --git a/zebra/redistribute.c b/zebra/redistribute.c
index 6aa52bcb61d8f4d8e86804975c790401a2bc3076..77f5228fc15e28d690dbe0e08c1dc8f93332f4f2 100644 (file)
--- a/zebra/redistribute.c
+++ b/zebra/redistribute.c
@@ -288,6 +288,10 @@ void redistribute_delete(const struct prefix *p, const struct prefix *src_p,
        }
 
        for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+               /* Do not send unsolicited messages to synchronous clients. */
+               if (client->synchronous)
+                       continue;
+
                if (new_re) {
                        /* Skip this client if it will receive an update for the
                         * 'new' re
@@ -470,6 +474,12 @@ void zebra_interface_up_update(struct interface *ifp)
        if (ifp->ptm_status || !ifp->ptm_enable) {
                for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode,
                                       client)) {
+                       /* Do not send unsolicited messages to synchronous
+                        * clients.
+                        */
+                       if (client->synchronous)
+                               continue;
+
                        zsend_interface_update(ZEBRA_INTERFACE_UP,
                                               client, ifp);
                        zsend_interface_link_params(client, ifp);
@@ -488,6 +498,10 @@ void zebra_interface_down_update(struct interface *ifp)
                           ifp->name, ifp->vrf_id);
 
        for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+               /* Do not send unsolicited messages to synchronous clients. */
+               if (client->synchronous)
+                       continue;
+
                zsend_interface_update(ZEBRA_INTERFACE_DOWN, client, ifp);
        }
 }
@@ -503,6 +517,10 @@ void zebra_interface_add_update(struct interface *ifp)
                           ifp->vrf_id);
 
        for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+               /* Do not send unsolicited messages to synchronous clients. */
+               if (client->synchronous)
+                       continue;
+
                client->ifadd_cnt++;
                zsend_interface_add(client, ifp);
                zsend_interface_link_params(client, ifp);
@@ -519,6 +537,10 @@ void zebra_interface_delete_update(struct interface *ifp)
                           ifp->name, ifp->vrf_id);
 
        for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+               /* Do not send unsolicited messages to synchronous clients. */
+               if (client->synchronous)
+                       continue;
+
                client->ifdel_cnt++;
                zsend_interface_delete(client, ifp);
        }
@@ -550,12 +572,17 @@ void zebra_interface_address_add_update(struct interface *ifp,
 
        router_id_add_address(ifc);
 
-       for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client))
+       for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+               /* Do not send unsolicited messages to synchronous clients. */
+               if (client->synchronous)
+                       continue;
+
                if (CHECK_FLAG(ifc->conf, ZEBRA_IFC_REAL)) {
                        client->connected_rt_add_cnt++;
                        zsend_interface_address(ZEBRA_INTERFACE_ADDRESS_ADD,
                                                client, ifp, ifc);
                }
+       }
 }
 
 /* Interface address deletion. */
@@ -579,12 +606,17 @@ void zebra_interface_address_delete_update(struct interface *ifp,
 
        router_id_del_address(ifc);
 
-       for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client))
+       for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+               /* Do not send unsolicited messages to synchronous clients. */
+               if (client->synchronous)
+                       continue;
+
                if (CHECK_FLAG(ifc->conf, ZEBRA_IFC_REAL)) {
                        client->connected_rt_del_cnt++;
                        zsend_interface_address(ZEBRA_INTERFACE_ADDRESS_DELETE,
                                                client, ifp, ifc);
                }
+       }
 }
 
 /* Interface VRF change. May need to delete from clients not interested in
@@ -601,6 +633,10 @@ void zebra_interface_vrf_update_del(struct interface *ifp, vrf_id_t new_vrf_id)
                        ifp->name, ifp->vrf_id, new_vrf_id);
 
        for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+               /* Do not send unsolicited messages to synchronous clients. */
+               if (client->synchronous)
+                       continue;
+
                /* Need to delete if the client is not interested in the new
                 * VRF. */
                zsend_interface_update(ZEBRA_INTERFACE_DOWN, client, ifp);
@@ -624,6 +660,10 @@ void zebra_interface_vrf_update_add(struct interface *ifp, vrf_id_t old_vrf_id)
                        ifp->name, old_vrf_id, ifp->vrf_id);
 
        for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+               /* Do not send unsolicited messages to synchronous clients. */
+               if (client->synchronous)
+                       continue;
+
                /* Need to add if the client is interested in the new VRF. */
                client->ifadd_cnt++;
                zsend_interface_add(client, ifp);
@@ -911,6 +951,11 @@ void zebra_interface_parameters_update(struct interface *ifp)
                zlog_debug("MESSAGE: ZEBRA_INTERFACE_LINK_PARAMS %s(%u)",
                           ifp->name, ifp->vrf_id);
 
-       for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client))
+       for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+               /* Do not send unsolicited messages to synchronous clients. */
+               if (client->synchronous)
+                       continue;
+
                zsend_interface_link_params(client, ifp);
+       }
 }

diff --git a/zebra/zapi_msg.c b/zebra/zapi_msg.c
index d4b1210b04880b1712fdd5440fca69b66322826d..b518a1551248406c0af40959550f044b7499b0a0 100644 (file)
--- a/zebra/zapi_msg.c
+++ b/zebra/zapi_msg.c
@@ -382,9 +382,14 @@ static void zebra_interface_nbr_address_add_update(struct interface *ifp,
                        p->prefixlen, ifc->ifp->name);
        }
 
-       for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client))
+       for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+               /* Do not send unsolicited messages to synchronous clients. */
+               if (client->synchronous)
+                       continue;
+
                zsend_interface_nbr_address(ZEBRA_INTERFACE_NBR_ADDRESS_ADD,
                                            client, ifp, ifc);
+       }
 }
 
 /* Interface address deletion. */
@@ -406,9 +411,14 @@ static void zebra_interface_nbr_address_delete_update(struct interface *ifp,
                        p->prefixlen, ifc->ifp->name);
        }
 
-       for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client))
+       for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+               /* Do not send unsolicited messages to synchronous clients. */
+               if (client->synchronous)
+                       continue;
+
                zsend_interface_nbr_address(ZEBRA_INTERFACE_NBR_ADDRESS_DELETE,
                                            client, ifp, ifc);
+       }
 }
 
 /* Send addresses on interface to client */
@@ -1735,6 +1745,10 @@ void zsend_capabilities_all_clients(void)
 
        zvrf = vrf_info_lookup(VRF_DEFAULT);
        for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+               /* Do not send unsolicited messages to synchronous clients. */
+               if (client->synchronous)
+                       continue;
+
                zsend_capabilities(client, zvrf);
        }
 }
@@ -1746,13 +1760,18 @@ static void zread_hello(ZAPI_HANDLER_ARGS)
        uint8_t proto;
        unsigned short instance;
        uint8_t notify;
+       uint8_t synchronous;
 
        STREAM_GETC(msg, proto);
        STREAM_GETW(msg, instance);
        STREAM_GETC(msg, notify);
+       STREAM_GETC(msg, synchronous);
        if (notify)
                client->notify_owner = true;
 
+       if (synchronous)
+               client->synchronous = true;
+
        /* accept only dynamic routing protocols */
        if ((proto < ZEBRA_ROUTE_MAX) && (proto > ZEBRA_ROUTE_CONNECT)) {
                zlog_notice(
@@ -1766,8 +1785,10 @@ static void zread_hello(ZAPI_HANDLER_ARGS)
                client->instance = instance;
        }
 
-       zsend_capabilities(client, zvrf);
-       zebra_vrf_update_all(client);
+       if (!client->synchronous) {
+               zsend_capabilities(client, zvrf);
+               zebra_vrf_update_all(client);
+       }
 stream_failure:
        return;
 }

diff --git a/zebra/zebra_vrf.c b/zebra/zebra_vrf.c
index c392303760503c4b33812a66aeb408b6cceef46a..dfa7d5ae923c9c254f21a90d2bb0b4783b081821 100644 (file)
--- a/zebra/zebra_vrf.c
+++ b/zebra/zebra_vrf.c
@@ -60,8 +60,13 @@ static void zebra_vrf_add_update(struct zebra_vrf *zvrf)
        if (IS_ZEBRA_DEBUG_EVENT)
                zlog_debug("MESSAGE: ZEBRA_VRF_ADD %s", zvrf_name(zvrf));
 
-       for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client))
+       for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+               /* Do not send unsolicited messages to synchronous clients. */
+               if (client->synchronous)
+                       continue;
+
                zsend_vrf_add(client, zvrf);
+       }
 }
 
 static void zebra_vrf_delete_update(struct zebra_vrf *zvrf)
@@ -72,8 +77,13 @@ static void zebra_vrf_delete_update(struct zebra_vrf *zvrf)
        if (IS_ZEBRA_DEBUG_EVENT)
                zlog_debug("MESSAGE: ZEBRA_VRF_DELETE %s", zvrf_name(zvrf));
 
-       for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client))
+       for (ALL_LIST_ELEMENTS(zrouter.client_list, node, nnode, client)) {
+               /* Do not send unsolicited messages to synchronous clients. */
+               if (client->synchronous)
+                       continue;
+
                zsend_vrf_delete(client, zvrf);
+       }
 }
 
 void zebra_vrf_update_all(struct zserv *client)

diff --git a/zebra/zserv.h b/zebra/zserv.h
index d8d82a52ec47bab8765843ba94351734211fed23..b20daea1f086964727b155eebfbfaaafce1c7f62 100644 (file)
--- a/zebra/zserv.h
+++ b/zebra/zserv.h
@@ -95,6 +95,9 @@ struct zserv {
 
        bool notify_owner;
 
+       /* Indicates if client is synchronous. */
+       bool synchronous;
+
        /* client's protocol */
        uint8_t proto;
        uint16_t instance;