pimd: Convert over to use LIB_ERR_XXX for zlog_err

Convert, where appropriate, the zlog_err functions to zlog_ferr
for the LIB_ERR_XXX enums

Signed-off-by: Donald Sharp <sharpd@cumulusnetworks.com>

diff --git a/pimd/pim_ifchannel.c b/pimd/pim_ifchannel.c
index eb3307589ec0b826e8470974157a3385c44dd77a..92a78c4bb4b43a3509157e65bc2f8b48a9b98399 100644 (file)
--- a/pimd/pim_ifchannel.c
+++ b/pimd/pim_ifchannel.c
@@ -549,26 +549,6 @@ struct pim_ifchannel *pim_ifchannel_add(struct interface *ifp,
        up = pim_upstream_add(pim_ifp->pim, sg, NULL, up_flags,
                              __PRETTY_FUNCTION__, ch);
 
-       if (!up) {
-               zlog_err(
-                       "%s: could not attach upstream (S,G)=%s on interface %s",
-                       __PRETTY_FUNCTION__, pim_str_sg_dump(sg), ifp->name);
-
-               if (ch->parent)
-                       listnode_delete(ch->parent->sources, ch);
-
-               pim_ifchannel_remove_children(ch);
-               if (ch->sources)
-                       list_delete_and_null(&ch->sources);
-
-               THREAD_OFF(ch->t_ifjoin_expiry_timer);
-               THREAD_OFF(ch->t_ifjoin_prune_pending_timer);
-               THREAD_OFF(ch->t_ifassert_timer);
-
-               RB_REMOVE(pim_ifchannel_rb, &pim_ifp->ifchannel_rb, ch);
-               XFREE(MTYPE_PIM_IFCHANNEL, ch);
-               return NULL;
-       }
        ch->upstream = up;
 
        listnode_add_sort(up->ifchannels, ch);

diff --git a/pimd/pim_igmp.c b/pimd/pim_igmp.c
index b46f1b5e9dde1870297c7fcb633d64bcc2a3fa83..96ec35be7b9bc7ab60098784aa01114e0378c847 100644 (file)
--- a/pimd/pim_igmp.c
+++ b/pimd/pim_igmp.c
@@ -24,6 +24,7 @@
 #include "if.h"
 #include "hash.h"
 #include "jhash.h"
+#include "lib_errors.h"
 
 #include "pimd.h"
 #include "pim_igmp.h"
@@ -96,9 +97,9 @@ static int igmp_sock_open(struct in_addr ifaddr, struct interface *ifp,
        }
 
        if (!join) {
-               zlog_err(
-                       "IGMP socket fd=%d could not join any group on interface address %s",
-                       fd, inet_ntoa(ifaddr));
+               zlog_ferr(LIB_ERR_SOCKET,
+                         "IGMP socket fd=%d could not join any group on interface address %s",
+                         fd, inet_ntoa(ifaddr));
                close(fd);
                fd = -1;
        }
@@ -697,7 +698,8 @@ static void sock_close(struct igmp_sock *igmp)
        THREAD_OFF(igmp->t_igmp_read);
 
        if (close(igmp->fd)) {
-               zlog_err(
+               zlog_ferr(
+                       LIB_ERR_SOCKET,
                        "Failure closing IGMP socket %s fd=%d on interface %s: errno=%d: %s",
                        inet_ntoa(igmp->ifaddr), igmp->fd,
                        igmp->interface->name, errno, safe_strerror(errno));
@@ -960,12 +962,6 @@ struct igmp_sock *pim_igmp_sock_add(struct list *igmp_sock_list,
        }
 
        igmp = igmp_sock_new(fd, ifaddr, ifp, mtrace_only);
-       if (!igmp) {
-               zlog_err("%s %s: igmp_sock_new() failure", __FILE__,
-                        __PRETTY_FUNCTION__);
-               close(fd);
-               return 0;
-       }
 
        igmp_read_on(igmp);
 

diff --git a/pimd/pim_igmpv3.c b/pimd/pim_igmpv3.c
index 132fe4d56424e3c45394e779ab464d6b1e1d88a8..38f26f7ae85e6f9ab102109d4499d343d488a4e0 100644 (file)
--- a/pimd/pim_igmpv3.c
+++ b/pimd/pim_igmpv3.c
@@ -21,6 +21,7 @@
 #include "log.h"
 #include "memory.h"
 #include "if.h"
+#include "lib_errors.h"
 
 #include "pimd.h"
 #include "pim_iface.h"
@@ -1583,7 +1584,8 @@ void igmp_v3_send_query(struct igmp_group *group, int fd, const char *ifname,
 
        msg_size = IGMP_V3_SOURCES_OFFSET + (num_sources << 2);
        if (msg_size > query_buf_size) {
-               zlog_err(
+               zlog_ferr(
+                       LIB_ERR_DEVELOPMENT,
                        "%s %s: unable to send: msg_size=%zd larger than query_buf_size=%d",
                        __FILE__, __PRETTY_FUNCTION__, msg_size,
                        query_buf_size);

diff --git a/pimd/pim_instance.c b/pimd/pim_instance.c
index e664bf3062b9e83ca3030a5c64c4eefb35d9dddc..8dc48cc004615b2e06cf81d9b979777a7b312c02 100644 (file)
--- a/pimd/pim_instance.c
+++ b/pimd/pim_instance.c
@@ -22,6 +22,7 @@
 
 #include "hash.h"
 #include "vrf.h"
+#include "lib_errors.h"
 
 #include "pimd.h"
 #include "pim_ssm.h"
@@ -94,10 +95,6 @@ static struct pim_instance *pim_instance_init(struct vrf *vrf)
                zlog_debug("%s: NHT rpf hash init ", __PRETTY_FUNCTION__);
 
        pim->ssm_info = pim_ssm_init();
-       if (!pim->ssm_info) {
-               pim_instance_terminate(pim);
-               return NULL;
-       }
 
        pim->static_routes = list_new();
        pim->static_routes->del = (void (*)(void *))pim_static_route_free;
@@ -132,14 +129,6 @@ static int pim_vrf_new(struct vrf *vrf)
        struct pim_instance *pim = pim_instance_init(vrf);
 
        zlog_debug("VRF Created: %s(%u)", vrf->name, vrf->vrf_id);
-       if (pim == NULL) {
-               zlog_err("%s %s: pim class init failure ", __FILE__,
-                        __PRETTY_FUNCTION__);
-               /*
-                * We will crash and burn otherwise
-                */
-               exit(1);
-       }
 
        vrf->info = (void *)pim;
 

diff --git a/pimd/pim_mroute.c b/pimd/pim_mroute.c
index dd306784055a04d0bbc0e9a0b50c7914f268f187..9b0599caf0e8f8d1587f9157343b851243c13f56 100644 (file)
--- a/pimd/pim_mroute.c
+++ b/pimd/pim_mroute.c
@@ -25,6 +25,7 @@
 #include "vty.h"
 #include "plist.h"
 #include "sockopt.h"
+#include "lib_errors.h"
 
 #include "pimd.h"
 #include "pim_rpf.h"
@@ -56,7 +57,8 @@ static int pim_mroute_set(struct pim_instance *pim, int enable)
         */
        if (pim->vrf_id != VRF_DEFAULT) {
                if (pimd_privs.change(ZPRIVS_RAISE))
-                       zlog_err(
+                       zlog_ferr(
+                               LIB_ERR_PRIVILEGES,
                                "pim_mroute_socket_enable: could not raise privs, %s",
                                safe_strerror(errno));
 
@@ -73,7 +75,8 @@ static int pim_mroute_set(struct pim_instance *pim, int enable)
                }
 
                if (pimd_privs.change(ZPRIVS_LOWER))
-                       zlog_err(
+                       zlog_ferr(
+                               LIB_ERR_PRIVILEGES,
                                "pim_mroute_socket_enable: could not lower privs, %s",
                                safe_strerror(errno));
        }
@@ -709,8 +712,9 @@ int pim_mroute_socket_enable(struct pim_instance *pim)
        int fd;
 
        if (pimd_privs.change(ZPRIVS_RAISE))
-               zlog_err("pim_mroute_socket_enable: could not raise privs, %s",
-                        safe_strerror(errno));
+               zlog_ferr(LIB_ERR_PRIVILEGES,
+                         "pim_mroute_socket_enable: could not raise privs, %s",
+                         safe_strerror(errno));
 
        fd = socket(AF_INET, SOCK_RAW, IPPROTO_IGMP);
 
@@ -732,8 +736,9 @@ int pim_mroute_socket_enable(struct pim_instance *pim)
 #endif
 
        if (pimd_privs.change(ZPRIVS_LOWER))
-               zlog_err("pim_mroute_socket_enable: could not lower privs, %s",
-                        safe_strerror(errno));
+               zlog_ferr(LIB_ERR_PRIVILEGES,
+                         "pim_mroute_socket_enable: could not lower privs, %s",
+                         safe_strerror(errno));
 
        pim->mroute_socket = fd;
        if (pim_mroute_set(pim, 1)) {

diff --git a/pimd/pim_msdp.c b/pimd/pim_msdp.c
index 4910cb8b38085e1724bec0863abf6b5261a8b176..c15b87f92ee9136842f51935fb49c749025deaa9 100644 (file)
--- a/pimd/pim_msdp.c
+++ b/pimd/pim_msdp.c
@@ -28,6 +28,7 @@
 #include <lib/thread.h>
 #include <lib/vty.h>
 #include <lib/plist.h>
+#include <lib/lib_errors.h>
 
 #include "pimd.h"
 #include "pim_cmd.h"
@@ -517,7 +518,8 @@ static void pim_msdp_sa_local_del_on_up_del(struct pim_instance *pim,
                         * the flow. Accounting for such cases requires lot of
                         * changes; perhaps
                         * address this in the next release? - XXX  */
-                       zlog_err(
+                       zlog_ferr(
+                                 LIB_ERR_DEVELOPMENT,
                                "MSDP sa %s SPT teardown is causing the local entry to be removed",
                                sa->sg_str);
                        return;

diff --git a/pimd/pim_msdp_packet.c b/pimd/pim_msdp_packet.c
index 978d979245bc4a163591a7541d188b83f9382b76..7aa9357b8535af1bb91407f5290018e12da083eb 100644 (file)
--- a/pimd/pim_msdp_packet.c
+++ b/pimd/pim_msdp_packet.c
@@ -23,6 +23,7 @@
 #include <lib/stream.h>
 #include <lib/thread.h>
 #include <lib/vty.h>
+#include <lib/lib_errors.h>
 
 #include "pimd.h"
 #include "pim_str.h"
@@ -145,7 +146,8 @@ static void pim_msdp_connect_check(struct pim_msdp_peer *mp)
 
        /* If getsockopt is fail, this is fatal error. */
        if (ret < 0) {
-               zlog_err("can't get sockopt for nonblocking connect");
+               zlog_ferr(LIB_ERR_SOCKET,
+                         "can't get sockopt for nonblocking connect");
                pim_msdp_peer_reset_tcp_conn(mp, "connect-failed");
                return;
        }

diff --git a/pimd/pim_msdp_socket.c b/pimd/pim_msdp_socket.c
index f245a043534af4557dca3210e35dfab4418e6906..5b1afb774b665da204cbdd3f568a93accc6d5f96 100644 (file)
--- a/pimd/pim_msdp_socket.c
+++ b/pimd/pim_msdp_socket.c
@@ -26,6 +26,7 @@
 #include <lib/vty.h>
 #include <lib/if.h>
 #include <lib/vrf.h>
+#include <lib/lib_errors.h>
 
 #include "pimd.h"
 #include "pim_sock.h"
@@ -41,16 +42,17 @@ static void pim_msdp_update_sock_send_buffer_size(int fd)
        socklen_t optlen = sizeof(optval);
 
        if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &optval, &optlen) < 0) {
-               zlog_err("getsockopt of SO_SNDBUF failed %s\n",
-                        safe_strerror(errno));
+               zlog_ferr(LIB_ERR_SOCKET, "getsockopt of SO_SNDBUF failed %s\n",
+                         safe_strerror(errno));
                return;
        }
 
        if (optval < size) {
                if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size))
                    < 0) {
-                       zlog_err("Couldn't increase send buffer: %s\n",
-                                safe_strerror(errno));
+                       zlog_ferr(LIB_ERR_SOCKET,
+                                 "Couldn't increase send buffer: %s\n",
+                                 safe_strerror(errno));
                }
        }
 }
@@ -70,7 +72,8 @@ static int pim_msdp_sock_accept(struct thread *thread)
        /* re-register accept thread */
        accept_sock = THREAD_FD(thread);
        if (accept_sock < 0) {
-               zlog_err("accept_sock is negative value %d", accept_sock);
+               zlog_ferr(LIB_ERR_DEVELOPMENT,
+                         "accept_sock is negative value %d", accept_sock);
                return -1;
        }
        pim->msdp.listener.thread = NULL;
@@ -80,8 +83,8 @@ static int pim_msdp_sock_accept(struct thread *thread)
        /* accept client connection. */
        msdp_sock = sockunion_accept(accept_sock, &su);
        if (msdp_sock < 0) {
-               zlog_err("pim_msdp_sock_accept failed (%s)",
-                        safe_strerror(errno));
+               zlog_ferr(LIB_ERR_SOCKET, "pim_msdp_sock_accept failed (%s)",
+                         safe_strerror(errno));
                return -1;
        }
 
@@ -106,7 +109,7 @@ static int pim_msdp_sock_accept(struct thread *thread)
         * with this one */
        if (mp->fd >= 0) {
                if (PIM_DEBUG_MSDP_EVENTS) {
-                       zlog_err(
+                       zlog_notice(
                                "msdp peer new connection from %s stop old connection",
                                sockunion2str(&su, buf, SU_ADDRSTRLEN));
                }
@@ -135,7 +138,7 @@ int pim_msdp_sock_listen(struct pim_instance *pim)
 
        sock = socket(AF_INET, SOCK_STREAM, 0);
        if (sock < 0) {
-               zlog_err("socket: %s", safe_strerror(errno));
+               zlog_ferr(LIB_ERR_SOCKET, "socket: %s", safe_strerror(errno));
                return sock;
        }
 
@@ -154,42 +157,47 @@ int pim_msdp_sock_listen(struct pim_instance *pim)
                struct interface *ifp =
                        if_lookup_by_name(pim->vrf->name, pim->vrf_id);
                if (!ifp) {
-                       zlog_err("%s: Unable to lookup vrf interface: %s",
-                                __PRETTY_FUNCTION__, pim->vrf->name);
+                       zlog_ferr(LIB_ERR_INTERFACE,
+                                 "%s: Unable to lookup vrf interface: %s",
+                                 __PRETTY_FUNCTION__, pim->vrf->name);
                        close(sock);
                        return -1;
                }
                if (pim_socket_bind(sock, ifp)) {
-                       zlog_err("%s: Unable to bind to socket: %s",
-                                __PRETTY_FUNCTION__, safe_strerror(errno));
+                       zlog_ferr(LIB_ERR_SOCKET,
+                                 "%s: Unable to bind to socket: %s",
+                                 __PRETTY_FUNCTION__, safe_strerror(errno));
                        close(sock);
                        return -1;
                }
        }
 
        if (pimd_privs.change(ZPRIVS_RAISE)) {
-               zlog_err("pim_msdp_socket: could not raise privs, %s",
-                        safe_strerror(errno));
+               zlog_ferr(LIB_ERR_PRIVILEGES,
+                         "pim_msdp_socket: could not raise privs, %s",
+                         safe_strerror(errno));
        }
 
        /* bind to well known TCP port */
        rc = bind(sock, (struct sockaddr *)&sin, socklen);
 
        if (pimd_privs.change(ZPRIVS_LOWER)) {
-               zlog_err("pim_msdp_socket: could not lower privs, %s",
-                        safe_strerror(errno));
+               zlog_ferr(LIB_ERR_PRIVILEGES,
+                         "pim_msdp_socket: could not lower privs, %s",
+                         safe_strerror(errno));
        }
 
        if (rc < 0) {
-               zlog_err("pim_msdp_socket bind to port %d: %s",
-                        ntohs(sin.sin_port), safe_strerror(errno));
+               zlog_ferr(LIB_ERR_SOCKET, "pim_msdp_socket bind to port %d: %s",
+                         ntohs(sin.sin_port), safe_strerror(errno));
                close(sock);
                return rc;
        }
 
        rc = listen(sock, 3 /* backlog */);
        if (rc < 0) {
-               zlog_err("pim_msdp_socket listen: %s", safe_strerror(errno));
+               zlog_ferr(LIB_ERR_SOCKET, "pim_msdp_socket listen: %s",
+                         safe_strerror(errno));
                close(sock);
                return rc;
        }
@@ -219,7 +227,7 @@ int pim_msdp_sock_connect(struct pim_msdp_peer *mp)
         * with this one */
        if (mp->fd >= 0) {
                if (PIM_DEBUG_MSDP_EVENTS) {
-                       zlog_err(
+                       zlog_notice(
                                "msdp duplicate connect to %s nuke old connection",
                                mp->key_str);
                }
@@ -229,8 +237,8 @@ int pim_msdp_sock_connect(struct pim_msdp_peer *mp)
        /* Make socket for the peer. */
        mp->fd = sockunion_socket(&mp->su_peer);
        if (mp->fd < 0) {
-               zlog_err("pim_msdp_socket socket failure: %s",
-                        safe_strerror(errno));
+               zlog_ferr(LIB_ERR_SOCKET, "pim_msdp_socket socket failure: %s",
+                         safe_strerror(errno));
                return -1;
        }
 
@@ -238,13 +246,15 @@ int pim_msdp_sock_connect(struct pim_msdp_peer *mp)
                struct interface *ifp =
                        if_lookup_by_name(mp->pim->vrf->name, mp->pim->vrf_id);
                if (!ifp) {
-                       zlog_err("%s: Unable to lookup vrf interface: %s",
-                                __PRETTY_FUNCTION__, mp->pim->vrf->name);
+                       zlog_ferr(LIB_ERR_INTERFACE,
+                                 "%s: Unable to lookup vrf interface: %s",
+                                 __PRETTY_FUNCTION__, mp->pim->vrf->name);
                        return -1;
                }
                if (pim_socket_bind(mp->fd, ifp)) {
-                       zlog_err("%s: Unable to bind to socket: %s",
-                                __PRETTY_FUNCTION__, safe_strerror(errno));
+                       zlog_ferr(LIB_ERR_SOCKET,
+                                 "%s: Unable to bind to socket: %s",
+                                 __PRETTY_FUNCTION__, safe_strerror(errno));
                        close(mp->fd);
                        mp->fd = -1;
                        return -1;
@@ -261,8 +271,9 @@ int pim_msdp_sock_connect(struct pim_msdp_peer *mp)
        /* source bind */
        rc = sockunion_bind(mp->fd, &mp->su_local, 0, &mp->su_local);
        if (rc < 0) {
-               zlog_err("pim_msdp_socket connect bind failure: %s",
-                        safe_strerror(errno));
+               zlog_ferr(LIB_ERR_SOCKET,
+                         "pim_msdp_socket connect bind failure: %s",
+                         safe_strerror(errno));
                close(mp->fd);
                mp->fd = -1;
                return rc;

diff --git a/pimd/pim_neighbor.c b/pimd/pim_neighbor.c
index e73422331f7c56918ce0a493abbd3fc2101f2354..0aaf6127d0549dd5cd8ec68c1507b93c637d2c0a 100644 (file)
--- a/pimd/pim_neighbor.c
+++ b/pimd/pim_neighbor.c
@@ -25,6 +25,7 @@
 #include "if.h"
 #include "vty.h"
 #include "plist.h"
+#include "lib_errors.h"
 
 #include "pimd.h"
 #include "pim_neighbor.h"
@@ -799,7 +800,8 @@ void pim_neighbor_update(struct pim_neighbor *neigh,
 
        if (neigh->prefix_list == addr_list) {
                if (addr_list) {
-                       zlog_err(
+                       zlog_ferr(
+                               LIB_ERR_DEVELOPMENT,
                                "%s: internal error: trying to replace same prefix list=%p",
                                __PRETTY_FUNCTION__, (void *)addr_list);
                }

diff --git a/pimd/pim_rp.c b/pimd/pim_rp.c
index 3b3e5eb693c6a575144d3f5669f1ccedcce4b900..fd1b96505b23bea09fe44bdb8bcc619c9d4662f4 100644 (file)
--- a/pimd/pim_rp.c
+++ b/pimd/pim_rp.c
@@ -31,6 +31,7 @@
 #include "plist.h"
 #include "nexthop.h"
 #include "table.h"
+#include "lib_errors.h"
 
 #include "pimd.h"
 #include "pim_vty.h"
@@ -231,7 +232,8 @@ static struct rp_info *pim_rp_find_match_group(struct pim_instance *pim,
 
        rn = route_node_match(pim->rp_table, group);
        if (!rn) {
-               zlog_err(
+               zlog_ferr(
+                       LIB_ERR_DEVELOPMENT,
                        "%s: BUG We should have found default group information\n",
                        __PRETTY_FUNCTION__);
                return best;
@@ -619,7 +621,9 @@ int pim_rp_del(struct pim_instance *pim, const char *rp,
                rn = route_node_get(pim->rp_table, &rp_info->group);
                if (rn) {
                        if (rn->info != rp_info)
-                               zlog_err("WTF matey");
+                               zlog_ferr(
+                                       LIB_ERR_DEVELOPMENT,
+                                       "Expected rn->info to be equal to rp_info");
 
                        if (PIM_DEBUG_TRACE) {
                                char buf[PREFIX_STRLEN];

diff --git a/pimd/pim_sock.c b/pimd/pim_sock.c
index fb0d6b5064e78a20dc83e88923363dee89ad5d8d..44e051804a6cb73395ea2569636c502c86f75d02 100644 (file)
--- a/pimd/pim_sock.c
+++ b/pimd/pim_sock.c
@@ -33,6 +33,7 @@
 #include "if.h"
 #include "vrf.h"
 #include "sockopt.h"
+#include "lib_errors.h"
 
 #include "pimd.h"
 #include "pim_mroute.h"
@@ -46,14 +47,16 @@ int pim_socket_raw(int protocol)
        int fd;
 
        if (pimd_privs.change(ZPRIVS_RAISE))
-               zlog_err("pim_sockek_raw: could not raise privs, %s",
-                        safe_strerror(errno));
+               zlog_ferr(LIB_ERR_PRIVILEGES,
+                         "pim_sockek_raw: could not raise privs, %s",
+                         safe_strerror(errno));
 
        fd = socket(AF_INET, SOCK_RAW, protocol);
 
        if (pimd_privs.change(ZPRIVS_LOWER))
-               zlog_err("pim_socket_raw: could not lower privs, %s",
-                        safe_strerror(errno));
+               zlog_ferr(LIB_ERR_PRIVILEGES,
+                         "pim_socket_raw: could not lower privs, %s",
+                         safe_strerror(errno));
 
        if (fd < 0) {
                zlog_warn("Could not create raw socket: errno=%d: %s", errno,
@@ -69,16 +72,17 @@ void pim_socket_ip_hdr(int fd)
        const int on = 1;
 
        if (pimd_privs.change(ZPRIVS_RAISE))
-               zlog_err("%s: could not raise privs, %s", __PRETTY_FUNCTION__,
-                        safe_strerror(errno));
+               zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not raise privs, %s",
+                         __PRETTY_FUNCTION__, safe_strerror(errno));
 
        if (setsockopt(fd, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on)))
-               zlog_err("%s: Could not turn on IP_HDRINCL option: %s",
-                        __PRETTY_FUNCTION__, safe_strerror(errno));
+               zlog_ferr(LIB_ERR_SOCKET,
+                         "%s: Could not turn on IP_HDRINCL option: %s",
+                         __PRETTY_FUNCTION__, safe_strerror(errno));
 
        if (pimd_privs.change(ZPRIVS_LOWER))
-               zlog_err("%s: could not lower privs, %s", __PRETTY_FUNCTION__,
-                        safe_strerror(errno));
+               zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not lower privs, %s",
+                         __PRETTY_FUNCTION__, safe_strerror(errno));
 }
 
 /*
@@ -91,15 +95,15 @@ int pim_socket_bind(int fd, struct interface *ifp)
 #ifdef SO_BINDTODEVICE
 
        if (pimd_privs.change(ZPRIVS_RAISE))
-               zlog_err("%s: could not raise privs, %s", __PRETTY_FUNCTION__,
-                        safe_strerror(errno));
+               zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not raise privs, %s",
+                         __PRETTY_FUNCTION__, safe_strerror(errno));
 
        ret = setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, ifp->name,
                         strlen(ifp->name));
 
        if (pimd_privs.change(ZPRIVS_LOWER))
-               zlog_err("%s: could not lower privs, %s", __PRETTY_FUNCTION__,
-                        safe_strerror(errno));
+               zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not lower privs, %s",
+                         __PRETTY_FUNCTION__, safe_strerror(errno));
 
 #endif
        return ret;
@@ -161,7 +165,8 @@ int pim_socket_mcast(int protocol, struct in_addr ifaddr, struct interface *ifp,
                                fd, errno, safe_strerror(errno));
                }
 #else
-               zlog_err(
+               zlog_ferr(
+                       LIB_ERR_DEVELOPMENT,
                        "%s %s: Missing IP_PKTINFO and IP_RECVDSTADDR: unable to get dst addr from recvmsg()",
                        __FILE__, __PRETTY_FUNCTION__);
                close(fd);
@@ -298,7 +303,8 @@ int pim_socket_join(int fd, struct in_addr group, struct in_addr ifaddr,
                               sizeof(ifaddr_str)))
                        sprintf(ifaddr_str, "<ifaddr?>");
 
-               zlog_err(
+               zlog_ferr(
+                       LIB_ERR_SOCKET,
                        "Failure socket joining fd=%d group %s on interface address %s: errno=%d: %s",
                        fd, group_str, ifaddr_str, errno, safe_strerror(errno));
                return ret;

diff --git a/pimd/pim_ssmpingd.c b/pimd/pim_ssmpingd.c
index bdf303d5c565faadb816725cde2ac08d30a6f776..3cb49079b48a1ff7f4244e35a85a090f5ed0d2fb 100644 (file)
--- a/pimd/pim_ssmpingd.c
+++ b/pimd/pim_ssmpingd.c
@@ -24,6 +24,7 @@
 #include "memory.h"
 #include "sockopt.h"
 #include "vrf.h"
+#include "lib_errors.h"
 
 #include "pimd.h"
 #include "pim_ssmpingd.h"
@@ -82,8 +83,9 @@ static int ssmpingd_socket(struct in_addr addr, int port, int mttl)
 
        fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
        if (fd < 0) {
-               zlog_err("%s: could not create socket: errno=%d: %s",
-                        __PRETTY_FUNCTION__, errno, safe_strerror(errno));
+               zlog_ferr(LIB_ERR_SOCKET,
+                         "%s: could not create socket: errno=%d: %s",
+                         __PRETTY_FUNCTION__, errno, safe_strerror(errno));
                return -1;
        }
 
@@ -124,7 +126,8 @@ static int ssmpingd_socket(struct in_addr addr, int port, int mttl)
                                safe_strerror(errno));
                }
 #else
-               zlog_err(
+               zlog_ferr(
+                       LIB_ERR_DEVELOPMENT,
                        "%s %s: missing IP_PKTINFO and IP_RECVDSTADDR: unable to get dst addr from recvmsg()",
                        __FILE__, __PRETTY_FUNCTION__);
                close(fd);

diff --git a/pimd/pim_time.c b/pimd/pim_time.c
index 6f011da43e755e8bfa274e6d3a0fd858a2115125..ed2942d5946ceeb75561be688c0fb89f3e14325e 100644 (file)
--- a/pimd/pim_time.c
+++ b/pimd/pim_time.c
@@ -25,6 +25,7 @@
 
 #include "log.h"
 #include "thread.h"
+#include "lib_errors.h"
 
 #include "pim_time.h"
 
@@ -34,8 +35,9 @@ static int gettime_monotonic(struct timeval *tv)
 
        result = gettimeofday(tv, 0);
        if (result) {
-               zlog_err("%s: gettimeofday() failure: errno=%d: %s",
-                        __PRETTY_FUNCTION__, errno, safe_strerror(errno));
+               zlog_ferr(LIB_ERR_SYSTEM_CALL,
+                         "%s: gettimeofday() failure: errno=%d: %s",
+                         __PRETTY_FUNCTION__, errno, safe_strerror(errno));
        }
 
        return result;
@@ -50,8 +52,9 @@ int64_t pim_time_monotonic_sec()
        struct timeval now_tv;
 
        if (gettime_monotonic(&now_tv)) {
-               zlog_err("%s: gettime_monotonic() failure: errno=%d: %s",
-                        __PRETTY_FUNCTION__, errno, safe_strerror(errno));
+               zlog_ferr(LIB_ERR_SYSTEM_CALL,
+                         "%s: gettime_monotonic() failure: errno=%d: %s",
+                         __PRETTY_FUNCTION__, errno, safe_strerror(errno));
                return -1;
        }
 
@@ -68,8 +71,9 @@ int64_t pim_time_monotonic_dsec()
        int64_t now_dsec;
 
        if (gettime_monotonic(&now_tv)) {
-               zlog_err("%s: gettime_monotonic() failure: errno=%d: %s",
-                        __PRETTY_FUNCTION__, errno, safe_strerror(errno));
+               zlog_ferr(LIB_ERR_SYSTEM_CALL,
+                         "%s: gettime_monotonic() failure: errno=%d: %s",
+                         __PRETTY_FUNCTION__, errno, safe_strerror(errno));
                return -1;
        }
 
@@ -85,8 +89,9 @@ int64_t pim_time_monotonic_usec(void)
        int64_t now_dsec;
 
        if (gettime_monotonic(&now_tv)) {
-               zlog_err("%s: gettime_monotonic() failure: errno=%d: %s",
-                        __PRETTY_FUNCTION__, errno, safe_strerror(errno));
+               zlog_ferr(LIB_ERR_SYSTEM_CALL,
+                         "%s: gettime_monotonic() failure: errno=%d: %s",
+                         __PRETTY_FUNCTION__, errno, safe_strerror(errno));
                return -1;
        }
 

diff --git a/pimd/pim_tlv.c b/pimd/pim_tlv.c
index 80bda336dfefeba9adefb0538713bb26a17f558e..70700dd508d1de715715a3e1c4f4b25b4528e8a6 100644 (file)
--- a/pimd/pim_tlv.c
+++ b/pimd/pim_tlv.c
@@ -767,12 +767,6 @@ int pim_tlv_parse_addr_list(const char *ifname, struct in_addr src_addr,
                {
                        struct prefix *p;
                        p = prefix_new();
-                       if (!p) {
-                               zlog_err("%s %s: failure: prefix_new()",
-                                        __FILE__, __PRETTY_FUNCTION__);
-                               FREE_ADDR_LIST(*hello_option_addr_list);
-                               return -3;
-                       }
                        prefix_copy(p, &tmp);
                        listnode_add(*hello_option_addr_list, p);
                }

diff --git a/pimd/pim_zlookup.c b/pimd/pim_zlookup.c
index fb616e1b0dda8ea586c9993c3834516471a06c9a..12958b0390a983382f20f6b6930cd54d6b5cbc7b 100644 (file)
--- a/pimd/pim_zlookup.c
+++ b/pimd/pim_zlookup.c
@@ -28,6 +28,7 @@
 #include "thread.h"
 #include "prefix.h"
 #include "vty.h"
+#include "lib_errors.h"
 
 #include "pimd.h"
 #include "pim_iface.h"
@@ -122,7 +123,8 @@ void zclient_lookup_new(void)
 {
        zlookup = zclient_new_notify(master, &zclient_options_default);
        if (!zlookup) {
-               zlog_err("%s: zclient_new() failure", __PRETTY_FUNCTION__);
+               zlog_ferr(LIB_ERR_ZAPI_SOCKET, "%s: zclient_new() failure",
+                         __PRETTY_FUNCTION__);
                return;
        }
 
@@ -168,8 +170,9 @@ static int zclient_read_nexthop(struct pim_instance *pim,
                err = zclient_read_header(s, zlookup->sock, &length, &marker,
                                          &version, &vrf_id, &command);
                if (err < 0) {
-                       zlog_err("%s: zclient_read_header() failed",
-                                __PRETTY_FUNCTION__);
+                       zlog_ferr(LIB_ERR_ZAPI_MISSMATCH,
+                                 "%s: zclient_read_header() failed",
+                                 __PRETTY_FUNCTION__);
                        zclient_lookup_failed(zlookup);
                        return -1;
                }
@@ -333,15 +336,17 @@ static int zclient_lookup_nexthop_once(struct pim_instance *pim,
 
        ret = writen(zlookup->sock, s->data, stream_get_endp(s));
        if (ret < 0) {
-               zlog_err(
+               zlog_ferr(
+                       LIB_ERR_SOCKET,
                        "%s: writen() failure: %d writing to zclient lookup socket",
                        __PRETTY_FUNCTION__, errno);
                zclient_lookup_failed(zlookup);
                return -2;
        }
        if (ret == 0) {
-               zlog_err("%s: connection closed on zclient lookup socket",
-                        __PRETTY_FUNCTION__);
+               zlog_ferr(LIB_ERR_SOCKET,
+                         "%s: connection closed on zclient lookup socket",
+                         __PRETTY_FUNCTION__);
                zclient_lookup_failed(zlookup);
                return -3;
        }
@@ -509,7 +514,8 @@ int pim_zlookup_sg_statistics(struct channel_oil *c_oil)
        count = stream_get_endp(s);
        ret = writen(zlookup->sock, s->data, count);
        if (ret <= 0) {
-               zlog_err(
+               zlog_ferr(
+                       LIB_ERR_SOCKET,
                        "%s: writen() failure: %d writing to zclient lookup socket",
                        __PRETTY_FUNCTION__, errno);
                return -1;
@@ -528,8 +534,9 @@ int pim_zlookup_sg_statistics(struct channel_oil *c_oil)
                err = zclient_read_header(s, zlookup->sock, &length, &marker,
                                          &version, &vrf_id, &command);
                if (err < 0) {
-                       zlog_err("%s: zclient_read_header() failed",
-                                __PRETTY_FUNCTION__);
+                       zlog_ferr(LIB_ERR_ZAPI_MISSMATCH,
+                                 "%s: zclient_read_header() failed",
+                                 __PRETTY_FUNCTION__);
                        zclient_lookup_failed(zlookup);
                        return -1;
                }
@@ -544,7 +551,8 @@ int pim_zlookup_sg_statistics(struct channel_oil *c_oil)
 
                        more.src = c_oil->oil.mfcc_origin;
                        more.grp = c_oil->oil.mfcc_mcastgrp;
-                       zlog_err(
+                       zlog_ferr(
+                               LIB_ERR_ZAPI_MISSMATCH,
                                "%s: Received wrong %s(%s) information requested",
                                __PRETTY_FUNCTION__, pim_str_sg_dump(&more),
                                c_oil->pim->vrf->name);

diff --git a/pimd/pimd.c b/pimd/pimd.c
index cb7b8b589afbfd2fbec846ebfbffbf97faf6a712..f5ec3728586551c343c81d040bed579c3005e810 100644 (file)
--- a/pimd/pimd.c
+++ b/pimd/pimd.c
@@ -28,6 +28,7 @@
 #include "hash.h"
 #include "jhash.h"
 #include "vrf.h"
+#include "lib_errors.h"
 
 #include "pimd.h"
 #include "pim_cmd.h"
@@ -84,7 +85,8 @@ static void pim_free()
 void pim_init()
 {
        if (!inet_aton(PIM_ALL_PIM_ROUTERS, &qpim_all_pim_routers_addr)) {
-               zlog_err(
+               zlog_ferr(
+                       LIB_ERR_SOCKET,
                        "%s %s: could not solve %s to group address: errno=%d: %s",
                        __FILE__, __PRETTY_FUNCTION__, PIM_ALL_PIM_ROUTERS,
                        errno, safe_strerror(errno));