all: merge branch 'th/coverity-fixes'

https://github.com/thom311/libnl/pull/310

43 files changed, 463 insertions, 382 deletions

diff --git a/include/netlink-private/nl-auto.h b/include/netlink-private/nl-auto.h
index 4516539c..4434a5b8 100644
--- a/include/netlink-private/nl-auto.h
+++ b/include/netlink-private/nl-auto.h
@@ -51,6 +51,11 @@ void rtnl_route_put(struct rtnl_route *);
 #define _nl_auto_rtnl_route _nl_auto(_nl_auto_rtnl_route_fcn)
 _NL_AUTO_DEFINE_FCN_TYPED0(struct rtnl_route *, _nl_auto_rtnl_route_fcn, rtnl_route_put);
 
+struct rtnl_mdb;
+void rtnl_mdb_put(struct rtnl_mdb *);
+#define _nl_auto_rtnl_mdb _nl_auto(_nl_auto_rtnl_mdb_fcn)
+_NL_AUTO_DEFINE_FCN_TYPED0(struct rtnl_mdb *, _nl_auto_rtnl_mdb_fcn, rtnl_mdb_put);
+
 struct rtnl_nexthop;
 void rtnl_route_nh_free(struct rtnl_nexthop *);
 #define _nl_auto_rtnl_nexthop _nl_auto(_nl_auto_rtnl_nexthop_fcn)
diff --git a/include/netlink-private/utils.h b/include/netlink-private/utils.h
index 8fb12af9..dca05b93 100644
--- a/include/netlink-private/utils.h
+++ b/include/netlink-private/utils.h
@@ -12,6 +12,8 @@
 #include <errno.h>
 #include <string.h>
 #include <stdbool.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
 
 #if __BYTE_ORDER == __BIG_ENDIAN
 #define ntohll(x) (x)
@@ -84,6 +86,40 @@
 
 /*****************************************************************************/
 
+#define _nl_assert_addr_family_or_unspec(addr_family)                          \
+	do {                                                                   \
+		typeof(addr_family) _addr_family = (addr_family);              \
+                                                                               \
+		_nl_assert(_addr_family == AF_UNSPEC ||                        \
+			   _addr_family == AF_INET ||                          \
+			   _addr_family == AF_INET6);                          \
+	} while (0)
+
+#define _nl_assert_addr_family(addr_family)                                    \
+	do {                                                                   \
+		typeof(addr_family) _addr_family = (addr_family);              \
+                                                                               \
+		_nl_assert(_addr_family == AF_INET ||                          \
+			   _addr_family == AF_INET6);                          \
+	} while (0)
+
+/*****************************************************************************/
+
+#define _NL_SWAP(pa, pb)                                                       \
+	do {                                                                   \
+		typeof(*(pa)) *_pa = (pa);                                     \
+		typeof(*(pb)) *_pb = (pb);                                     \
+		typeof(*_pa) _tmp;                                             \
+                                                                               \
+		_nl_assert(_pa);                                               \
+		_nl_assert(_pb);                                               \
+		_tmp = *_pa;                                                   \
+		*_pa = *_pb;                                                   \
+		*_pb = _tmp;                                                   \
+	} while (0)
+
+/*****************************************************************************/
+
 #define _NL_N_ELEMENTS(arr) (sizeof(arr) / sizeof((arr)[0]))
 
 /*****************************************************************************/
@@ -300,4 +336,41 @@ _nl_memdup(const void *ptr, size_t len)
 
 #define _nl_memdup_ptr(ptr) ((__typeof__(ptr)) _nl_memdup((ptr), sizeof(*(ptr))))
 
+/*****************************************************************************/
+
+typedef union {
+	in_addr_t addr4;
+	struct in_addr a4;
+	struct in6_addr a6;
+} _NLIPAddr;
+
+static inline char *_nl_inet_ntop(int addr_family, const void *addr,
+				  char buf[static INET_ADDRSTRLEN])
+{
+	char *r;
+
+	_nl_assert_addr_family(addr_family);
+	_nl_assert(addr);
+
+	/* inet_ntop() is documented to fail, but if we pass a known address family
+	 * and a suitably large buffer, it cannot. Assert for that. */
+
+	r = (char *)inet_ntop(addr_family, addr, buf,
+			      (addr_family == AF_INET) ? INET_ADDRSTRLEN :
+							       INET6_ADDRSTRLEN);
+	_nl_assert(r == buf);
+	_nl_assert(strlen(r) < ((addr_family == AF_INET) ? INET_ADDRSTRLEN :
+								 INET6_ADDRSTRLEN));
+
+	return r;
+}
+
+static inline char *_nl_inet_ntop_dup(int addr_family, const void *addr)
+{
+	return (char *)_nl_inet_ntop(addr_family, addr,
+				     malloc((addr_family == AF_INET) ?
+						    INET_ADDRSTRLEN :
+							  INET6_ADDRSTRLEN));
+}
+
 #endif
diff --git a/include/netlink/utils.h b/include/netlink/utils.h
index 08be8e59..62652b16 100644
--- a/include/netlink/utils.h
+++ b/include/netlink/utils.h
@@ -13,6 +13,12 @@
 extern "C" {
 #endif
 
+#if defined(__GNUC__) && __GNUC__ > 5
+#define _nl_attribute_printf(a, b) __attribute__((__format__(printf, a, b)))
+#else
+#define _nl_attribute_printf(a, b)
+#endif
+
 /**
  * @name Probability Constants
  * @{
@@ -70,8 +76,8 @@ extern int	nl_str2ip_proto(const char *);
 
 /* Dumping helpers */
 extern void	nl_new_line(struct nl_dump_params *);
-extern void	nl_dump(struct nl_dump_params *, const char *, ...);
-extern void	nl_dump_line(struct nl_dump_params *, const char *, ...);
+extern void	nl_dump(struct nl_dump_params *, const char *, ...) _nl_attribute_printf(2, 3);
+extern void	nl_dump_line(struct nl_dump_params *, const char *, ...) _nl_attribute_printf(2, 3);
 
 enum {
 	NL_CAPABILITY_NONE,
diff --git a/lib/netfilter/ct_obj.c b/lib/netfilter/ct_obj.c
index 254c2ca2..86cbc17c 100644
--- a/lib/netfilter/ct_obj.c
+++ b/lib/netfilter/ct_obj.c
@@ -204,7 +204,7 @@ static void ct_dump_line(struct nl_object *a, struct nl_dump_params *p)
 			delta_time /= NSEC_PER_SEC;
 		else
 			delta_time = 0;
-		nl_dump(p, "delta-time %llu ", delta_time);
+		nl_dump(p, "delta-time %llu ", (long long unsigned)delta_time);
 	}
 
 	nl_dump(p, "\n");
diff --git a/lib/netfilter/exp.c b/lib/netfilter/exp.c
index d1c6c8ef..05a6cdcc 100644
--- a/lib/netfilter/exp.c
+++ b/lib/netfilter/exp.c
@@ -416,7 +416,6 @@ nla_put_failure:
 static int nfnl_exp_build_nat(struct nl_msg *msg, const struct nfnl_exp *exp)
 {
 	struct nlattr *nat;
-	int err;
 
 	nat = nla_nest_start(msg, CTA_EXPECT_NAT);
 
@@ -425,7 +424,7 @@ static int nfnl_exp_build_nat(struct nl_msg *msg, const struct nfnl_exp *exp)
 				nfnl_exp_get_nat_dir(exp));
 	}
 
-	if ((err = nfnl_exp_build_tuple(msg, exp, CTA_EXPECT_NAT)) < 0)
+	if (nfnl_exp_build_tuple(msg, exp, CTA_EXPECT_NAT) < 0)
 		goto nla_put_failure;
 
 	nla_nest_end(msg, nat);
diff --git a/lib/netfilter/exp_obj.c b/lib/netfilter/exp_obj.c
index 9a69f3d9..21311c98 100644
--- a/lib/netfilter/exp_obj.c
+++ b/lib/netfilter/exp_obj.c
@@ -218,7 +218,7 @@ static void exp_dump_tuples(struct nfnl_exp *exp, struct nl_dump_params *p)
 	}
 
 	if (nfnl_exp_test_nat_dir(exp))
-		nl_dump(p, "nat dir %s ", exp->exp_nat_dir);
+		nl_dump(p, "nat dir %u ", exp->exp_nat_dir);
 
 }
 
diff --git a/lib/route/classid.c b/lib/route/classid.c
index 3adb0190..350962ac 100644
--- a/lib/route/classid.c
+++ b/lib/route/classid.c
@@ -408,7 +408,7 @@ int rtnl_classid_generate(const char *name, uint32_t *result, uint32_t parent)
 
 	fclose(fd);
 
