*: style for EC replacements

[mirror_frr.git] / zebra / kernel_netlink.c

diff --git a/zebra/kernel_netlink.c b/zebra/kernel_netlink.c
index ef7c26c9dfbf30a9e5d7566c88192180014cf6be..1b713cc8cd62b81a2bc3a06483239b8a5f6cc25b 100644 (file)
--- a/zebra/kernel_netlink.c
+++ b/zebra/kernel_netlink.c
@@ -163,7 +163,7 @@ static int netlink_recvbuf(struct nlsock *nl, uint32_t newsize)
 
        ret = getsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &oldsize, &oldlen);
        if (ret < 0) {
-               flog_err_sys(LIB_ERR_SOCKET,
+               flog_err_sys(EC_LIB_SOCKET,
                             "Can't get %s receive buffer size: %s", nl->name,
                             safe_strerror(errno));
                return -1;
@@ -179,7 +179,7 @@ static int netlink_recvbuf(struct nlsock *nl, uint32_t newsize)
                ret = setsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF,
                                 &nl_rcvbufsize, sizeof(nl_rcvbufsize));
        if (ret < 0) {
-               flog_err_sys(LIB_ERR_SOCKET,
+               flog_err_sys(EC_LIB_SOCKET,
                             "Can't set %s receive buffer size: %s", nl->name,
                             safe_strerror(errno));
                return -1;
@@ -187,7 +187,7 @@ static int netlink_recvbuf(struct nlsock *nl, uint32_t newsize)
 
        ret = getsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &newsize, &newlen);
        if (ret < 0) {
-               flog_err_sys(LIB_ERR_SOCKET,
+               flog_err_sys(EC_LIB_SOCKET,
                             "Can't get %s receive buffer size: %s", nl->name,
                             safe_strerror(errno));
                return -1;
@@ -234,7 +234,7 @@ static int netlink_socket(struct nlsock *nl, unsigned long groups,
        namelen = sizeof snl;
        ret = getsockname(sock, (struct sockaddr *)&snl, (socklen_t *)&namelen);
        if (ret < 0 || namelen != sizeof snl) {
-               flog_err_sys(LIB_ERR_SOCKET, "Can't get %s socket name: %s",
+               flog_err_sys(EC_LIB_SOCKET, "Can't get %s socket name: %s",
                             nl->name, safe_strerror(errno));
                close(sock);
                return -1;
@@ -286,10 +286,10 @@ static int netlink_information_fetch(struct nlmsghdr *h, ns_id_t ns_id,
                 * this message type or not ask for
                 * it to be sent up to us
                 */
-               flog_err(ZEBRA_ERR_UNKNOWN_NLMSG,
-                         "Unknown netlink nlmsg_type %s(%d) vrf %u\n",
-                         nl_msg_type_to_str(h->nlmsg_type), h->nlmsg_type,
-                         ns_id);
+               flog_err(EC_ZEBRA_UNKNOWN_NLMSG,
+                        "Unknown netlink nlmsg_type %s(%d) vrf %u\n",
+                        nl_msg_type_to_str(h->nlmsg_type), h->nlmsg_type,
+                        ns_id);
                break;
        }
        return 0;
@@ -453,8 +453,8 @@ static void netlink_install_filter(int sock, __u32 pid)
 
        if (setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog))
            < 0)
-               zlog_warn("Can't install socket filter: %s\n",
-                         safe_strerror(errno));
+               flog_err_sys(EC_LIB_SOCKET, "Can't install socket filter: %s\n",
+                            safe_strerror(errno));
 }
 
 void netlink_parse_rtattr(struct rtattr **tb, int max, struct rtattr *rta,
@@ -467,6 +467,18 @@ void netlink_parse_rtattr(struct rtattr **tb, int max, struct rtattr *rta,
        }
 }
 
+/**
+ * netlink_parse_rtattr_nested() - Parses a nested route attribute
+ * @tb:         Pointer to array for storing rtattr in.
+ * @max:        Max number to store.
+ * @rta:        Pointer to rtattr to look for nested items in.
+ */
+void netlink_parse_rtattr_nested(struct rtattr **tb, int max,
+                                struct rtattr *rta)
+{
+       netlink_parse_rtattr(tb, max, RTA_DATA(rta), RTA_PAYLOAD(rta));
+}
+
 int addattr_l(struct nlmsghdr *n, unsigned int maxlen, int type,
              const void *data, unsigned int alen)
 {
@@ -629,8 +641,8 @@ static void netlink_parse_extended_ack(struct nlmsghdr *h)
                         * but noticing it for later.
                         */
                        err_nlh = &err->msg;
-                       zlog_warn("%s: Received %d extended Ack",
-                                 __PRETTY_FUNCTION__, err_nlh->nlmsg_type);
+                       zlog_debug("%s: Received %d extended Ack",
+                                  __PRETTY_FUNCTION__, err_nlh->nlmsg_type);
                }
        }
 
@@ -640,7 +652,8 @@ static void netlink_parse_extended_ack(struct nlmsghdr *h)
                if (is_err)
                        zlog_err("Extended Error: %s", msg);
                else
-                       zlog_warn("Extended Warning: %s", msg);
+                       flog_warn(EC_ZEBRA_NETLINK_EXTENDED_WARNING,
+                                 "Extended Warning: %s", msg);
        }
 }
 
@@ -696,9 +709,9 @@ int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
                                continue;
                        if (errno == EWOULDBLOCK || errno == EAGAIN)
                                break;
-                       flog_err(ZEBRA_ERR_RECVMSG_OVERRUN,
-                                 "%s recvmsg overrun: %s", nl->name,
-                                 safe_strerror(errno));
+                       flog_err(EC_ZEBRA_RECVMSG_OVERRUN,
+                                "%s recvmsg overrun: %s", nl->name,
+                                safe_strerror(errno));
                        /*
                         *  In this case we are screwed.
                         *  There is no good way to
@@ -709,14 +722,14 @@ int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
                }
 
                if (status == 0) {
-                       flog_err_sys(LIB_ERR_SOCKET, "%s EOF", nl->name);
+                       flog_err_sys(EC_LIB_SOCKET, "%s EOF", nl->name);
                        return -1;
                }
 
                if (msg.msg_namelen != sizeof snl) {
-                       flog_err(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
-                                 "%s sender address length error: length %d",
-                                 nl->name, msg.msg_namelen);
+                       flog_err(EC_ZEBRA_NETLINK_LENGTH_ERROR,
+                                "%s sender address length error: length %d",
+                                nl->name, msg.msg_namelen);
                        return -1;
                }
 
@@ -789,10 +802,9 @@ int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
 
                                if (h->nlmsg_len
                                    < NLMSG_LENGTH(sizeof(struct nlmsgerr))) {
-                                       flog_err(
-                                               ZEBRA_ERR_NETLINK_LENGTH_ERROR,
-                                               "%s error: message truncated",
-                                               nl->name);
+                                       flog_err(EC_ZEBRA_NETLINK_LENGTH_ERROR,
+                                                "%s error: message truncated",
+                                                nl->name);
                                        return -1;
                                }
 
@@ -845,7 +857,7 @@ int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
                                                        err->msg.nlmsg_pid);
                                } else
                                        flog_err(
-                                               ZEBRA_ERR_UNEXPECTED_MESSAGE,
+                                               EC_ZEBRA_UNEXPECTED_MESSAGE,
                                                "%s error: %s, type=%s(%u), seq=%u, pid=%u",
                                                nl->name,
                                                safe_strerror(-errnum),
@@ -878,21 +890,22 @@ int netlink_parse_info(int (*filter)(struct nlmsghdr *, ns_id_t, int),
 
                        error = (*filter)(h, zns->ns_id, startup);
                        if (error < 0) {
-                               zlog_warn("%s filter function error", nl->name);
+                               zlog_debug("%s filter function error",
+                                          nl->name);
                                ret = error;
                        }
                }
 
                /* After error care. */
                if (msg.msg_flags & MSG_TRUNC) {
-                       flog_err(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
-                                 "%s error: message truncated", nl->name);
+                       flog_err(EC_ZEBRA_NETLINK_LENGTH_ERROR,
+                                "%s error: message truncated", nl->name);
                        continue;
                }
                if (status) {
-                       flog_err(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
-                                 "%s error: data remnant size %d", nl->name,
-                                 status);
+                       flog_err(EC_ZEBRA_NETLINK_LENGTH_ERROR,
+                                "%s error: data remnant size %d", nl->name,
+                                status);
                        return -1;
                }
        }