-	if ((err = classid_map_add(classid, name)) < 0) {
+	if (classid_map_add(classid, name) < 0) {
 		/*
 		 * Error adding classid map, re-read classid file is best
 		 * option here. It is likely to fail as well but better
diff --git a/lib/route/cls/ematch.c b/lib/route/cls/ematch.c
index d79f8078..90520302 100644
--- a/lib/route/cls/ematch.c
+++ b/lib/route/cls/ematch.c
@@ -693,14 +693,14 @@ int rtnl_ematch_parse_expr(const char *expr, char **errp,
 	if (!(tree = rtnl_ematch_tree_alloc(RTNL_EMATCH_PROGID)))
 		return -NLE_FAILURE;
 
-	if ((err = ematch_lex_init(&scanner)) < 0) {
+	if (ematch_lex_init(&scanner) < 0) {
 		err = -NLE_FAILURE;
 		goto errout;
 	}
 
 	buf = ematch__scan_string(expr, scanner);
 
-	if ((err = ematch_parse(scanner, errp, &tree->et_list)) != 0) {
+	if (ematch_parse(scanner, errp, &tree->et_list) != 0) {
 		ematch__delete_buffer(buf, scanner);
 		err = -NLE_PARSE_ERR;
 		goto errout;
diff --git a/lib/route/cls/ematch/meta.c b/lib/route/cls/ematch/meta.c
index 6d724d6d..3f63cdea 100644
--- a/lib/route/cls/ematch/meta.c
+++ b/lib/route/cls/ematch/meta.c
@@ -240,9 +240,9 @@ static void dump_value(struct rtnl_meta_value *v, struct nl_dump_params *p)
 					nl_dump(p, " >> %u", v->mv_shift);
 
 				if (v->mv_len == 4)
-					nl_dump(p, " & %#x", *(uint32_t *) (v + 1));
+					nl_dump(p, " & %#lx", (long unsigned) *(uint32_t *) (v + 1));
 				else if (v->mv_len == 8)
-					nl_dump(p, " & %#x", *(uint64_t *) (v + 1));
+					nl_dump(p, " & %#llx", (long long unsigned) (*(uint64_t *) (v + 1)));
 			}
 		break;
 
diff --git a/lib/route/cls/u32.c b/lib/route/cls/u32.c
index e6c51729..56952fb2 100644
--- a/lib/route/cls/u32.c
+++ b/lib/route/cls/u32.c
@@ -343,7 +343,9 @@ static void print_selector(struct nl_dump_params *p, struct tc_u32_sel *sel,
 		if (p->dp_type == NL_DUMP_STATS &&
 		    (u->cu_mask & U32_ATTR_PCNT)) {
 			struct tc_u32_pcnt *pcnt = u->cu_pcnt->d_data;
-			nl_dump(p, " successful %" PRIu64, pcnt->kcnts[i]);
+
+			nl_dump(p, " successful %llu",
+				(long long unsigned)pcnt->kcnts[i]);
 		}
 	}
 }
@@ -358,11 +360,6 @@ static void u32_dump_details(struct rtnl_tc *tc, void *data,
 	if (!u)
 		return;
 
-	if (!(u->cu_mask & (U32_ATTR_SELECTOR & U32_ATTR_MARK))) {
-		nl_dump(p, "no-selector no-mark\n");
-		return;
-	}
-
 	if (!(u->cu_mask & U32_ATTR_SELECTOR)) {
 		nl_dump(p, "no-selector");
 	} else {
@@ -403,9 +400,11 @@ static void u32_dump_stats(struct rtnl_tc *tc, void *data,
 
 	if (u->cu_mask & U32_ATTR_PCNT) {
 		struct tc_u32_pcnt *pc = u->cu_pcnt->d_data;
+
 		nl_dump(p, "\n");
-		nl_dump_line(p, "    hit %8" PRIu64 " count %8" PRIu64 "\n",
-			     pc->rhit, pc->rcnt);
+		nl_dump_line(p, "    hit %8llu count %8llu\n",
+			     (long long unsigned)pc->rhit,
+			     (long long unsigned)pc->rcnt);
 	}
 }
 
diff --git a/lib/route/link.c b/lib/route/link.c
index 32026003..65f3dbb7 100644
--- a/lib/route/link.c
+++ b/lib/route/link.c
@@ -86,13 +86,12 @@ static struct rtnl_link_af_ops *af_lookup_and_alloc(struct rtnl_link *link,
 						    int family)
 {
 	struct rtnl_link_af_ops *af_ops;
-	void *data;
 
 	af_ops = rtnl_link_af_ops_lookup(family);
 	if (!af_ops)
 		return NULL;
 
-	if (!(data = rtnl_link_af_alloc(link, af_ops))) {
+	if (!rtnl_link_af_alloc(link, af_ops)) {
 		rtnl_link_af_ops_put(af_ops);
 		return NULL;
 	}
@@ -2561,9 +2560,10 @@ int rtnl_link_set_type(struct rtnl_link *link, const char *type)
 
 	io = rtnl_link_info_ops_lookup(type);
 	if (io) {
-		if (   io->io_alloc
-		    && (err = io->io_alloc(link)) < 0)
+		if (io->io_alloc && (err = io->io_alloc(link)) < 0) {
+			_nl_clear_free(&kind);
 			return err;
+		}
 
 		link->l_info_ops = io;
 	}
@@ -3107,22 +3107,16 @@ int rtnl_link_has_vf_list(struct rtnl_link *link) {
 		return 0;
 }
 
-void rtnl_link_set_vf_list(struct rtnl_link *link) {
-	int err;
-
-	if (!(err = rtnl_link_has_vf_list(link)))
+void rtnl_link_set_vf_list(struct rtnl_link *link)
+{
+	if (!rtnl_link_has_vf_list(link))
 		link->ce_mask |= LINK_ATTR_VF_LIST;
-
-	return;
 }
 
-void rtnl_link_unset_vf_list(struct rtnl_link *link) {
-	int err;
-
-	if ((err = rtnl_link_has_vf_list(link)))
+void rtnl_link_unset_vf_list(struct rtnl_link *link)
+{
+	if (rtnl_link_has_vf_list(link))
 		link->ce_mask &= ~LINK_ATTR_VF_LIST;
-
-	return;
 }
 
 /** @} */
diff --git a/lib/route/link/bonding.c b/lib/route/link/bonding.c
index 1d8f89b7..90e64703 100644
--- a/lib/route/link/bonding.c
+++ b/lib/route/link/bonding.c
@@ -27,12 +27,11 @@
 struct rtnl_link *rtnl_link_bond_alloc(void)
 {
 	struct rtnl_link *link;
-	int err;
 
 	if (!(link = rtnl_link_alloc()))
 		return NULL;
 
-	if ((err = rtnl_link_set_type(link, "bond")) < 0) {
+	if (rtnl_link_set_type(link, "bond") < 0) {
 		rtnl_link_put(link);
 		return NULL;
 	}
diff --git a/lib/route/link/bridge.c b/lib/route/link/bridge.c
index 639128d6..bd042539 100644
--- a/lib/route/link/bridge.c
+++ b/lib/route/link/bridge.c
@@ -458,12 +458,11 @@ static int bridge_compare(struct rtnl_link *_a, struct rtnl_link *_b,
 struct rtnl_link *rtnl_link_bridge_alloc(void)
 {
 	struct rtnl_link *link;
-	int err;
 
 	if (!(link = rtnl_link_alloc()))
 		return NULL;
 
-	if ((err = rtnl_link_set_type(link, "bridge")) < 0) {
+	if (rtnl_link_set_type(link, "bridge") < 0) {
 		rtnl_link_put(link);
 		return NULL;
 	}
diff --git a/lib/route/link/can.c b/lib/route/link/can.c
index 759cb2cc..da8f092d 100644
--- a/lib/route/link/can.c
+++ b/lib/route/link/can.c
@@ -273,7 +273,7 @@ static void can_dump_details(struct rtnl_link *link, struct nl_dump_params *p)
 	}
 
 	if (ci->ci_mask & CAN_HAS_CLOCK) {
-		nl_dump_line(p,"    base freq %d Hz\n", ci->ci_clock);
+		nl_dump_line(p,"    base freq %u Hz\n", ci->ci_clock.freq);
 
 	}
 
diff --git a/lib/route/link/geneve.c b/lib/route/link/geneve.c
index 513a0cf6..cab57cc0 100644
--- a/lib/route/link/geneve.c
+++ b/lib/route/link/geneve.c
@@ -186,16 +186,12 @@ static void geneve_dump_details(struct rtnl_link *link, struct nl_dump_params *p
 
         if (geneve->mask & GENEVE_ATTR_REMOTE) {
                 nl_dump(p, "     remote ");
-                if (inet_ntop(AF_INET, &geneve->remote, addr, sizeof(addr)))
-                        nl_dump_line(p, "%s\n", addr);
-                else
-                        nl_dump_line(p, "%#x\n", ntohs(geneve->remote));
+                nl_dump_line(p, "%s\n",
+                             _nl_inet_ntop(AF_INET, &geneve->remote, addr));
         } else if (geneve->mask & GENEVE_ATTR_REMOTE6) {
                 nl_dump(p, "      remote ");
-                if (inet_ntop(AF_INET6, &geneve->remote6, addr, sizeof(addr)))
-                        nl_dump_line(p, "%s\n", addr);
-                else
-                        nl_dump_line(p, "%#x\n", geneve->remote6);
+                nl_dump_line(p, "%s\n",
+                             _nl_inet_ntop(AF_INET6, &geneve->remote6, addr));
         }
 
         if (geneve->mask & GENEVE_ATTR_TTL) {
@@ -352,12 +348,11 @@ static struct rtnl_link_info_ops geneve_info_ops = {
 struct rtnl_link *rtnl_link_geneve_alloc(void)
 {
         struct rtnl_link *link;
-        int err;
 
         if (!(link = rtnl_link_alloc()))
                 return NULL;
 
-        if ((err = rtnl_link_set_type(link, "geneve")) < 0) {
+        if (rtnl_link_set_type(link, "geneve") < 0) {
                 rtnl_link_put(link);
                 return NULL;
         }
diff --git a/lib/route/link/inet6.c b/lib/route/link/inet6.c
index 0cf16234..afcbbceb 100644
--- a/lib/route/link/inet6.c
+++ b/lib/route/link/inet6.c
@@ -413,7 +413,7 @@ static void inet6_dump_stats(struct rtnl_link *link,
 	if (octets)
 		nl_dump(p, "%14.2f %3s ", octets, octetsUnit);
 	else
-		nl_dump(p, "%16" PRIu64 " B ", 0);
+		nl_dump(p, "%16u B ", 0);
 	
 	nl_dump(p, "%18" PRIu64 " %18" PRIu64 "\n",
 		link->l_stats[RTNL_LINK_IP6_INDISCARDS],
@@ -429,7 +429,7 @@ static void inet6_dump_stats(struct rtnl_link *link,
 	if (octets)
 		nl_dump(p, "%14.2f %3s ", octets, octetsUnit);
 	else
-		nl_dump(p, "%16" PRIu64 " B ", 0);
+		nl_dump(p, "%16u B ", 0);
 
 	nl_dump(p, "%18" PRIu64 " %18" PRIu64 "\n",
 		link->l_stats[RTNL_LINK_IP6_OUTDISCARDS],
@@ -445,7 +445,7 @@ static void inet6_dump_stats(struct rtnl_link *link,
 	if (octets)
 		nl_dump(p, "%14.2f %3s ", octets, octetsUnit);
 	else
-		nl_dump(p, "%16" PRIu64 " B ", 0);
+		nl_dump(p, "%16u B ", 0);
 
 	nl_dump(p, "%18" PRIu64 " ", link->l_stats[RTNL_LINK_IP6_INBCASTPKTS]);
 	octets = nl_cancel_down_bytes(link->l_stats[RTNL_LINK_IP6_INBCASTOCTETS],
@@ -453,7 +453,7 @@ static void inet6_dump_stats(struct rtnl_link *link,
 	if (octets)
 		nl_dump(p, "%14.2f %3s\n", octets, octetsUnit);
 	else
-		nl_dump(p, "%16" PRIu64 " B\n", 0);
+		nl_dump(p, "%16u B\n", 0);
 
 	nl_dump(p, "          OutMcastPkts     OutMcastOctets     "
 		   "  OutBcastPkts    OutBcastOctests\n");
@@ -465,7 +465,7 @@ static void inet6_dump_stats(struct rtnl_link *link,
 	if (octets)
 		nl_dump(p, "%14.2f %3s ", octets, octetsUnit);
 	else
-		nl_dump(p, "%16" PRIu64 " B ", 0);
+		nl_dump(p, "%16u B ", 0);
 
 	nl_dump(p, "%18" PRIu64 " ", link->l_stats[RTNL_LINK_IP6_OUTBCASTPKTS]);
 	octets = nl_cancel_down_bytes(link->l_stats[RTNL_LINK_IP6_OUTBCASTOCTETS],
@@ -473,7 +473,7 @@ static void inet6_dump_stats(struct rtnl_link *link,
 	if (octets)
 		nl_dump(p, "%14.2f %3s\n", octets, octetsUnit);
 	else
-		nl_dump(p, "%16" PRIu64 " B\n", 0);
+		nl_dump(p, "%16u B\n", 0);
 
 	nl_dump(p, "              ReasmOKs         ReasmFails     "
 		   "    ReasmReqds       ReasmTimeout\n");
diff --git a/lib/route/link/ip6gre.c b/lib/route/link/ip6gre.c
index 8583a015..5d5c3a01 100644
--- a/lib/route/link/ip6gre.c
+++ b/lib/route/link/ip6gre.c
@@ -238,7 +238,8 @@ static void ip6gre_dump_line(struct rtnl_link *link, struct nl_dump_params *p)
 static void ip6gre_dump_details(struct rtnl_link *link, struct nl_dump_params *p)
 {
 	struct ip6gre_info *ip6gre = link->l_info;
-	char *name, addr[INET6_ADDRSTRLEN];
+	char *name;
+	char addr[INET6_ADDRSTRLEN];
 
 	if (ip6gre->ip6gre_mask & IP6GRE_ATTR_LINK) {
 		nl_dump(p, "      link ");
@@ -271,18 +272,14 @@ static void ip6gre_dump_details(struct rtnl_link *link, struct nl_dump_params *p
 
 	if (ip6gre->ip6gre_mask & IP6GRE_ATTR_LOCAL) {
 		nl_dump(p, "      local ");
-		if(inet_ntop(AF_INET6, &ip6gre->local, addr, sizeof(addr)))
-			nl_dump_line(p, "%s\n", addr);
-		else
-			nl_dump_line(p, "%#x\n", ip6gre->local);
+		nl_dump_line(p, "%s\n",
+			     _nl_inet_ntop(AF_INET6, &ip6gre->local, addr));
 	}
 
 	if (ip6gre->ip6gre_mask & IP6GRE_ATTR_REMOTE) {
 		nl_dump(p, "      remote ");
-		if(inet_ntop(AF_INET6, &ip6gre->remote, addr, sizeof(addr)))
-			nl_dump_line(p, "%s\n", addr);
-		else
-			nl_dump_line(p, "%#x\n", ip6gre->remote);
+		nl_dump_line(p, "%s\n",
+			     _nl_inet_ntop(AF_INET6, &ip6gre->remote, addr));
 	}
 
 	if (ip6gre->ip6gre_mask & IP6GRE_ATTR_TTL) {
diff --git a/lib/route/link/ip6tnl.c b/lib/route/link/ip6tnl.c
index c641c3f3..cdc90241 100644
--- a/lib/route/link/ip6tnl.c
+++ b/lib/route/link/ip6tnl.c
@@ -241,20 +241,14 @@ static void ip6_tnl_dump_details(struct rtnl_link *link, struct nl_dump_params *
 
 	if (ip6_tnl->ip6_tnl_mask & IP6_TNL_ATTR_LOCAL) {
 		nl_dump(p, "      local ");
-
-		if(inet_ntop(AF_INET6, &ip6_tnl->local, addr, INET6_ADDRSTRLEN))
-			nl_dump_line(p, "%s\n", addr);
-		else
-			nl_dump_line(p, "%#x\n", ip6_tnl->local);
+		nl_dump_line(p, "%s\n",
+			     _nl_inet_ntop(AF_INET6, &ip6_tnl->local, addr));
 	}
 
 	if (ip6_tnl->ip6_tnl_mask & IP6_TNL_ATTR_REMOTE) {
 		nl_dump(p, "      remote ");
-
-		if(inet_ntop(AF_INET6, &ip6_tnl->remote, addr, INET6_ADDRSTRLEN))
-			nl_dump_line(p, "%s\n", addr);
-		else
-			nl_dump_line(p, "%#x\n", ip6_tnl->remote);
+		nl_dump_line(p, "%s\n",
+			     _nl_inet_ntop(AF_INET6, &ip6_tnl->remote, addr));
 	}
 
 	if (ip6_tnl->ip6_tnl_mask & IP6_TNL_ATTR_TTL) {
diff --git a/lib/route/link/ip6vti.c b/lib/route/link/ip6vti.c
index 0afaf7a4..8c603abe 100644
--- a/lib/route/link/ip6vti.c
+++ b/lib/route/link/ip6vti.c
@@ -172,7 +172,8 @@ static void ip6vti_dump_line(struct rtnl_link *link, struct nl_dump_params *p)
 static void ip6vti_dump_details(struct rtnl_link *link, struct nl_dump_params *p)
 {
 	struct ip6vti_info *ip6vti = link->l_info;
-	char *name, addr[INET6_ADDRSTRLEN];
+	char *name;
+	char addr[INET6_ADDRSTRLEN];
 
 	if (ip6vti->ip6vti_mask & IP6VTI_ATTR_LINK) {
 		nl_dump(p, "      link ");
@@ -195,18 +196,14 @@ static void ip6vti_dump_details(struct rtnl_link *link, struct nl_dump_params *p
 
 	if (ip6vti->ip6vti_mask & IP6VTI_ATTR_LOCAL) {
 		nl_dump(p, "      local ");
-		if(inet_ntop(AF_INET6, &ip6vti->local, addr, sizeof(addr)))
-			nl_dump_line(p, "%s\n", addr);
-		else
-			nl_dump_line(p, "%#x\n", ip6vti->local);
+		nl_dump_line(p, "%s\n",
+			     _nl_inet_ntop(AF_INET6, &ip6vti->local, addr));
 	}
 
 	if (ip6vti->ip6vti_mask & IP6VTI_ATTR_REMOTE) {
 		nl_dump(p, "      remote ");
-		if(inet_ntop(AF_INET6, &ip6vti->remote, addr, sizeof(addr)))
-			nl_dump_line(p, "%s\n", addr);
-		else
-			nl_dump_line(p, "%#x\n", ip6vti->remote);
+		nl_dump_line(p, "%s\n",
+			     _nl_inet_ntop(AF_INET6, &ip6vti->remote, addr));
 	}
 
 	if (ip6vti->ip6vti_mask & IP6VTI_ATTR_FWMARK) {
diff --git a/lib/route/link/ipvlan.c b/lib/route/link/ipvlan.c
index 5acf8e22..020f2cb9 100644
--- a/lib/route/link/ipvlan.c
+++ b/lib/route/link/ipvlan.c
@@ -172,12 +172,11 @@ static struct rtnl_link_info_ops ipvlan_info_ops = {
 struct rtnl_link *rtnl_link_ipvlan_alloc(void)
 {
 	struct rtnl_link *link;
-	int err;
 
 	if (!(link = rtnl_link_alloc()))
 		return NULL;
 
-	if ((err = rtnl_link_set_type(link, "ipvlan")) < 0) {
+	if (rtnl_link_set_type(link, "ipvlan") < 0) {
 		rtnl_link_put(link);
 		return NULL;
 	}
diff --git a/lib/route/link/macsec.c b/lib/route/link/macsec.c
index 04edc350..16b65b04 100644
--- a/lib/route/link/macsec.c
+++ b/lib/route/link/macsec.c
@@ -263,7 +263,8 @@ static void macsec_dump_line(struct rtnl_link *link, struct nl_dump_params *p)
 	struct macsec_info *info = link->l_info;
 	char tmp[128];
 
-	nl_dump(p, "sci %016llx <%s>", ntohll(info->sci), flags_str(tmp, sizeof(tmp), info));
+	nl_dump(p, "sci %016llx <%s>", (long long unsigned)ntohll(info->sci),
+		flags_str(tmp, sizeof(tmp), info));
 }
 
 static void macsec_dump_details(struct rtnl_link *link, struct nl_dump_params *p)
@@ -271,12 +272,15 @@ static void macsec_dump_details(struct rtnl_link *link, struct nl_dump_params *p
 	struct macsec_info *info = link->l_info;
 	char tmp[128];
 
-	nl_dump(p, "    sci %016llx protect %s encoding_sa %d encrypt %s send_sci %s validate %s %s\n",
-		ntohll(info->sci), values_on_off[info->protect], info->encoding_sa, values_on_off[info->encrypt], values_on_off[info->send_sci],
+	nl_dump(p,
+		"    sci %016llx protect %s encoding_sa %d encrypt %s send_sci %s validate %s %s\n",
+		(long long unsigned)ntohll(info->sci),
+		values_on_off[info->protect], info->encoding_sa,
+		values_on_off[info->encrypt], values_on_off[info->send_sci],
 		VALIDATE_STR[info->validate],
 		replay_protect_str(tmp, info->replay_protect, info->window));
 	nl_dump(p, "    cipher suite: %016llx, icv_len %d\n",
-		info->cipher_suite, info->icv_len);
+		(long long unsigned)info->cipher_suite, info->icv_len);
 }
 
 static int macsec_clone(struct rtnl_link *dst, struct rtnl_link *src)
diff --git a/lib/route/link/macvlan.c b/lib/route/link/macvlan.c
index 48fed6f2..df61bb20 100644
--- a/lib/route/link/macvlan.c
+++ b/lib/route/link/macvlan.c
@@ -307,12 +307,11 @@ static struct rtnl_link_info_ops macvtap_info_ops = {
 struct rtnl_link *rtnl_link_macvlan_alloc(void)
 {
 	struct rtnl_link *link;
-	int err;
 
 	if (!(link = rtnl_link_alloc()))
 		return NULL;
 
-	if ((err = rtnl_link_set_type(link, "macvlan")) < 0) {
+	if (rtnl_link_set_type(link, "macvlan") < 0) {
 		rtnl_link_put(link);
 		return NULL;
 	}
@@ -653,12 +652,11 @@ int rtnl_link_macvlan_del_macaddr(struct rtnl_link *link, struct nl_addr *addr)
 struct rtnl_link *rtnl_link_macvtap_alloc(void)
 {
 	struct rtnl_link *link;
-	int err;
 
 	if (!(link = rtnl_link_alloc()))
 		return NULL;
 
-	if ((err = rtnl_link_set_type(link, "macvtap")) < 0) {
+	if (rtnl_link_set_type(link, "macvtap") < 0) {
 		rtnl_link_put(link);
 		return NULL;
 	}
diff --git a/lib/route/link/ppp.c b/lib/route/link/ppp.c
index 73b32451..a5fb400d 100644
--- a/lib/route/link/ppp.c
+++ b/lib/route/link/ppp.c
@@ -150,12 +150,11 @@ static struct rtnl_link_info_ops ppp_info_ops = {
 struct rtnl_link *rtnl_link_ppp_alloc(void)
 {
 	struct rtnl_link *link;
-	int err;
 
 	if (!(link = rtnl_link_alloc()))
 		return NULL;
 
-	if ((err = rtnl_link_set_type(link, "ppp")) < 0) {
+	if (rtnl_link_set_type(link, "ppp") < 0) {
 		rtnl_link_put(link);
 		return NULL;
 	}
diff --git a/lib/route/link/sriov.c b/lib/route/link/sriov.c
index 9b3bd327..ebc4e6ac 100644
--- a/lib/route/link/sriov.c
+++ b/lib/route/link/sriov.c
@@ -86,7 +86,7 @@ int rtnl_link_sriov_clone(struct rtnl_link *dst, struct rtnl_link *src) {
 	nl_vf_vlans_t *src_vlans = NULL, *dst_vlans = NULL;
 	nl_vf_vlan_info_t *src_vlan_info = NULL, *dst_vlan_info = NULL;
 
-	if (!(err = rtnl_link_has_vf_list(src)))
+	if (!rtnl_link_has_vf_list(src))
 		return 0;
 
 	dst->l_vf_list = rtnl_link_vf_alloc();
@@ -123,7 +123,7 @@ int rtnl_link_sriov_clone(struct rtnl_link *dst, struct rtnl_link *src) {
 			dst_vlan_info = dst_vlans->vlans;
 			memcpy(dst_vlans, src_vlans, sizeof(nl_vf_vlans_t));
 			memcpy(dst_vlan_info, src_vlan_info,
-			       dst_vlans->size * sizeof(dst_vlan_info));
+			       dst_vlans->size * sizeof(*dst_vlan_info));
 			d_vf->vf_vlans = dst_vlans;
 		}
 
@@ -207,10 +207,9 @@ static void dump_vf_details(struct rtnl_link_vf *vf_data,
 /* Loop through SRIOV VF list dump details */
 void rtnl_link_sriov_dump_details(struct rtnl_link *link,
 				  struct nl_dump_params *p) {
-	int err;
 	struct rtnl_link_vf *vf_data, *list, *next;
 
-	if (!(err = rtnl_link_has_vf_list(link)))
+	if (!rtnl_link_has_vf_list(link))
 		BUG();
 
 	nl_dump(p, "    SRIOV VF List\n");
@@ -229,7 +228,7 @@ static void dump_vf_stats(struct rtnl_link_vf *vf_data,
 	char *unit;
 	float res;
 
-	nl_dump(p, "    VF %" PRIu64 " Stats:\n", vf_data->vf_index);
+	nl_dump(p, "    VF %u Stats:\n", vf_data->vf_index);
 	nl_dump_line(p, "\tRX:    %-14s %-10s   %-10s %-10s\n",
 		     "bytes", "packets", "multicast", "broadcast");
 
@@ -271,10 +270,9 @@ void rtnl_link_sriov_dump_stats(struct rtnl_link *link,
 
 /* Free stored SRIOV VF data */
 void rtnl_link_sriov_free_data(struct rtnl_link *link) {
-	int err = 0;
 	struct rtnl_link_vf *list, *vf, *next;
 
-	if (!(err = rtnl_link_has_vf_list(link)))
+	if (!rtnl_link_has_vf_list(link))
 		return;
 
 	list = link->l_vf_list;
@@ -650,7 +648,7 @@ int rtnl_link_sriov_parse_vflist(struct rtnl_link *link, struct nlattr **tb) {
 		}
 
 		if (t[IFLA_VF_STATS]) {
-			err = nla_parse_nested(stb, IFLA_VF_STATS_MAX,
+			err = nla_parse_nested(stb, RTNL_LINK_VF_STATS_MAX,
 					       t[IFLA_VF_STATS],
 					       sriov_stats_policy);
 			if (err < 0) {
diff --git a/lib/route/link/team.c b/lib/route/link/team.c
index 1b470220..1bcc86ed 100644
--- a/lib/route/link/team.c
+++ b/lib/route/link/team.c
@@ -27,12 +27,11 @@
 struct rtnl_link *rtnl_link_team_alloc(void)
 {
 	struct rtnl_link *link;
-	int err;
 
 	if (!(link = rtnl_link_alloc()))
 		return NULL;
 
-	if ((err = rtnl_link_set_type(link, "team")) < 0) {
+	if (rtnl_link_set_type(link, "team") < 0) {
 		rtnl_link_put(link);
 		return NULL;
 	}
diff --git a/lib/route/link/veth.c b/lib/route/link/veth.c
index 561693c0..37f43f69 100644
--- a/lib/route/link/veth.c
+++ b/lib/route/link/veth.c
@@ -207,11 +207,10 @@ static struct rtnl_link_info_ops veth_info_ops = {
 struct rtnl_link *rtnl_link_veth_alloc(void)
 {
 	struct rtnl_link *link;
-	int err;
 
 	if (!(link = rtnl_link_alloc()))
 		return NULL;
-	if ((err = rtnl_link_set_type(link, "veth")) < 0) {
+	if (rtnl_link_set_type(link, "veth") < 0) {
 		rtnl_link_put(link);
 		return NULL;
 	}
diff --git a/lib/route/link/vlan.c b/lib/route/link/vlan.c
index f7e0ff06..36f88225 100644
--- a/lib/route/link/vlan.c
+++ b/lib/route/link/vlan.c
@@ -386,12 +386,11 @@ static struct rtnl_link_info_ops vlan_info_ops = {
 struct rtnl_link *rtnl_link_vlan_alloc(void)
 {
 	struct rtnl_link *link;
-	int err;
 
 	if (!(link = rtnl_link_alloc()))
 		return NULL;
 
-	if ((err = rtnl_link_set_type(link, "vlan")) < 0) {
+	if (rtnl_link_set_type(link, "vlan") < 0) {
 		rtnl_link_put(link);
 		return NULL;
 	}
diff --git a/lib/route/link/vrf.c b/lib/route/link/vrf.c
index f5c12306..c4edd3ef 100644
--- a/lib/route/link/vrf.c
+++ b/lib/route/link/vrf.c
@@ -175,12 +175,11 @@ static struct rtnl_link_info_ops vrf_info_ops = {
 struct rtnl_link *rtnl_link_vrf_alloc(void)
 {
 	struct rtnl_link *link;
-	int err;
 
 	if (!(link = rtnl_link_alloc()))
 		return NULL;
 
-	if ((err = rtnl_link_set_type(link, "vrf")) < 0) {
+	if (rtnl_link_set_type(link, "vrf") < 0) {
 		rtnl_link_put(link);
 		return NULL;
 	}
@@ -234,8 +233,8 @@ int rtnl_link_vrf_set_tableid(struct rtnl_link *link, uint32_t id)
 	struct vrf_info *vi = link->l_info;
 
 	IS_VRF_LINK_ASSERT(link);
-	if(id > VRF_TABLE_ID_MAX)
-		return -NLE_INVAL;
+
+	_NL_STATIC_ASSERT(VRF_TABLE_ID_MAX == UINT32_MAX);
 
 	vi->table_id = id;
 	vi->vi_mask |= VRF_HAS_TABLE_ID;
diff --git a/lib/route/link/vxlan.c b/lib/route/link/vxlan.c
index a4a4c44c..7b8429c8 100644
--- a/lib/route/link/vxlan.c
+++ b/lib/route/link/vxlan.c
@@ -316,16 +316,12 @@ static void vxlan_dump_details(struct rtnl_link *link, struct nl_dump_params *p)
 
 	if (vxi->ce_mask & VXLAN_ATTR_GROUP) {
 		nl_dump(p, "      group ");
-		if (inet_ntop(AF_INET, &vxi->vxi_group, addr, sizeof(addr)))
-			nl_dump_line(p, "%s\n", addr);
-		else
-			nl_dump_line(p, "%#x\n", ntohs(vxi->vxi_group));
+		nl_dump_line(p, "%s\n",
+			     _nl_inet_ntop(AF_INET, &vxi->vxi_group, addr));
 	} else if (vxi->ce_mask & VXLAN_ATTR_GROUP6) {
 		nl_dump(p, "      group ");
-		if (inet_ntop(AF_INET6, &vxi->vxi_group6, addr, sizeof(addr)))
-			nl_dump_line(p, "%s\n", addr);
-		else
-			nl_dump_line(p, "%#x\n", vxi->vxi_group6);
+		nl_dump_line(p, "%s\n",
+			     _nl_inet_ntop(AF_INET6, &vxi->vxi_group6, addr));
 	}
 
 	if (vxi->ce_mask & VXLAN_ATTR_LINK) {
@@ -344,19 +340,14 @@ static void vxlan_dump_details(struct rtnl_link *link, struct nl_dump_params *p)
 
 	if (vxi->ce_mask & VXLAN_ATTR_LOCAL) {
 		nl_dump(p, "      local ");
-		if (inet_ntop(AF_INET, &vxi->vxi_local, addr, sizeof(addr)))
-			nl_dump_line(p, "%s\n", addr);
-		else
-			nl_dump_line(p, "%#x\n", ntohs(vxi->vxi_local));
+		nl_dump_line(p, "%s\n",
+			     _nl_inet_ntop(AF_INET, &vxi->vxi_local, addr));
 	} else if (vxi->ce_mask & VXLAN_ATTR_LOCAL6) {
 		nl_dump(p, "      local ");
-		if (inet_ntop(AF_INET6, &vxi->vxi_local6, addr, sizeof(addr)))
-			nl_dump_line(p, "%s\n", addr);
-		else
-			nl_dump_line(p, "%#x\n", vxi->vxi_local6);
+		nl_dump_line(p, "%s\n",
+			     _nl_inet_ntop(AF_INET6, &vxi->vxi_local6, addr));
 	}
 
-
 	if (vxi->ce_mask & VXLAN_ATTR_TTL) {
 		nl_dump(p, "      ttl ");
 		if(vxi->vxi_ttl)
@@ -368,7 +359,7 @@ static void vxlan_dump_details(struct rtnl_link *link, struct nl_dump_params *p)
 	if (vxi->ce_mask & VXLAN_ATTR_TOS) {
 		nl_dump(p, "      tos ");
 		if (vxi->vxi_tos == 1)
-			nl_dump_line(p, "inherit\n", vxi->vxi_tos);
+			nl_dump_line(p, "inherit\n");
 		else
 			nl_dump_line(p, "%#x\n", vxi->vxi_tos);
 	}
@@ -695,12 +686,11 @@ static struct rtnl_link_info_ops vxlan_info_ops = {
 struct rtnl_link *rtnl_link_vxlan_alloc(void)
 {
 	struct rtnl_link *link;
-	int err;
 
 	if (!(link = rtnl_link_alloc()))
 		return NULL;
 
-	if ((err = rtnl_link_set_type(link, "vxlan")) < 0) {
+	if (rtnl_link_set_type(link, "vxlan") < 0) {
 		rtnl_link_put(link);
 		return NULL;
 	}
diff --git a/lib/route/mdb.c b/lib/route/mdb.c
index 39fad480..459959ee 100644
--- a/lib/route/mdb.c
+++ b/lib/route/mdb.c
@@ -14,6 +14,7 @@
 #define MDB_ATTR_ENTRIES         0x000002
 
 static struct rtnl_mdb_entry *rtnl_mdb_entry_alloc(void);
+static void rtnl_mdb_entry_free(struct rtnl_mdb_entry *mdb_entry);
 
 static struct nl_cache_ops rtnl_mdb_ops;
 static struct nl_object_ops mdb_obj_ops;
@@ -28,15 +29,13 @@ static void mdb_constructor(struct nl_object *obj)
 
 static void mdb_free_data(struct nl_object *obj)
 {
-	struct rtnl_mdb *mdb = (struct rtnl_mdb *) obj;
+	struct rtnl_mdb *mdb = (struct rtnl_mdb *)obj;
 	struct rtnl_mdb_entry *mdb_entry;
 	struct rtnl_mdb_entry *mdb_entry_safe;
 
-	nl_list_for_each_entry_safe(mdb_entry, mdb_entry_safe, &mdb->mdb_entry_list, mdb_list) {
-		nl_list_del(&mdb_entry->mdb_list);
-		nl_addr_put(mdb_entry->addr);
-		free(mdb_entry);
-	}
+	nl_list_for_each_entry_safe(mdb_entry, mdb_entry_safe,
+				    &mdb->mdb_entry_list, mdb_list)
+		rtnl_mdb_entry_free(mdb_entry);
 }
 
 static int mdb_entry_equal(struct rtnl_mdb_entry *a, struct rtnl_mdb_entry *b)
@@ -176,7 +175,7 @@ static int mdb_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
 	struct br_port_msg *port;
 	struct nlattr *nla;
 	struct br_mdb_entry *e;
-	struct rtnl_mdb *mdb = rtnl_mdb_alloc();
+	_nl_auto_rtnl_mdb struct rtnl_mdb *mdb = rtnl_mdb_alloc();
 
 	if (!mdb)
 		return -NLE_NOMEM;
@@ -184,7 +183,7 @@ static int mdb_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
 	err = nlmsg_parse(nlh, sizeof(struct br_port_msg), tb, MDBA_MAX,
 	                  mdb_policy);
 	if (err < 0)
-		goto errout;
+		return err;
 
 	mdb->ce_msgtype = nlh->nlmsg_type;
 
@@ -195,8 +194,10 @@ static int mdb_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
 	if (tb[MDBA_MDB]) {
 		struct nlattr *db_attr[MDBA_MDB_MAX+1];
 
-		nla_parse_nested(db_attr, MDBA_MDB_MAX, tb[MDBA_MDB],
-		                 mdb_db_policy);
+		err = nla_parse_nested(db_attr, MDBA_MDB_MAX, tb[MDBA_MDB],
+				       mdb_db_policy);
+		if (err < 0)
+			return err;
 		rem = nla_len(tb[MDBA_MDB]);
 
 		for (nla = nla_data(tb[MDBA_MDB]); nla_ok(nla, rem);
@@ -206,51 +207,47 @@ static int mdb_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
 
 			for (nla2 = nla_data(nla); nla_ok(nla2, rm);
 			     nla2 = nla_next(nla2, &rm)) {
-				struct rtnl_mdb_entry *entry = rtnl_mdb_entry_alloc();
+				_nl_auto_nl_addr struct nl_addr *addr = NULL;
+				struct rtnl_mdb_entry *entry;
+				uint16_t proto;
+
+				e = nla_data(nla2);
 
-				if (!entry) {
-					goto errout;
+				proto = ntohs(e->addr.proto);
+
+				if (proto == ETH_P_IP) {
+					addr = nl_addr_build(
+						AF_INET, &e->addr.u.ip4,
+						sizeof(e->addr.u.ip4));
+				} else if (proto == ETH_P_IPV6) {
+					addr = nl_addr_build(
+						AF_INET6, &e->addr.u.ip6,
+						sizeof(e->addr.u.ip6));
+				} else {
+					addr = nl_addr_build(
+						AF_LLC, e->addr.u.mac_addr,
+						sizeof(e->addr.u.mac_addr));
 				}
+				if (!addr)
+					return -NLE_NOMEM;
 
-				e = nla_data(nla2);
+				entry = rtnl_mdb_entry_alloc();
+				if (!entry)
+					return -NLE_NOMEM;
 
 				mdb->ce_mask |= MDB_ATTR_ENTRIES;
 
 				entry->ifindex = e->ifindex;
-
 				entry->vid = e->vid;
-
 				entry->state = e->state;
-
 				entry->proto = ntohs(e->addr.proto);
-
-				if (entry->proto == ETH_P_IP) {
-					entry->addr = nl_addr_build(AF_INET,
-					                            &e->addr.u.ip4,
-					                            sizeof(e->addr.u.ip4));
-				} else if (entry->proto == ETH_P_IPV6) {
-					entry->addr = nl_addr_build(AF_INET6,
-					                            &e->addr.u.ip6,
-					                            sizeof(e->addr.u.ip6));
-				} else {
-					entry->addr = nl_addr_build(AF_LLC,
-								    e->addr.u.mac_addr,
-								    sizeof(e->addr.u.mac_addr));
-				}
-
-				if (!entry->addr)
-					goto errout;
-
+				entry->addr = _nl_steal_pointer(&addr);
 				rtnl_mdb_add_entry(mdb, entry);
 			}
 		}
 	}
 
-	err = pp->pp_cb((struct nl_object *) mdb, pp);
-errout:
-	rtnl_mdb_put(mdb);
-
-	return err;
+	return pp->pp_cb((struct nl_object *) mdb, pp);
 }
 
 static int mdb_request_update(struct nl_cache *cache, struct nl_sock *sk)
@@ -428,6 +425,13 @@ static struct rtnl_mdb_entry *rtnl_mdb_entry_alloc(void)
 
 }
 
+static void rtnl_mdb_entry_free(struct rtnl_mdb_entry *mdb_entry)
+{
+	nl_list_del(&mdb_entry->mdb_list);
+	nl_addr_put(mdb_entry->addr);
+	free(mdb_entry);
+}
+
 static struct nl_af_group mdb_groups[] = {
 	{AF_BRIDGE, RTNLGRP_MDB},
 	{END_OF_GROUP_LIST},
diff --git a/lib/route/neightbl.c b/lib/route/neightbl.c
index 468613b6..c4244fc6 100644
--- a/lib/route/neightbl.c
+++ b/lib/route/neightbl.c
@@ -19,31 +19,31 @@
 #include <netlink/route/link.h>
 
 /** @cond SKIP */
-#define NEIGHTBL_ATTR_FAMILY       0x001
-#define NEIGHTBL_ATTR_STATS        0x002
-#define NEIGHTBL_ATTR_NAME	  0x004
-#define NEIGHTBL_ATTR_THRESH1	  0x008
-#define NEIGHTBL_ATTR_THRESH2	  0x010
-#define NEIGHTBL_ATTR_THRESH3	  0x020
-#define NEIGHTBL_ATTR_CONFIG	  0x040
-#define NEIGHTBL_ATTR_PARMS	  0x080
-#define NEIGHTBL_ATTR_GC_INTERVAL  0x100
-
-#define NEIGHTBLPARM_ATTR_IFINDEX	0x0001
-#define NEIGHTBLPARM_ATTR_REFCNT		0x0002
-#define NEIGHTBLPARM_ATTR_QUEUE_LEN	0x0004
-#define NEIGHTBLPARM_ATTR_APP_PROBES	0x0008
-#define NEIGHTBLPARM_ATTR_UCAST_PROBES	0x0010
-#define NEIGHTBLPARM_ATTR_MCAST_PROBES	0x0020
-#define NEIGHTBLPARM_ATTR_PROXY_QLEN	0x0040
-#define NEIGHTBLPARM_ATTR_REACHABLE_TIME	0x0080
+#define NEIGHTBL_ATTR_FAMILY 0x001
+#define NEIGHTBL_ATTR_STATS 0x002
+#define NEIGHTBL_ATTR_NAME 0x004
+#define NEIGHTBL_ATTR_THRESH1 0x008
+#define NEIGHTBL_ATTR_THRESH2 0x010
+#define NEIGHTBL_ATTR_THRESH3 0x020
+#define NEIGHTBL_ATTR_CONFIG 0x040
+#define NEIGHTBL_ATTR_PARMS 0x080
+#define NEIGHTBL_ATTR_GC_INTERVAL 0x100
+
+#define NEIGHTBLPARM_ATTR_IFINDEX 0x0001
+#define NEIGHTBLPARM_ATTR_REFCNT 0x0002
+#define NEIGHTBLPARM_ATTR_QUEUE_LEN 0x0004
+#define NEIGHTBLPARM_ATTR_APP_PROBES 0x0008
+#define NEIGHTBLPARM_ATTR_UCAST_PROBES 0x0010
+#define NEIGHTBLPARM_ATTR_MCAST_PROBES 0x0020
+#define NEIGHTBLPARM_ATTR_PROXY_QLEN 0x0040
+#define NEIGHTBLPARM_ATTR_REACHABLE_TIME 0x0080
 #define NEIGHTBLPARM_ATTR_BASE_REACHABLE_TIME 0x0100
-#define NEIGHTBLPARM_ATTR_RETRANS_TIME	0x0200
-#define NEIGHTBLPARM_ATTR_GC_STALETIME	0x0400
+#define NEIGHTBLPARM_ATTR_RETRANS_TIME 0x0200
+#define NEIGHTBLPARM_ATTR_GC_STALETIME 0x0400
 #define NEIGHTBLPARM_ATTR_DELAY_PROBE_TIME 0x0800
-#define NEIGHTBLPARM_ATTR_ANYCAST_DELAY	0x1000
-#define NEIGHTBLPARM_ATTR_PROXY_DELAY	0x2000
-#define NEIGHTBLPARM_ATTR_LOCKTIME	0x4000
+#define NEIGHTBLPARM_ATTR_ANYCAST_DELAY 0x1000
+#define NEIGHTBLPARM_ATTR_PROXY_DELAY 0x2000
+#define NEIGHTBLPARM_ATTR_LOCKTIME 0x4000
 
 static struct nl_cache_ops rtnl_neightbl_ops;
 static struct nl_object_ops neightbl_obj_ops;
@@ -52,18 +52,18 @@ static struct nl_object_ops neightbl_obj_ops;
 static uint64_t neightbl_compare(struct nl_object *_a, struct nl_object *_b,
 				 uint64_t attrs, int flags)
 {
-	struct rtnl_neightbl *a = (struct rtnl_neightbl *) _a;
-	struct rtnl_neightbl *b = (struct rtnl_neightbl *) _b;
+	struct rtnl_neightbl *a = (struct rtnl_neightbl *)_a;
+	struct rtnl_neightbl *b = (struct rtnl_neightbl *)_b;
 	uint64_t diff = 0;
 
 #define NT_DIFF(ATTR, EXPR) ATTR_DIFF(attrs, NEIGHTBL_ATTR_##ATTR, a, b, EXPR)
 
-	diff |= NT_DIFF(FAMILY,		a->nt_family != b->nt_family);
-	diff |= NT_DIFF(NAME,		strcmp(a->nt_name, b->nt_name));
-	diff |= NT_DIFF(THRESH1,	a->nt_gc_thresh1 != b->nt_gc_thresh1);
-	diff |= NT_DIFF(THRESH2,	a->nt_gc_thresh2 != b->nt_gc_thresh2);
-	diff |= NT_DIFF(THRESH3,	a->nt_gc_thresh3 != b->nt_gc_thresh3);
-	diff |= NT_DIFF(GC_INTERVAL,	a->nt_gc_interval != b->nt_gc_interval);
+	diff |= NT_DIFF(FAMILY, a->nt_family != b->nt_family);
+	diff |= NT_DIFF(NAME, strcmp(a->nt_name, b->nt_name));
+	diff |= NT_DIFF(THRESH1, a->nt_gc_thresh1 != b->nt_gc_thresh1);
+	diff |= NT_DIFF(THRESH2, a->nt_gc_thresh2 != b->nt_gc_thresh2);
+	diff |= NT_DIFF(THRESH3, a->nt_gc_thresh3 != b->nt_gc_thresh3);
+	diff |= NT_DIFF(GC_INTERVAL, a->nt_gc_interval != b->nt_gc_interval);
 
 #undef NT_DIFF
 
@@ -71,8 +71,7 @@ static uint64_t neightbl_compare(struct nl_object *_a, struct nl_object *_b,
 	    !(b->ce_mask & NEIGHTBL_ATTR_PARMS))
 		return diff;
 
-	/* XXX: FIXME: Compare parameter table */
-
+		/* XXX: FIXME: Compare parameter table */
 
 #if 0
 #define REQ(F) (fp->ntp_mask & NEIGHTBLPARM_ATTR_##F)
@@ -100,17 +99,15 @@ static uint64_t neightbl_compare(struct nl_object *_a, struct nl_object *_b,
 	return diff;
 }
 
-
-static struct nla_policy neightbl_policy[NDTA_MAX+1] = {
-	[NDTA_NAME]		= { .type = NLA_STRING,
-				    .maxlen = NTBLNAMSIZ },
-	[NDTA_THRESH1]		= { .type = NLA_U32 },
-	[NDTA_THRESH2]		= { .type = NLA_U32 },
-	[NDTA_THRESH3]		= { .type = NLA_U32 },
-	[NDTA_GC_INTERVAL]	= { .type = NLA_U32 },
-	[NDTA_CONFIG]		= { .minlen = sizeof(struct ndt_config) },
-	[NDTA_STATS]		= { .minlen = sizeof(struct ndt_stats) },
-	[NDTA_PARMS]		= { .type = NLA_NESTED },
+static struct nla_policy neightbl_policy[NDTA_MAX + 1] = {
+	[NDTA_NAME] = { .type = NLA_STRING, .maxlen = NTBLNAMSIZ },
+	[NDTA_THRESH1] = { .type = NLA_U32 },
+	[NDTA_THRESH2] = { .type = NLA_U32 },
+	[NDTA_THRESH3] = { .type = NLA_U32 },
+	[NDTA_GC_INTERVAL] = { .type = NLA_U32 },
+	[NDTA_CONFIG] = { .minlen = sizeof(struct ndt_config) },
+	[NDTA_STATS] = { .minlen = sizeof(struct ndt_stats) },
+	[NDTA_PARMS] = { .type = NLA_NESTED },
 };
 
 static int neightbl_msg_parser(struct nl_cache_ops *ops,
@@ -185,11 +182,11 @@ static int neightbl_msg_parser(struct nl_cache_ops *ops,
 		if (err < 0)
 			goto errout;
 
-#define COPY_ENTRY(name, var) \
-		if (tbp[NDTPA_ ##name]) { \
-			p->ntp_ ##var = nla_get_u32(tbp[NDTPA_ ##name]); \
-			p->ntp_mask |= NEIGHTBLPARM_ATTR_ ##name; \
-		}
+#define COPY_ENTRY(name, var)                                                  \
+	if (tbp[NDTPA_##name]) {                                               \
+		p->ntp_##var = nla_get_u32(tbp[NDTPA_##name]);                 \
+		p->ntp_mask |= NEIGHTBLPARM_ATTR_##name;                       \
+	}
 
 		COPY_ENTRY(IFINDEX, ifindex);
 		COPY_ENTRY(REFCNT, refcnt);
@@ -211,7 +208,7 @@ static int neightbl_msg_parser(struct nl_cache_ops *ops,
 		ntbl->ce_mask |= NEIGHTBL_ATTR_PARMS;
 	}
 
-	err = pp->pp_cb((struct nl_object *) ntbl, pp);
+	err = pp->pp_cb((struct nl_object *)ntbl, pp);
 errout:
 	rtnl_neightbl_put(ntbl);
 	return err;
@@ -222,10 +219,9 @@ static int neightbl_request_update(struct nl_cache *c, struct nl_sock *h)
 	return nl_rtgen_request(h, RTM_GETNEIGHTBL, AF_UNSPEC, NLM_F_DUMP);
 }
 
-
 static void neightbl_dump_line(struct nl_object *arg, struct nl_dump_params *p)
 {
-	struct rtnl_neightbl *ntbl = (struct rtnl_neightbl *) arg;
+	struct rtnl_neightbl *ntbl = (struct rtnl_neightbl *)arg;
 
 	nl_dump_line(p, "%s", ntbl->nt_name);
 
@@ -261,101 +257,102 @@ static void neightbl_dump_line(struct nl_object *arg, struct nl_dump_params *p)
 	nl_dump(p, "\n");
 }
 
-static void neightbl_dump_details(struct nl_object *arg, struct nl_dump_params *p)
+static void neightbl_dump_details(struct nl_object *arg,
+				  struct nl_dump_params *p)
 {
 	char x[32], y[32], z[32];
-	struct rtnl_neightbl *ntbl = (struct rtnl_neightbl *) arg;
+	struct rtnl_neightbl *ntbl = (struct rtnl_neightbl *)arg;
 
 	neightbl_dump_line(arg, p);
 
 	if (ntbl->ce_mask & NEIGHTBL_ATTR_CONFIG) {
 		nl_dump_line(p, "    key-len %u entry-size %u last-flush %s\n",
-			ntbl->nt_config.ndtc_key_len,
-			ntbl->nt_config.ndtc_entry_size,
-			nl_msec2str(ntbl->nt_config.ndtc_last_flush,
-				    x, sizeof(x)));
-
-		nl_dump_line(p, "    gc threshold %u/%u/%u interval %s " \
-				"chain-position %u\n",
-			ntbl->nt_gc_thresh1, ntbl->nt_gc_thresh2,
-			ntbl->nt_gc_thresh3,
-			nl_msec2str(ntbl->nt_gc_interval, x, sizeof(x)),
-			ntbl->nt_config.ndtc_hash_chain_gc);
+			     ntbl->nt_config.ndtc_key_len,
+			     ntbl->nt_config.ndtc_entry_size,
+			     nl_msec2str(ntbl->nt_config.ndtc_last_flush, x,
+					 sizeof(x)));
+
+		nl_dump_line(p,
+			     "    gc threshold %u/%u/%u interval %s "
+			     "chain-position %u\n",
+			     ntbl->nt_gc_thresh1, ntbl->nt_gc_thresh2,
+			     ntbl->nt_gc_thresh3,
+			     nl_msec2str(ntbl->nt_gc_interval, x, sizeof(x)),
+			     ntbl->nt_config.ndtc_hash_chain_gc);
 
 		nl_dump_line(p, "    hash-rand 0x%08X/0x%08X last-rand %s\n",
-			ntbl->nt_config.ndtc_hash_rnd,
-			ntbl->nt_config.ndtc_hash_mask,
-			nl_msec2str(ntbl->nt_config.ndtc_last_rand,
-				    x, sizeof(x)));
+			     ntbl->nt_config.ndtc_hash_rnd,
+			     ntbl->nt_config.ndtc_hash_mask,
+			     nl_msec2str(ntbl->nt_config.ndtc_last_rand, x,
+					 sizeof(x)));
 	}
 
 	if (ntbl->ce_mask & NEIGHTBL_ATTR_PARMS) {
 		struct rtnl_neightbl_parms *pa = &ntbl->nt_parms;
 
-		nl_dump_line(p, "    refcnt %u pending-queue-limit %u " \
-				"proxy-delayed-queue-limit %u\n",
-			pa->ntp_refcnt,
-			pa->ntp_queue_len,
-			pa->ntp_proxy_qlen);
-
-		nl_dump_line(p, "    num-userspace-probes %u num-unicast-probes " \
-				"%u num-multicast-probes %u\n",
-			pa->ntp_app_probes,
-			pa->ntp_ucast_probes,
-			pa->ntp_mcast_probes);
-
-		nl_dump_line(p, "    min-age %s base-reachable-time %s " \
-				"stale-check-interval %s\n",
-			nl_msec2str(pa->ntp_locktime, x, sizeof(x)),
-			nl_msec2str(pa->ntp_base_reachable_time,
-				    y, sizeof(y)),
-			nl_msec2str(pa->ntp_gc_stale_time, z, sizeof(z)));
-
-		nl_dump_line(p, "    initial-probe-delay %s answer-delay %s " \
-				"proxy-answer-delay %s\n",
-			nl_msec2str(pa->ntp_probe_delay, x, sizeof(x)),
-			nl_msec2str(pa->ntp_anycast_delay, y, sizeof(y)),
-			nl_msec2str(pa->ntp_proxy_delay, z, sizeof(z)));
+		nl_dump_line(p,
+			     "    refcnt %u pending-queue-limit %u "
+			     "proxy-delayed-queue-limit %u\n",
+			     pa->ntp_refcnt, pa->ntp_queue_len,
+			     pa->ntp_proxy_qlen);
+
+		nl_dump_line(p,
+			     "    num-userspace-probes %u num-unicast-probes "
+			     "%u num-multicast-probes %u\n",
+			     pa->ntp_app_probes, pa->ntp_ucast_probes,
+			     pa->ntp_mcast_probes);
+
+		nl_dump_line(p,
+			     "    min-age %s base-reachable-time %s "
+			     "stale-check-interval %s\n",
+			     nl_msec2str(pa->ntp_locktime, x, sizeof(x)),
+			     nl_msec2str(pa->ntp_base_reachable_time, y,
+					 sizeof(y)),
+			     nl_msec2str(pa->ntp_gc_stale_time, z, sizeof(z)));
+
+		nl_dump_line(p,
+			     "    initial-probe-delay %s answer-delay %s "
+			     "proxy-answer-delay %s\n",
+			     nl_msec2str(pa->ntp_probe_delay, x, sizeof(x)),
+			     nl_msec2str(pa->ntp_anycast_delay, y, sizeof(y)),
+			     nl_msec2str(pa->ntp_proxy_delay, z, sizeof(z)));
 	}
 }
 
 static void neightbl_dump_stats(struct nl_object *arg, struct nl_dump_params *p)
 {
-	struct rtnl_neightbl *ntbl = (struct rtnl_neightbl *) arg;
+	struct rtnl_neightbl *ntbl = (struct rtnl_neightbl *)arg;
 
 	neightbl_dump_details(arg, p);
 
 	if (!(ntbl->ce_mask & NEIGHTBL_ATTR_STATS))
 		return;
 
-	nl_dump_line(p, "   " \
-			" lookups %" PRIu64 \
-			" hits %" PRIu64 \
-			" failed %" PRIu64 \
-			" allocations %" PRIu64 \
-			" destroys %" PRIu64 \
-			"\n",
-		ntbl->nt_stats.ndts_lookups,
-		ntbl->nt_stats.ndts_hits,
-		ntbl->nt_stats.ndts_res_failed,
-		ntbl->nt_stats.ndts_allocs,
-		ntbl->nt_stats.ndts_destroys);
-
-	nl_dump_line(p, "   " \
-			" hash-grows %" PRIu64 \
-			" forced-gc-runs %" PRIu64 \
-			" periodic-gc-runs %" PRIu64 \
-			"\n",
-		ntbl->nt_stats.ndts_hash_grows,
-		ntbl->nt_stats.ndts_forced_gc_runs,
-		ntbl->nt_stats.ndts_periodic_gc_runs);
-
-	nl_dump_line(p, "   " \
-			" rcv-unicast-probes %" PRIu64 \
-			" rcv-multicast-probes %" PRIu64 \
-			"\n",
-		ntbl->nt_stats.ndts_rcv_probes_ucast,
-		ntbl->nt_stats.ndts_rcv_probes_mcast);
+	nl_dump_line(p,
+		     "   "
+		     " lookups %llu hits %llu failed %llu"
+		     " allocations %llu destroys %llu\n",
+		     (long long unsigned)ntbl->nt_stats.ndts_lookups,
+		     (long long unsigned)ntbl->nt_stats.ndts_hits,
+		     (long long unsigned)ntbl->nt_stats.ndts_res_failed,
+		     (long long unsigned)ntbl->nt_stats.ndts_allocs,
+		     (long long unsigned)ntbl->nt_stats.ndts_destroys);
+
+	nl_dump_line(p,
+		     "   "
+		     " hash-grows %llu forced-gc-runs %llu"
+		     " periodic-gc-runs %llu\n",
+		     (long long unsigned)ntbl->nt_stats.ndts_hash_grows,
+		     (long long unsigned)ntbl->nt_stats.ndts_forced_gc_runs,
+		     (long long unsigned)ntbl->nt_stats.ndts_periodic_gc_runs);
+
+	nl_dump_line(p,
+		     "   "
+		     " rcv-unicast-probes %llu"
+		     " rcv-multicast-probes %llu"
+		     "\n",
+		     (long long unsigned)ntbl->nt_stats.ndts_rcv_probes_ucast,
+		     (long long unsigned)ntbl->nt_stats.ndts_rcv_probes_mcast);
 }
 
 /**
@@ -365,12 +362,12 @@ static void neightbl_dump_stats(struct nl_object *arg, struct nl_dump_params *p)
 
 struct rtnl_neightbl *rtnl_neightbl_alloc(void)
 {
-	return (struct rtnl_neightbl *) nl_object_alloc(&neightbl_obj_ops);
+	return (struct rtnl_neightbl *)nl_object_alloc(&neightbl_obj_ops);
 }
 
 void rtnl_neightbl_put(struct rtnl_neightbl *neightbl)
 {
-	nl_object_put((struct nl_object *) neightbl);
+	nl_object_put((struct nl_object *)neightbl);
 }
 
 /** @} */
@@ -417,11 +414,11 @@ struct rtnl_neightbl *rtnl_neightbl_get(struct nl_cache *cache,
 	if (cache->c_ops != &rtnl_neightbl_ops)
 		return NULL;
 
-	nl_list_for_each_entry(nt, &cache->c_items, ce_list) {
+	nl_list_for_each_entry (nt, &cache->c_items, ce_list) {
 		if (!strcasecmp(nt->nt_name, name) &&
 		    ((!ifindex && !nt->nt_parms.ntp_ifindex) ||
 		     (ifindex && ifindex == nt->nt_parms.ntp_ifindex))) {
-			nl_object_get((struct nl_object *) nt);
+			nl_object_get((struct nl_object *)nt);
 			return nt;
 		}
 	}
@@ -480,8 +477,7 @@ int rtnl_neightbl_build_change_request(struct rtnl_neightbl *old,
 		NLA_PUT_U32(m, NDTA_THRESH2, tmpl->nt_gc_thresh2);
 
 	if (tmpl->ce_mask & NEIGHTBL_ATTR_GC_INTERVAL)
-		NLA_PUT_U64(m, NDTA_GC_INTERVAL,
-				      tmpl->nt_gc_interval);
+		NLA_PUT_U64(m, NDTA_GC_INTERVAL, tmpl->nt_gc_interval);
 
 	if (tmpl->ce_mask & NEIGHTBL_ATTR_PARMS) {
 		struct rtnl_neightbl_parms *p = &tmpl->nt_parms;
@@ -492,8 +488,7 @@ int rtnl_neightbl_build_change_request(struct rtnl_neightbl *old,
 
 		if (old->nt_parms.ntp_mask & NEIGHTBLPARM_ATTR_IFINDEX)
 			NLA_PUT_U32(parms, NDTPA_IFINDEX,
-					      old->nt_parms.ntp_ifindex);
-
+				    old->nt_parms.ntp_ifindex);
 
 		if (p->ntp_mask & NEIGHTBLPARM_ATTR_QUEUE_LEN)
 			NLA_PUT_U32(parms, NDTPA_QUEUE_LEN, p->ntp_queue_len);
@@ -510,8 +505,7 @@ int rtnl_neightbl_build_change_request(struct rtnl_neightbl *old,
 				    p->ntp_mcast_probes);
 
 		if (p->ntp_mask & NEIGHTBLPARM_ATTR_PROXY_QLEN)
-			NLA_PUT_U32(parms, NDTPA_PROXY_QLEN,
-				    p->ntp_proxy_qlen);
+			NLA_PUT_U32(parms, NDTPA_PROXY_QLEN, p->ntp_proxy_qlen);
 
 		if (p->ntp_mask & NEIGHTBLPARM_ATTR_BASE_REACHABLE_TIME)
 			NLA_PUT_U64(parms, NDTPA_BASE_REACHABLE_TIME,
@@ -535,7 +529,7 @@ int rtnl_neightbl_build_change_request(struct rtnl_neightbl *old,
 
 		if (p->ntp_mask & NEIGHTBLPARM_ATTR_PROXY_DELAY)
 			NLA_PUT_U64(parms, NDTPA_PROXY_DELAY,
-					      p->ntp_proxy_delay);
+				    p->ntp_proxy_delay);
 
 		if (p->ntp_mask & NEIGHTBLPARM_ATTR_LOCKTIME)
 			NLA_PUT_U64(parms, NDTPA_LOCKTIME, p->ntp_locktime);
@@ -574,7 +568,7 @@ int rtnl_neightbl_change(struct nl_sock *sk, struct rtnl_neightbl *old,
 {
 	struct nl_msg *msg;
 	int err;
-	
+
 	if ((err = rtnl_neightbl_build_change_request(old, tmpl, &msg)) < 0)
 		return err;
 
diff --git a/lib/route/nexthop_encap.c b/lib/route/nexthop_encap.c
index 94bcb60f..2382886a 100644
--- a/lib/route/nexthop_encap.c
+++ b/lib/route/nexthop_encap.c
@@ -31,10 +31,13 @@ static const char *nh_encap_type2str(unsigned int type)
 
 void nh_encap_dump(struct rtnl_nh_encap *rtnh_encap, struct nl_dump_params *dp)
 {
+	if (!rtnh_encap->ops)
+		return;
+
 	nl_dump(dp, " encap %s ",
 		nh_encap_type2str(rtnh_encap->ops->encap_type));
 
-	if (rtnh_encap->ops && rtnh_encap->ops->dump)
+	if (rtnh_encap->ops->dump)
 		rtnh_encap->ops->dump(rtnh_encap->priv, dp);
 }
 
diff --git a/lib/route/pktloc.c b/lib/route/pktloc.c
index 8db427ed..599e5930 100644
--- a/lib/route/pktloc.c
+++ b/lib/route/pktloc.c
@@ -117,7 +117,7 @@ static int read_pktlocs(void)
 		nl_init_list_head(&pktloc_name_ht[i]);
 	}
 
-	if ((err = pktloc_lex_init(&scanner)) < 0) {
+	if (pktloc_lex_init(&scanner) < 0) {
 		err = -NLE_FAILURE;
 		goto errout_close;
 	}
diff --git a/lib/route/qdisc/mqprio.c b/lib/route/qdisc/mqprio.c
index b07da786..c1654041 100644
--- a/lib/route/qdisc/mqprio.c
+++ b/lib/route/qdisc/mqprio.c
@@ -265,14 +265,15 @@ int rtnl_qdisc_mqprio_set_priomap(struct rtnl_qdisc *qdisc, uint8_t priomap[],
 	if (!(mqprio->qm_mask & SCH_MQPRIO_ATTR_NUMTC))
 		return -NLE_MISSING_ATTR;
 
-	if ((len / sizeof(uint8_t)) > (TC_QOPT_BITMASK+1))
+	if (len > TC_QOPT_BITMASK + 1)
 		return -NLE_RANGE;
 
-	for (i = 0; i <= TC_QOPT_BITMASK; i++) {
+	for (i = 0; i < len; i++) {
 		if (priomap[i] > mqprio->qm_num_tc)
 			return -NLE_RANGE;
 	}
 
+	memset(mqprio->qm_prio_map, 0, sizeof(mqprio->qm_prio_map));
 	memcpy(mqprio->qm_prio_map, priomap, len * sizeof(uint8_t));
 	mqprio->qm_mask |= SCH_MQPRIO_ATTR_PRIOMAP;
 
@@ -360,9 +361,11 @@ int rtnl_qdisc_mqprio_set_queue(struct rtnl_qdisc *qdisc, uint16_t count[],
 	if (!(mqprio->qm_mask & SCH_MQPRIO_ATTR_NUMTC))
 		return -NLE_MISSING_ATTR;
 
-	if ((len / sizeof(uint16_t)) > TC_QOPT_MAX_QUEUE)
+	if (len < 0 || len > TC_QOPT_MAX_QUEUE)
 		return -NLE_RANGE;
 
+	memset(mqprio->qm_count, 0, sizeof(mqprio->qm_count));
+	memset(mqprio->qm_offset, 0, sizeof(mqprio->qm_offset));
 	memcpy(mqprio->qm_count, count, len * sizeof(uint16_t));
 	memcpy(mqprio->qm_offset, offset, len * sizeof(uint16_t));
 	mqprio->qm_mask |= SCH_MQPRIO_ATTR_QUEUE;
@@ -493,9 +496,10 @@ int rtnl_qdisc_mqprio_set_min_rate(struct rtnl_qdisc *qdisc, uint64_t min[], int
 	if (mqprio->qm_shaper != TC_MQPRIO_SHAPER_BW_RATE)
 		return -NLE_INVAL;
 
-	if ((len / sizeof(uint64_t)) > TC_QOPT_MAX_QUEUE)
+	if (len < 0 || len > TC_QOPT_MAX_QUEUE)
 		return -NLE_RANGE;
 
+	memset(mqprio->qm_min_rate, 0, sizeof(mqprio->qm_min_rate));
 	memcpy(mqprio->qm_min_rate, min, len * sizeof(uint64_t));
 	mqprio->qm_mask |= SCH_MQPRIO_ATTR_MIN_RATE;
 
@@ -542,9 +546,10 @@ int rtnl_qdisc_mqprio_set_max_rate(struct rtnl_qdisc *qdisc, uint64_t max[], int
 	if (mqprio->qm_shaper != TC_MQPRIO_SHAPER_BW_RATE)
 		return -NLE_INVAL;
 
-	if ((len / sizeof(uint64_t)) > TC_QOPT_MAX_QUEUE)
+	if (len < 0 || len > TC_QOPT_MAX_QUEUE)
 		return -NLE_RANGE;
 
+	memset(mqprio->qm_max_rate, 0, sizeof(mqprio->qm_max_rate));
 	memcpy(mqprio->qm_max_rate, max, len * sizeof(uint64_t));
 	mqprio->qm_mask |= SCH_MQPRIO_ATTR_MAX_RATE;
 
diff --git a/lib/route/qdisc/netem.c b/lib/route/qdisc/netem.c
index 50122b81..0ca1d571 100644
--- a/lib/route/qdisc/netem.c
+++ b/lib/route/qdisc/netem.c
@@ -161,39 +161,39 @@ static void netem_dump_details(struct rtnl_tc *tc, void *data,
 				nl_dump(p, " jitter %s", buf);
 
 				if (netem->qnm_mask & SCH_NETEM_ATTR_DELAY_CORR && netem->qnm_corr.nmc_delay > 0)
-					nl_dump(p, " %d%", netem->qnm_corr.nmc_delay);
+					nl_dump(p, " %d", netem->qnm_corr.nmc_delay);
 			}
 		}
 
 		if (netem->qnm_mask & SCH_NETEM_ATTR_LOSS && netem->qnm_loss > 0) {
-			nl_dump(p, " loss %d%", netem->qnm_loss);
+			nl_dump(p, " loss %d", netem->qnm_loss);
 
 			if (netem->qnm_mask & SCH_NETEM_ATTR_LOSS_CORR && netem->qnm_corr.nmc_loss > 0)
-				nl_dump(p, " %d%", netem->qnm_corr.nmc_loss);
+				nl_dump(p, " %d", netem->qnm_corr.nmc_loss);
 		}
 
 		if (netem->qnm_mask & SCH_NETEM_ATTR_DUPLICATE && netem->qnm_duplicate > 0) {
-			nl_dump(p, " duplicate %d%", netem->qnm_duplicate);
+			nl_dump(p, " duplicate %d", netem->qnm_duplicate);
 
 			if (netem->qnm_mask & SCH_NETEM_ATTR_DUP_CORR && netem->qnm_corr.nmc_duplicate > 0)
-				nl_dump(p, " %d%", netem->qnm_corr.nmc_duplicate);
+				nl_dump(p, " %d", netem->qnm_corr.nmc_duplicate);
 		}
 
 		if (netem->qnm_mask & SCH_NETEM_ATTR_RO_PROB && netem->qnm_ro.nmro_probability > 0) {
-			nl_dump(p, " reorder %d%", netem->qnm_ro.nmro_probability);
+			nl_dump(p, " reorder %d", netem->qnm_ro.nmro_probability);
 
 			if (netem->qnm_mask & SCH_NETEM_ATTR_RO_CORR && netem->qnm_ro.nmro_correlation > 0)
-				nl_dump(p, " %d%", netem->qnm_ro.nmro_correlation);
+				nl_dump(p, " %d", netem->qnm_ro.nmro_correlation);
 
 			if (netem->qnm_mask & SCH_NETEM_ATTR_GAP && netem->qnm_gap > 0)
 				nl_dump(p, " gap %d", netem->qnm_gap);
 		}
 
 		if (netem->qnm_mask & SCH_NETEM_ATTR_CORRUPT_PROB && netem->qnm_crpt.nmcr_probability > 0) {
-			nl_dump(p, " reorder %d%", netem->qnm_crpt.nmcr_probability);
+			nl_dump(p, " reorder %d", netem->qnm_crpt.nmcr_probability);
 
 			if (netem->qnm_mask & SCH_NETEM_ATTR_CORRUPT_CORR && netem->qnm_crpt.nmcr_correlation > 0)
-				nl_dump(p, " %d%", netem->qnm_crpt.nmcr_correlation);
+				nl_dump(p, " %d", netem->qnm_crpt.nmcr_correlation);
 		}
 	}
 }
diff --git a/lib/route/qdisc/tbf.c b/lib/route/qdisc/tbf.c
index a60399c7..ba8e304e 100644
--- a/lib/route/qdisc/tbf.c
+++ b/lib/route/qdisc/tbf.c
@@ -115,9 +115,9 @@ static void tbf_dump_details(struct rtnl_tc *tc, void *data,
 		cl = nl_cancel_down_bits(1 << tbf->qt_peakrate.rs_cell_log,
 					 &clu);
 
-		nl_dump_line(p, "    peak-rate %.2f%s/s (%.0f%s) "
-				"bucket-size %.1f%s cell-size %.1f%s"
-				"latency %.1f%s",
+		nl_dump_line(p,
+			     "    peak-rate %.2f%s/s (%.0f%s) "
+			     "bucket-size %.1f%s cell-size %.1f%s",
 			     pr, pru, prb, prbu, bs, bsu, cl, clu);
 	}
 }
diff --git a/lib/route/tc.c b/lib/route/tc.c
index fb895110..a06a4789 100644
--- a/lib/route/tc.c
+++ b/lib/route/tc.c
@@ -949,22 +949,19 @@ void rtnl_tc_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
 
 	res = nl_cancel_down_bytes(tc->tc_stats[RTNL_TC_BYTES], &unit);
 
-	nl_dump_line(p,
-	             "       %10.2f %3s   %10u   %-10u %-10u %-10u %-10u\n",
-	             res, unit,
-	             tc->tc_stats[RTNL_TC_PACKETS],
-	             tc->tc_stats[RTNL_TC_DROPS],
-	             tc->tc_stats[RTNL_TC_OVERLIMITS],
-	             tc->tc_stats[RTNL_TC_QLEN],
-	             tc->tc_stats[RTNL_TC_BACKLOG]);
+	nl_dump_line(
+		p,
+		"       %10.2f %3s   %10llu   %-10llu %-10llu %-10llu %-10llu\n",
+		res, unit, (long long unsigned)tc->tc_stats[RTNL_TC_PACKETS],
+		(long long unsigned)tc->tc_stats[RTNL_TC_DROPS],
+		(long long unsigned)tc->tc_stats[RTNL_TC_OVERLIMITS],
+		(long long unsigned)tc->tc_stats[RTNL_TC_QLEN],
+		(long long unsigned)tc->tc_stats[RTNL_TC_BACKLOG]);
 
 	res = nl_cancel_down_bytes(tc->tc_stats[RTNL_TC_RATE_BPS], &unit);
 
-	nl_dump_line(p,
-	             "       %10.2f %3s/s %10u/s\n",
-	             res,
-	             unit,
-	             tc->tc_stats[RTNL_TC_RATE_PPS]);
+	nl_dump_line(p, "       %10.2f %3s/s %10llu/s\n", res, unit,
+		     (long long unsigned)tc->tc_stats[RTNL_TC_RATE_PPS]);
 }
 
 uint64_t rtnl_tc_compare(struct nl_object *aobj, struct nl_object *bobj,
diff --git a/lib/socket.c b/lib/socket.c
index 352217ef..99cd36d0 100644
--- a/lib/socket.c
+++ b/lib/socket.c
@@ -59,7 +59,8 @@ static NL_RW_LOCK(port_map_lock);
 
 static uint32_t generate_local_port(void)
 {
-	int i, j, n, m;
+	int i, j, m;
+	uint16_t n;
 	static uint16_t idx_state = 0;
 	uint32_t pid = getpid() & 0x3FFFFF;
 
@@ -91,7 +92,7 @@ static uint32_t generate_local_port(void)
 			continue;
 
 		for (m = 0; m < 32; m++) {
-			n = (n + 13) % 32;
+			n = (n + 13u) % 32u;
 			if (1UL & (used_ports_map[i] >> n))
 				continue;
 
@@ -104,7 +105,7 @@ static uint32_t generate_local_port(void)
 			nl_write_unlock(&port_map_lock);
 
 			/* ensure we don't return zero. */
-			pid = pid + (((uint32_t)n) << 22);
+			pid = pid + (n << 22);
 			return pid ? pid : 1024;
 		}
 	}
diff --git a/lib/xfrm/ae.c b/lib/xfrm/ae.c
index d76000d5..3af872f3 100644
--- a/lib/xfrm/ae.c
+++ b/lib/xfrm/ae.c
@@ -314,8 +314,9 @@ static void xfrm_ae_dump_line(struct nl_object *a, struct nl_dump_params *p)
 				ae->flags, ae->mark.m, ae->mark.v);
 
 	nl_dump_line(p, "\tlifetime current: \n");
-	nl_dump_line(p, "\t\tbytes %llu packets %llu \n", ae->lifetime_cur.bytes,
-				ae->lifetime_cur.packets);
+	nl_dump_line(p, "\t\tbytes %llu packets %llu \n",
+		     (long long unsigned)ae->lifetime_cur.bytes,
+		     (long long unsigned)ae->lifetime_cur.packets);
 	if (ae->lifetime_cur.add_time != 0)
 	{
 		add_time = ae->lifetime_cur.add_time;
@@ -381,6 +382,8 @@ static int build_xfrm_ae_message(struct xfrmnl_ae *tmpl, int cmd, int flags,
 		!(tmpl->ce_mask & XFRM_AE_ATTR_PROTO))
 		return -NLE_MISSING_ATTR;
 
+	memset(&ae_id, 0, sizeof(ae_id));
+
 	memcpy (&ae_id.sa_id.daddr, nl_addr_get_binary_addr (tmpl->sa_id.daddr), sizeof (uint8_t) * nl_addr_get_len (tmpl->sa_id.daddr));
 	ae_id.sa_id.spi    = htonl(tmpl->sa_id.spi);
 	ae_id.sa_id.family = tmpl->sa_id.family;
diff --git a/lib/xfrm/sa.c b/lib/xfrm/sa.c
index 3b657bfc..5567eb74 100644
--- a/lib/xfrm/sa.c
+++ b/lib/xfrm/sa.c
@@ -447,14 +447,23 @@ static void xfrm_sa_dump_line(struct nl_object *a, struct nl_dump_params *p)
 		sprintf (mode, "INF");
 	else
 		sprintf (mode, "%" PRIu64, sa->lft->hard_packet_limit);
-	nl_dump_line(p, "\t\thard limit: %s (bytes), %s (packets)\n", flags, mode);
-	nl_dump_line(p, "\t\tsoft add_time: %llu (seconds), soft use_time: %llu (seconds) \n",
-	             sa->lft->soft_add_expires_seconds, sa->lft->soft_use_expires_seconds);
-	nl_dump_line(p, "\t\thard add_time: %llu (seconds), hard use_time: %llu (seconds) \n",
-	             sa->lft->hard_add_expires_seconds, sa->lft->hard_use_expires_seconds);
+	nl_dump_line(p, "\t\thard limit: %s (bytes), %s (packets)\n", flags,
+		     mode);
+	nl_dump_line(
+		p,
+		"\t\tsoft add_time: %llu (seconds), soft use_time: %llu (seconds) \n",
+		(long long unsigned)sa->lft->soft_add_expires_seconds,
+		(long long unsigned)sa->lft->soft_use_expires_seconds);
+	nl_dump_line(
+		p,
+		"\t\thard add_time: %llu (seconds), hard use_time: %llu (seconds) \n",
+		(long long unsigned)sa->lft->hard_add_expires_seconds,
+		(long long unsigned)sa->lft->hard_use_expires_seconds);
 
 	nl_dump_line(p, "\tlifetime current: \n");
-	nl_dump_line(p, "\t\t%llu bytes, %llu packets\n", sa->curlft.bytes, sa->curlft.packets);
+	nl_dump_line(p, "\t\t%llu bytes, %llu packets\n",
+		     (long long unsigned)sa->curlft.bytes,
+		     (long long unsigned)sa->curlft.packets);
 	if (sa->curlft.add_time != 0)
 	{
 		add_time = sa->curlft.add_time;
diff --git a/lib/xfrm/sp.c b/lib/xfrm/sp.c
index 9cf351aa..df9e2fbe 100644
--- a/lib/xfrm/sp.c
+++ b/lib/xfrm/sp.c
@@ -361,15 +361,25 @@ static void xfrm_sp_dump_line(struct nl_object *a, struct nl_dump_params *p)
 		sprintf (share, "INF");
 	else
 		sprintf (share, "%" PRIu64, sp->lft->hard_packet_limit);
-	nl_dump_line(p, "\t\tsoft limit: %s (bytes), %s (packets) \n", dir, action);
-	nl_dump_line(p, "\t\thard limit: %s (bytes), %s (packets) \n", flags, share);
-	nl_dump_line(p, "\t\tsoft add_time: %llu (seconds), soft use_time: %llu (seconds) \n",
-	             sp->lft->soft_add_expires_seconds, sp->lft->soft_use_expires_seconds);
-	nl_dump_line(p, "\t\thard add_time: %llu (seconds), hard use_time: %llu (seconds) \n",
-	             sp->lft->hard_add_expires_seconds, sp->lft->hard_use_expires_seconds);
+	nl_dump_line(p, "\t\tsoft limit: %s (bytes), %s (packets) \n", dir,
+		     action);
+	nl_dump_line(p, "\t\thard limit: %s (bytes), %s (packets) \n", flags,
+		     share);
+	nl_dump_line(
+		p,
+		"\t\tsoft add_time: %llu (seconds), soft use_time: %llu (seconds) \n",
+		(long long unsigned)sp->lft->soft_add_expires_seconds,
+		(long long unsigned)sp->lft->soft_use_expires_seconds);
+	nl_dump_line(
+		p,
+		"\t\thard add_time: %llu (seconds), hard use_time: %llu (seconds) \n",
+		(long long unsigned)sp->lft->hard_add_expires_seconds,
+		(long long unsigned)sp->lft->hard_use_expires_seconds);
 
 	nl_dump_line(p, "\tlifetime current: \n");
-	nl_dump_line(p, "\t\t%llu bytes, %llu packets\n", sp->curlft.bytes, sp->curlft.packets);
+	nl_dump_line(p, "\t\t%llu bytes, %llu packets\n",
+		     (long long unsigned)sp->curlft.bytes,
+		     (long long unsigned)sp->curlft.packets);
 
 	if (sp->curlft.add_time != 0)
 	{
diff --git a/src/lib/utils.c b/src/lib/utils.c
index 36fb0292..cbcdafe9 100644
--- a/src/lib/utils.c
+++ b/src/lib/utils.c
@@ -229,10 +229,13 @@ void nl_cli_load_module(const char *prefix, const char *name)
 	{
 		void *handle;
 
-		if (!(handle = dlopen(path, RTLD_NOW))) {
+		handle = dlopen(path, RTLD_NOW);
+		if (!handle) {
 			nl_cli_fatal(ENOENT, "Unable to load module \"%s\": %s\n",
 			             path, dlerror());
 		}
+		/* We intentionally leak the dlopen handle. */
+		/* coverity[RESOURCE_LEAK] */
 	}
 #else
 	nl_cli_fatal(ENOTSUP, "Unable to load module \"%s\": built without dynamic libraries support\n",
diff --git a/src/nl-pktloc-lookup.c b/src/nl-pktloc-lookup.c
index f888424d..606b2db8 100644
--- a/src/nl-pktloc-lookup.c
+++ b/src/nl-pktloc-lookup.c
@@ -7,6 +7,8 @@
 #include <netlink/route/pktloc.h>
 #include <linux/tc_ematch/tc_em_cmp.h>
 
+#include "netlink-private/utils.h"
+
 static void print_usage(void)
 {
 printf(
@@ -45,8 +47,19 @@ static const char *layer_txt[] = {
 	[TCF_LAYER_TRANSPORT] = "tcp"
 };
 
+static const char *get_align_txt(struct rtnl_pktloc *loc, char buf[static 16])
+{
+	if (loc->align < _NL_N_ELEMENTS(align_txt))
+		return align_txt[loc->align];
+
+	snprintf(buf, 16, "%u", loc->align);
+	return buf;
+}
+
 static void dump_u32_style(struct rtnl_pktloc *loc, uint32_t value)
 {
+	char buf[16];
+
 	if (loc->align > 4)
 		nl_cli_fatal(EINVAL, "u32 only supports alignments u8|u16|u32.");
 
@@ -57,37 +70,35 @@ static void dump_u32_style(struct rtnl_pktloc *loc, uint32_t value)
 	if (loc->shift > 0)
 		nl_cli_fatal(EINVAL, "u32 does not support shifting.");
 
-	printf("%s %x %x at %s%u\n",
-		align_txt[loc->align],
-		value, loc->mask ? loc->mask : align_mask[loc->align],
-		loc->layer == TCF_LAYER_TRANSPORT ? "nexthdr+" : "",
-		loc->offset);
-}
-
-static char *get_align_txt(struct rtnl_pktloc *loc)
-{
-	static char buf[16];
-
-	if (loc->align <= 4)
-		strcpy(buf, align_txt[loc->align]);
-	else
-		snprintf(buf, sizeof(buf), "%u", loc->align);
-
-	return buf;
+	printf("%s %x %x at %s%u\n", get_align_txt(loc, buf), value,
+	       loc->mask ? loc->mask :
+				 (loc->align < _NL_N_ELEMENTS(align_mask) ?
+				    align_mask[loc->align] :
+					  0),
+	       loc->layer == TCF_LAYER_TRANSPORT ? "nexthdr+" : "",
+	       loc->offset);
 }
 
 static void dump_loc(struct rtnl_pktloc *loc)
 {
-	printf("%s = %s at %s+%u & %#x >> %u\n",
-		loc->name, get_align_txt(loc), layer_txt[loc->layer],
-		loc->offset, loc->mask, loc->shift);
+	char buf[16];
+
+	printf("%s = %s at %s+%u & %#x >> %u\n", loc->name,
+	       get_align_txt(loc, buf),
+	       loc->layer < _NL_N_ELEMENTS(layer_txt) ? layer_txt[loc->layer] :
+							      "???",
+	       loc->offset, loc->mask, loc->shift);
 }
 
 static void list_cb(struct rtnl_pktloc *loc, void *arg)
 {
-	printf("%-26s %-5s %3s+%-4u %#-10x %-8u %u\n",
-		loc->name, get_align_txt(loc), layer_txt[loc->layer],
-		loc->offset, loc->mask, loc->shift, loc->refcnt);
+	char buf[16];
+
+	printf("%-26s %-5s %3s+%-4u %#-10x %-8u %u\n", loc->name,
+	       get_align_txt(loc, buf),
+	       loc->layer < _NL_N_ELEMENTS(layer_txt) ? layer_txt[loc->layer] :
+							     "???",
+	       loc->offset, loc->mask, loc->shift, loc->refcnt);
 }
 
 static void do_list(void)