@@ -957,7 +970,7 @@ int netlink_talk(int (*filter)(struct nlmsghdr *, ns_id_t, int startup),
        }
 
        if (status < 0) {
-               flog_err_sys(LIB_ERR_SOCKET, "netlink_talk sendmsg() error: %s",
+               flog_err_sys(EC_LIB_SOCKET, "netlink_talk sendmsg() error: %s",
                             safe_strerror(save_errno));
                return -1;
        }
@@ -980,7 +993,7 @@ int netlink_request(struct nlsock *nl, struct nlmsghdr *n)
 
        /* Check netlink socket. */
        if (nl->sock < 0) {
-               flog_err_sys(LIB_ERR_SOCKET, "%s socket isn't active.",
+               flog_err_sys(EC_LIB_SOCKET, "%s socket isn't active.",
                             nl->name);
                return -1;
        }
@@ -1075,7 +1088,7 @@ void kernel_init(struct zebra_ns *zns)
 
        /* Register kernel socket. */
        if (fcntl(zns->netlink.sock, F_SETFL, O_NONBLOCK) < 0)
-               flog_err_sys(LIB_ERR_SOCKET, "Can't set %s socket flags: %s",
+               flog_err_sys(EC_LIB_SOCKET, "Can't set %s socket flags: %s",
                             zns->netlink.name, safe_strerror(errno));
 
        if (fcntl(zns->netlink_cmd.sock, F_SETFL, O_NONBLOCK) < 0)