*: rename zlog_fer -> flog_err

Signed-off-by: Quentin Young <qlyoung@cumulusnetworks.com>

18 files changed, 85 insertions, 85 deletions

diff --git a/lib/agentx.c b/lib/agentx.c
index 80422c4805..8e6493d4d3 100644
--- a/lib/agentx.c
+++ b/lib/agentx.c
@@ -142,19 +142,19 @@ static int agentx_log_callback(int major, int minor, void *serverarg,
 		msg[strlen(msg) - 1] = '\0';
 	switch (slm->priority) {
 	case LOG_EMERG:
-		zlog_ferr(LIB_ERR_SNMP,
+		flog_err(LIB_ERR_SNMP,
 			  "snmp[emerg]: %s", msg ? msg : slm->msg);
 		break;
 	case LOG_ALERT:
-		zlog_ferr(LIB_ERR_SNMP,
+		flog_err(LIB_ERR_SNMP,
 			  "snmp[alert]: %s", msg ? msg : slm->msg);
 		break;
 	case LOG_CRIT:
-		zlog_ferr(LIB_ERR_SNMP,
+		flog_err(LIB_ERR_SNMP,
 			  "snmp[crit]: %s", msg ? msg : slm->msg);
 		break;
 	case LOG_ERR:
-		zlog_ferr(LIB_ERR_SNMP,
+		flog_err(LIB_ERR_SNMP,
 			  "snmp[err]: %s", msg ? msg : slm->msg);
 		break;
 	case LOG_WARNING:
diff --git a/lib/buffer.c b/lib/buffer.c
index acdaf07bbc..c292e43419 100644
--- a/lib/buffer.c
+++ b/lib/buffer.c
@@ -343,7 +343,7 @@ buffer_status_t buffer_flush_window(struct buffer *b, int fd, int width,
 					       iov_alloc * sizeof(*iov));
 			} else {
 				/* This should absolutely never occur. */
-				zlog_ferr(LIB_ERR_SYSTEM_CALL,
+				flog_err(LIB_ERR_SYSTEM_CALL,
 					  "%s: corruption detected: iov_small overflowed; "
 					  "head %p, tail %p, head->next %p",
 					  __func__, (void *)b->head,
@@ -458,7 +458,7 @@ in one shot. */
 	while (written > 0) {
 		struct buffer_data *d;
 		if (!(d = b->head)) {
-			zlog_ferr(
+			flog_err(
 				LIB_ERR_DEVELOPMENT,
 				"%s: corruption detected: buffer queue empty, but written is %lu",
 				__func__, (unsigned long)written);
diff --git a/lib/command.c b/lib/command.c
index ca916c6043..5e15892805 100644
--- a/lib/command.c
+++ b/lib/command.c
@@ -2417,7 +2417,7 @@ static int set_log_file(struct vty *vty, const char *fname, int loglevel)
 		cwd[MAXPATHLEN] = '\0';
 
 		if (getcwd(cwd, MAXPATHLEN) == NULL) {
-			zlog_ferr(LIB_ERR_SYSTEM_CALL,
+			flog_err(LIB_ERR_SYSTEM_CALL,
 				  "config_log_file: Unable to alloc mem!");
 			return CMD_WARNING_CONFIG_FAILED;
 		}
diff --git a/lib/frr_zmq.c b/lib/frr_zmq.c
index c479543ce4..02d9b68bc1 100644
--- a/lib/frr_zmq.c
+++ b/lib/frr_zmq.c
@@ -141,7 +141,7 @@ static int frrzmq_read_msg(struct thread *t)
 	return 0;
 
 out_err:
-	zlog_ferr(LIB_ERR_ZMQ, "ZeroMQ read error: %s(%d)", strerror(errno),
+	flog_err(LIB_ERR_ZMQ, "ZeroMQ read error: %s(%d)", strerror(errno),
 		  errno);
 	if (cb->read.cb_error)
 		cb->read.cb_error(cb->read.arg, cb->zmqsock);
@@ -255,7 +255,7 @@ static int frrzmq_write_msg(struct thread *t)
 	return 0;
 
 out_err:
-	zlog_ferr(LIB_ERR_ZMQ, "ZeroMQ write error: %s(%d)", strerror(errno),
+	flog_err(LIB_ERR_ZMQ, "ZeroMQ write error: %s(%d)", strerror(errno),
 		  errno);
 	if (cb->write.cb_error)
 		cb->write.cb_error(cb->write.arg, cb->zmqsock);
diff --git a/lib/if.h b/lib/if.h
index 4379e1ad8c..3a9c4af848 100644
--- a/lib/if.h
+++ b/lib/if.h
@@ -297,7 +297,7 @@ DECLARE_QOBJ_TYPE(interface)
 
 #define IFNAME_RB_INSERT(vrf, ifp)                                             \
 	if (RB_INSERT(if_name_head, &vrf->ifaces_by_name, (ifp)))              \
-		zlog_ferr(                                                     \
+		flog_err(                                                     \
 			LIB_ERR_INTERFACE,                                     \
 			"%s(%s): corruption detected -- interface with this "  \
 			"name exists already in VRF %u!",                      \
@@ -305,7 +305,7 @@ DECLARE_QOBJ_TYPE(interface)
 
 #define IFNAME_RB_REMOVE(vrf, ifp)                                             \
 	if (RB_REMOVE(if_name_head, &vrf->ifaces_by_name, (ifp)) == NULL)      \
-		zlog_ferr(                                                     \
+		flog_err(                                                     \
 			LIB_ERR_INTERFACE,                                     \
 			"%s(%s): corruption detected -- interface with this "  \
 			"name doesn't exist in VRF %u!",                       \
@@ -313,7 +313,7 @@ DECLARE_QOBJ_TYPE(interface)
 
 #define IFINDEX_RB_INSERT(vrf, ifp)                                            \
 	if (RB_INSERT(if_index_head, &vrf->ifaces_by_index, (ifp)))            \
-		zlog_ferr(                                                     \
+		flog_err(                                                     \
 			LIB_ERR_INTERFACE,                                     \
 			"%s(%u): corruption detected -- interface with this "  \
 			"ifindex exists already in VRF %u!",                   \
@@ -321,7 +321,7 @@ DECLARE_QOBJ_TYPE(interface)
 
 #define IFINDEX_RB_REMOVE(vrf, ifp)                                            \
 	if (RB_REMOVE(if_index_head, &vrf->ifaces_by_index, (ifp)) == NULL)    \
-		zlog_ferr(                                                     \
+		flog_err(                                                     \
 			LIB_ERR_INTERFACE,                                     \
 			"%s(%u): corruption detected -- interface with this "  \
 			"ifindex doesn't exist in VRF %u!",                    \
diff --git a/lib/libfrr.c b/lib/libfrr.c
index d9e51f67ca..a49372675a 100644
--- a/lib/libfrr.c
+++ b/lib/libfrr.c
@@ -829,7 +829,7 @@ static void frr_terminal_close(int isexit)
 
 	nullfd = open("/dev/null", O_RDONLY | O_NOCTTY);
 	if (nullfd == -1) {
-		zlog_ferr(LIB_ERR_SYSTEM_CALL,
+		flog_err(LIB_ERR_SYSTEM_CALL,
 			  "%s: failed to open /dev/null: %s", __func__,
 			  safe_strerror(errno));
 	} else {
@@ -902,7 +902,7 @@ void frr_run(struct thread_master *master)
 	} else if (di->daemon_mode) {
 		int nullfd = open("/dev/null", O_RDONLY | O_NOCTTY);
 		if (nullfd == -1) {
-			zlog_ferr(LIB_ERR_SYSTEM_CALL,
+			flog_err(LIB_ERR_SYSTEM_CALL,
 				  "%s: failed to open /dev/null: %s", __func__,
 				  safe_strerror(errno));
 		} else {
diff --git a/lib/log.c b/lib/log.c
index 6aa718c953..ceff7b5f65 100644
--- a/lib/log.c
+++ b/lib/log.c
@@ -633,7 +633,7 @@ void zlog_backtrace(int priority)
 
 	size = backtrace(array, array_size(array));
 	if (size <= 0 || (size_t)size > array_size(array)) {
-		zlog_ferr(LIB_ERR_SYSTEM_CALL,
+		flog_err(LIB_ERR_SYSTEM_CALL,
 			  "Cannot get backtrace, returned invalid # of frames %d "
 			  "(valid range is between 1 and %lu)",
 			  size, (unsigned long)(array_size(array)));
@@ -641,7 +641,7 @@ void zlog_backtrace(int priority)
 	}
 	zlog(priority, "Backtrace for %d stack frames:", size);
 	if (!(strings = backtrace_symbols(array, size))) {
-		zlog_ferr(LIB_ERR_SYSTEM_CALL,
+		flog_err(LIB_ERR_SYSTEM_CALL,
 			  "Cannot get backtrace symbols (out of memory?)");
 		for (i = 0; i < size; i++)
 			zlog(priority, "[bt %d] %p", i, array[i]);
@@ -715,7 +715,7 @@ void _zlog_assert_failed(const char *assertion, const char *file,
 
 void memory_oom(size_t size, const char *name)
 {
-	zlog_ferr(LIB_ERR_SYSTEM_CALL,
+	flog_err(LIB_ERR_SYSTEM_CALL,
 		  "out of memory: failed to allocate %zu bytes for %s"
 		  "object",
 		  size, name);
@@ -867,7 +867,7 @@ int zlog_rotate(void)
 		save_errno = errno;
 		umask(oldumask);
 		if (zl->fp == NULL) {
-			zlog_ferr(LIB_ERR_SYSTEM_CALL,
+			flog_err(LIB_ERR_SYSTEM_CALL,
 				  "Log rotate failed: cannot open file %s for append: %s",
 				  zl->filename, safe_strerror(save_errno));
 			ret = -1;
@@ -987,7 +987,7 @@ static const struct zebra_desc_table *zroute_lookup(unsigned int zroute)
 	unsigned int i;
 
 	if (zroute >= array_size(route_types)) {
-		zlog_ferr(LIB_ERR_DEVELOPMENT, "unknown zebra route type: %u",
+		flog_err(LIB_ERR_DEVELOPMENT, "unknown zebra route type: %u",
 			  zroute);
 		return &unknown;
 	}
@@ -1002,7 +1002,7 @@ static const struct zebra_desc_table *zroute_lookup(unsigned int zroute)
 			return &route_types[i];
 		}
 	}
-	zlog_ferr(LIB_ERR_DEVELOPMENT,
+	flog_err(LIB_ERR_DEVELOPMENT,
 		  "internal error: cannot find route type %u in table!",
 		  zroute);
 	return &unknown;
@@ -1021,7 +1021,7 @@ char zebra_route_char(unsigned int zroute)
 const char *zserv_command_string(unsigned int command)
 {
 	if (command >= array_size(command_types)) {
-		zlog_ferr(LIB_ERR_DEVELOPMENT, "unknown zserv command type: %u",
+		flog_err(LIB_ERR_DEVELOPMENT, "unknown zserv command type: %u",
 			  command);
 		return unknown.string;
 	}
diff --git a/lib/log.h b/lib/log.h
index a2546298a8..a7d39b264f 100644
--- a/lib/log.h
+++ b/lib/log.h
@@ -86,7 +86,7 @@ extern void zlog_notice(const char *format, ...) PRINTF_ATTRIBUTE(1, 2);
 extern void zlog_debug(const char *format, ...) PRINTF_ATTRIBUTE(1, 2);
 
 /* For logs which have error codes associated with them */
-#define zlog_ferr(ferr_id, format, ...)                                        \
+#define flog_err(ferr_id, format, ...)                                        \
 	zlog_err("[EC %d] " format, ferr_id, ##__VA_ARGS__)
 
 
diff --git a/lib/netns_linux.c b/lib/netns_linux.c
index 3a24e511ae..61ae450086 100644
--- a/lib/netns_linux.c
+++ b/lib/netns_linux.c
@@ -219,7 +219,7 @@ static int ns_enable_internal(struct ns *ns, void (*func)(ns_id_t, void *))
 		}
 
 		if (!ns_is_enabled(ns)) {
-			zlog_ferr(LIB_ERR_SYSTEM_CALL,
+			flog_err(LIB_ERR_SYSTEM_CALL,
 				  "Can not enable NS %u: %s!", ns->ns_id,
 				  safe_strerror(errno));
 			return 0;
@@ -227,7 +227,7 @@ static int ns_enable_internal(struct ns *ns, void (*func)(ns_id_t, void *))
 
 		/* Non default NS. leave */
 		if (ns->ns_id == NS_UNKNOWN) {
-			zlog_ferr(LIB_ERR_NS,
+			flog_err(LIB_ERR_NS,
 				  "Can not enable NS %s %u: Invalid NSID",
 				  ns->name, ns->ns_id);
 			return 0;
@@ -472,7 +472,7 @@ void ns_init(void)
 	if (have_netns_enabled < 0) {
 		ns_default_ns_fd = open(NS_DEFAULT_NAME, O_RDONLY);
 		if (ns_default_ns_fd == -1)
-			zlog_ferr(LIB_ERR_NS,
+			flog_err(LIB_ERR_NS,
 				  "NS initialization failure %d(%s)", errno,
 				  safe_strerror(errno));
 	} else {
@@ -495,7 +495,7 @@ void ns_init_management(ns_id_t default_ns_id, ns_id_t internal_ns)
 	ns_init();
 	default_ns = ns_get_created_internal(NULL, NULL, default_ns_id);
 	if (!default_ns) {
-		zlog_ferr(LIB_ERR_NS, "%s: failed to create the default NS!",
+		flog_err(LIB_ERR_NS, "%s: failed to create the default NS!",
 			  __func__);
 		exit(1);
 	}
@@ -513,7 +513,7 @@ void ns_init_management(ns_id_t default_ns_id, ns_id_t internal_ns)
 
 	/* Enable the default NS. */
 	if (!ns_enable(default_ns, NULL)) {
-		zlog_ferr(LIB_ERR_NS, "%s: failed to enable the default NS!",
+		flog_err(LIB_ERR_NS, "%s: failed to enable the default NS!",
 			  __func__);
 		exit(1);
 	}
diff --git a/lib/pid_output.c b/lib/pid_output.c
index 21687e48c4..5132e2f122 100644
--- a/lib/pid_output.c
+++ b/lib/pid_output.c
@@ -42,7 +42,7 @@ pid_t pid_output(const char *path)
 	oldumask = umask(0777 & ~PIDFILE_MASK);
 	fd = open(path, O_RDWR | O_CREAT, PIDFILE_MASK);
 	if (fd < 0) {
-		zlog_ferr(LIB_ERR_SYSTEM_CALL,
+		flog_err(LIB_ERR_SYSTEM_CALL,
 			  "Can't create pid lock file %s (%s), exiting", path,
 			  safe_strerror(errno));
 		umask(oldumask);
@@ -59,7 +59,7 @@ pid_t pid_output(const char *path)
 		lock.l_whence = SEEK_SET;
 
 		if (fcntl(fd, F_SETLK, &lock) < 0) {
-			zlog_ferr(LIB_ERR_SYSTEM_CALL,
+			flog_err(LIB_ERR_SYSTEM_CALL,
 				  "Could not lock pid_file %s (%s), exiting",
 				  path, safe_strerror(errno));
 			exit(1);
@@ -68,11 +68,11 @@ pid_t pid_output(const char *path)
 		sprintf(buf, "%d\n", (int)pid);
 		pidsize = strlen(buf);
 		if ((tmp = write(fd, buf, pidsize)) != (int)pidsize)
-			zlog_ferr(LIB_ERR_SYSTEM_CALL,
+			flog_err(LIB_ERR_SYSTEM_CALL,
 				  "Could not write pid %d to pid_file %s, rc was %d: %s",
 				  (int)pid, path, tmp, safe_strerror(errno));
 		else if (ftruncate(fd, pidsize) < 0)
-			zlog_ferr(LIB_ERR_SYSTEM_CALL,
+			flog_err(LIB_ERR_SYSTEM_CALL,
 				  "Could not truncate pid_file %s to %u bytes: %s",
 				  path, (unsigned int)pidsize,
 				  safe_strerror(errno));
diff --git a/lib/prefix.c b/lib/prefix.c
index fe4f360fb2..a7f4fda1b2 100644
--- a/lib/prefix.c
+++ b/lib/prefix.c
@@ -657,7 +657,7 @@ void prefix_copy(struct prefix *dest, const struct prefix *src)
 		memcpy((void *)dest->u.prefix_flowspec.ptr,
 		       (void *)src->u.prefix_flowspec.ptr, len);
 	} else {
-		zlog_ferr(LIB_ERR_DEVELOPMENT,
+		flog_err(LIB_ERR_DEVELOPMENT,
 			  "prefix_copy(): Unknown address family %d",
 			  src->family);
 		assert(0);
diff --git a/lib/sigevent.c b/lib/sigevent.c
index c6a8fcbd12..be904e982b 100644
--- a/lib/sigevent.c
+++ b/lib/sigevent.c
@@ -84,7 +84,7 @@ int quagga_sigevent_process(void)
 	sigdelset(&newmask, SIGKILL);
 
 	if ((sigprocmask(SIG_BLOCK, &newmask, &oldmask)) < 0) {
-		zlog_ferr(LIB_ERR_SYSTEM_CALL,
+		flog_err(LIB_ERR_SYSTEM_CALL,
 			  "quagga_signal_timer: couldnt block signals!");
 		return -1;
 	}
diff --git a/lib/skiplist.c b/lib/skiplist.c
index d2b3acc971..a36bf47139 100644
--- a/lib/skiplist.c
+++ b/lib/skiplist.c
@@ -183,7 +183,7 @@ int skiplist_insert(register struct skiplist *l, register void *key,
 
 	/* DEBUG */
 	if (!key) {
-		zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: key is 0, value is %p",
+		flog_err(LIB_ERR_DEVELOPMENT, "%s: key is 0, value is %p",
 			  __func__, value);
 	}
 
diff --git a/lib/sockopt.c b/lib/sockopt.c
index 1e45f20aad..c19e84d128 100644
--- a/lib/sockopt.c
+++ b/lib/sockopt.c
@@ -62,7 +62,7 @@ int getsockopt_so_sendbuf(const int sock)
 	int ret = getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *)&optval,
 			     &optlen);
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_SYSTEM_CALL,
+		flog_err(LIB_ERR_SYSTEM_CALL,
 			  "fd %d: can't getsockopt SO_SNDBUF: %d (%s)", sock,
 			  errno, safe_strerror(errno));
 		return ret;
@@ -672,7 +672,7 @@ int sockopt_tcp_signature(int sock, union sockunion *su, const char *password)
 		if (ENOENT == errno)
 			ret = 0;
 		else
-			zlog_ferr(LIB_ERR_SYSTEM_CALL,
+			flog_err(LIB_ERR_SYSTEM_CALL,
 				  "sockopt_tcp_signature: setsockopt(%d): %s",
 				  sock, safe_strerror(errno));
 	}
diff --git a/lib/sockunion.c b/lib/sockunion.c
index edd6b84c5f..60597b5881 100644
--- a/lib/sockunion.c
+++ b/lib/sockunion.c
@@ -367,13 +367,13 @@ int sockopt_mark_default(int sock, int mark, struct zebra_privs_t *cap)
 	int ret;
 
 	if (cap->change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES,
+		flog_err(LIB_ERR_PRIVILEGES,
 			  "routing_socket: Can't raise privileges");
 
 	ret = setsockopt(sock, SOL_SOCKET, SO_MARK, &mark, sizeof(mark));
 
 	if (cap->change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES,
+		flog_err(LIB_ERR_PRIVILEGES,
 			  "routing_socket: Can't lower privileges");
 
 	return ret;
diff --git a/lib/vrf.c b/lib/vrf.c
index 52a894cb20..8744f6335b 100644
--- a/lib/vrf.c
+++ b/lib/vrf.c
@@ -467,14 +467,14 @@ void vrf_init(int (*create)(struct vrf *), int (*enable)(struct vrf *),
 	/* The default VRF always exists. */
 	default_vrf = vrf_get(VRF_DEFAULT, VRF_DEFAULT_NAME);
 	if (!default_vrf) {
-		zlog_ferr(LIB_ERR_VRF_START,
+		flog_err(LIB_ERR_VRF_START,
 			  "vrf_init: failed to create the default VRF!");
 		exit(1);
 	}
 
 	/* Enable the default VRF. */
 	if (!vrf_enable(default_vrf)) {
-		zlog_ferr(LIB_ERR_VRF_START,
+		flog_err(LIB_ERR_VRF_START,
 			  "vrf_init: failed to enable the default VRF!");
 		exit(1);
 	}
@@ -545,7 +545,7 @@ int vrf_socket(int domain, int type, int protocol, vrf_id_t vrf_id,
 
 	ret = vrf_switch_to_netns(vrf_id);
 	if (ret < 0)
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "%s: Can't switch to VRF %u (%s)", __func__, vrf_id,
 			  safe_strerror(errno));
 
@@ -560,7 +560,7 @@ int vrf_socket(int domain, int type, int protocol, vrf_id_t vrf_id,
 	save_errno = errno;
 	ret2 = vrf_switchback_to_initial();
 	if (ret2 < 0)
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "%s: Can't switchback from VRF %u (%s)", __func__,
 			  vrf_id, safe_strerror(errno));
 	errno = save_errno;
@@ -766,14 +766,14 @@ DEFUN_NOSH (vrf_netns,
 		return CMD_WARNING_CONFIG_FAILED;
 
 	if (vrf_daemon_privs && vrf_daemon_privs->change(ZPRIVS_RAISE))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "%s: Can't raise privileges",
+		flog_err(LIB_ERR_PRIVILEGES, "%s: Can't raise privileges",
 			  __func__);
 
 	ret = vrf_netns_handler_create(vty, vrf, pathname,
 				       NS_UNKNOWN, NS_UNKNOWN);
 
 	if (vrf_daemon_privs && vrf_daemon_privs->change(ZPRIVS_LOWER))
-		zlog_ferr(LIB_ERR_PRIVILEGES, "%s: Can't lower privileges",
+		flog_err(LIB_ERR_PRIVILEGES, "%s: Can't lower privileges",
 			  __func__);
 	return ret;
 }
@@ -912,14 +912,14 @@ int vrf_getaddrinfo(const char *node, const char *service,
 
 	ret = vrf_switch_to_netns(vrf_id);
 	if (ret < 0)
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "%s: Can't switch to VRF %u (%s)", __func__, vrf_id,
 			  safe_strerror(errno));
 	ret = getaddrinfo(node, service, hints, res);
 	save_errno = errno;
 	ret2 = vrf_switchback_to_initial();
 	if (ret2 < 0)
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "%s: Can't switchback from VRF %u (%s)", __func__,
 			  vrf_id, safe_strerror(errno));
 	errno = save_errno;
@@ -932,7 +932,7 @@ int vrf_ioctl(vrf_id_t vrf_id, int d, unsigned long request, char *params)
 
 	ret = vrf_switch_to_netns(vrf_id);
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "%s: Can't switch to VRF %u (%s)", __func__, vrf_id,
 			  safe_strerror(errno));
 		return 0;
@@ -941,7 +941,7 @@ int vrf_ioctl(vrf_id_t vrf_id, int d, unsigned long request, char *params)
 	saved_errno = errno;
 	ret = vrf_switchback_to_initial();
 	if (ret < 0)
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "%s: Can't switchback from VRF %u (%s)", __func__,
 			  vrf_id, safe_strerror(errno));
 	errno = saved_errno;
@@ -955,14 +955,14 @@ int vrf_sockunion_socket(const union sockunion *su, vrf_id_t vrf_id,
 
 	ret = vrf_switch_to_netns(vrf_id);
 	if (ret < 0)
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "%s: Can't switch to VRF %u (%s)", __func__, vrf_id,
 			  safe_strerror(errno));
 	ret = sockunion_socket(su);
 	save_errno = errno;
 	ret2 = vrf_switchback_to_initial();
 	if (ret2 < 0)
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "%s: Can't switchback from VRF %u (%s)", __func__,
 			  vrf_id, safe_strerror(errno));
 	errno = save_errno;
diff --git a/lib/vty.c b/lib/vty.c
index 30db2d0930..df425aaef5 100644
--- a/lib/vty.c
+++ b/lib/vty.c
@@ -1330,7 +1330,7 @@ static int vty_telnet_option(struct vty *vty, unsigned char *buf, int nbytes)
 					TELNET_NAWS_SB_LEN,
 					(unsigned long)vty->sb_len);
 			else if (sizeof(vty->sb_buf) < TELNET_NAWS_SB_LEN)
-				zlog_ferr(
+				flog_err(
 					LIB_ERR_DEVELOPMENT,
 					"Bug detected: sizeof(vty->sb_buf) %lu < %d, too small to handle the telnet NAWS option",
 					(unsigned long)sizeof(vty->sb_buf),
@@ -1973,7 +1973,7 @@ static void vty_serv_sock_addrinfo(const char *hostname, unsigned short port)
 	ret = getaddrinfo(hostname, port_str, &req, &ainfo);
 
 	if (ret != 0) {
-		zlog_ferr(LIB_ERR_SYSTEM_CALL,
+		flog_err(LIB_ERR_SYSTEM_CALL,
 			  "getaddrinfo failed: %s", gai_strerror(ret));
 		exit(1);
 	}
@@ -2034,7 +2034,7 @@ static void vty_serv_un(const char *path)
 	/* Make UNIX domain socket. */
 	sock = socket(AF_UNIX, SOCK_STREAM, 0);
 	if (sock < 0) {
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "Cannot create unix stream socket: %s",
 			 safe_strerror(errno));
 		return;
@@ -2054,7 +2054,7 @@ static void vty_serv_un(const char *path)
 
 	ret = bind(sock, (struct sockaddr *)&serv, len);
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "Cannot bind path %s: %s",
 			  path, safe_strerror(errno));
 		close(sock); /* Avoid sd leak. */
@@ -2063,7 +2063,7 @@ static void vty_serv_un(const char *path)
 
 	ret = listen(sock, 5);
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_SOCKET,
+		flog_err(LIB_ERR_SOCKET,
 			  "listen(fd %d) failed: %s", sock,
 			  safe_strerror(errno));
 		close(sock); /* Avoid sd leak. */
@@ -2080,7 +2080,7 @@ static void vty_serv_un(const char *path)
 	if ((int)ids.gid_vty > 0) {
 		/* set group of socket */
 		if (chown(path, -1, ids.gid_vty)) {
-			zlog_ferr(LIB_ERR_SYSTEM_CALL,
+			flog_err(LIB_ERR_SYSTEM_CALL,
 				  "vty_serv_un: could chown socket, %s",
 				  safe_strerror(errno));
 		}
@@ -2413,7 +2413,7 @@ static void vty_read_file(FILE *confp)
 		nl = strchr(vty->error_buf, '\n');
 		if (nl)
 			*nl = '\0';
-		zlog_ferr(LIB_ERR_VTY,
+		flog_err(LIB_ERR_VTY,
 			  "ERROR: %s on config line %u: %s", message, line_num,
 			  vty->error_buf);
 	}
@@ -2488,7 +2488,7 @@ bool vty_read_config(const char *config_file, char *config_default_dir)
 	if (config_file != NULL) {
 		if (!IS_DIRECTORY_SEP(config_file[0])) {
 			if (getcwd(cwd, MAXPATHLEN) == NULL) {
-				zlog_ferr(LIB_ERR_SYSTEM_CALL,
+				flog_err(LIB_ERR_SYSTEM_CALL,
 					  "Failure to determine Current Working Directory %d!",
 					  errno);
 				exit(1);
@@ -2511,7 +2511,7 @@ bool vty_read_config(const char *config_file, char *config_default_dir)
 				zlog_warn(
 					"WARNING: using backup configuration file!");
 			else {
-				zlog_ferr(LIB_ERR_VTY,
+				flog_err(LIB_ERR_VTY,
 					  "can't open configuration file [%s]",
 					  config_file);
 				exit(1);
@@ -2559,7 +2559,7 @@ bool vty_read_config(const char *config_file, char *config_default_dir)
 					"WARNING: using backup configuration file!");
 				fullpath = config_default_dir;
 			} else {
-				zlog_ferr(LIB_ERR_VTY,
+				flog_err(LIB_ERR_VTY,
 					  "can't open configuration file [%s]",
 					  config_default_dir);
 				goto tmp_free_and_out;
@@ -3074,13 +3074,13 @@ static void vty_save_cwd(void)
 		 * Hence not worrying about it too much.
 		 */
 		if (!chdir(SYSCONFDIR)) {
-			zlog_ferr(LIB_ERR_SYSTEM_CALL,
+			flog_err(LIB_ERR_SYSTEM_CALL,
 				  "Failure to chdir to %s, errno: %d",
 				  SYSCONFDIR, errno);
 			exit(-1);
 		}
 		if (getcwd(cwd, MAXPATHLEN) == NULL) {
-			zlog_ferr(LIB_ERR_SYSTEM_CALL,
+			flog_err(LIB_ERR_SYSTEM_CALL,
 				  "Failure to getcwd, errno: %d", errno);
 			exit(-1);
 		}
diff --git a/lib/zclient.c b/lib/zclient.c
index 105435fb2e..c501ac49c7 100644
--- a/lib/zclient.c
+++ b/lib/zclient.c
@@ -313,7 +313,7 @@ int zclient_read_header(struct stream *s, int sock, uint16_t *size,
 	STREAM_GETW(s, *cmd);
 
 	if (*version != ZSERV_VERSION || *marker != ZEBRA_HEADER_MARKER) {
-		zlog_ferr(LIB_ERR_ZAPI_MISSMATCH,
+		flog_err(LIB_ERR_ZAPI_MISSMATCH,
 			  "%s: socket %d version mismatch, marker %d, version %d",
 			  __func__, sock, *marker, *version);
 		return -1;
@@ -1046,7 +1046,7 @@ int zapi_route_encode(uint8_t cmd, struct stream *s, struct zapi_route *api)
 					char buf[PREFIX2STR_BUFFER];
 					prefix2str(&api->prefix, buf,
 						   sizeof(buf));
-					zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+					flog_err(LIB_ERR_ZAPI_ENCODE,
 						  "%s: prefix %s: can't encode "
 						  "%u labels (maximum is %u)",
 						  __func__, buf,
@@ -1672,7 +1672,7 @@ static void link_params_set_value(struct stream *s, struct if_link_params *iflp)
 		for (i = 0; i < bwclassnum && i < MAX_CLASS_TYPE; i++)
 			iflp->unrsv_bw[i] = stream_getf(s);
 		if (i < bwclassnum)
-			zlog_ferr(LIB_ERR_ZAPI_MISSMATCH,
+			flog_err(LIB_ERR_ZAPI_MISSMATCH,
 				  "%s: received %d > %d (MAX_CLASS_TYPE) bw entries"
 				  " - outdated library?",
 				  __func__, bwclassnum, MAX_CLASS_TYPE);
@@ -1704,7 +1704,7 @@ struct interface *zebra_interface_link_params_read(struct stream *s)
 	struct interface *ifp = if_lookup_by_index(ifindex, VRF_DEFAULT);
 
 	if (ifp == NULL) {
-		zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+		flog_err(LIB_ERR_ZAPI_ENCODE,
 			  "%s: unknown ifindex %u, shouldn't happen", __func__,
 			  ifindex);
 		return NULL;
@@ -2041,7 +2041,7 @@ static int zclient_read_sync_response(struct zclient *zclient,
 				   size);
 	}
 	if (ret != 0) {
-		zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+		flog_err(LIB_ERR_ZAPI_ENCODE,
 			 "%s: Invalid Sync Message Reply", __func__);
 		return -1;
 	}
@@ -2084,13 +2084,13 @@ int lm_label_manager_connect(struct zclient *zclient)
 
 	ret = writen(zclient->sock, s->data, stream_get_endp(s));
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_ZAPI_SOCKET, "Can't write to zclient sock");
+		flog_err(LIB_ERR_ZAPI_SOCKET, "Can't write to zclient sock");
 		close(zclient->sock);
 		zclient->sock = -1;
 		return -1;
 	}
 	if (ret == 0) {
-		zlog_ferr(LIB_ERR_ZAPI_SOCKET, "Zclient sock closed");
+		flog_err(LIB_ERR_ZAPI_SOCKET, "Zclient sock closed");
 		close(zclient->sock);
 		zclient->sock = -1;
 		return -1;
@@ -2111,11 +2111,11 @@ int lm_label_manager_connect(struct zclient *zclient)
 
 	/* sanity */
 	if (proto != zclient->redist_default)
-		zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+		flog_err(LIB_ERR_ZAPI_ENCODE,
 			  "Wrong proto (%u) in LM connect response. Should be %u",
 			  proto, zclient->redist_default);
 	if (instance != zclient->instance)
-		zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+		flog_err(LIB_ERR_ZAPI_ENCODE,
 			  "Wrong instId (%u) in LM connect response. Should be %u",
 			  instance, zclient->instance);
 
@@ -2206,14 +2206,14 @@ int lm_get_label_chunk(struct zclient *zclient, uint8_t keep,
 
 	ret = writen(zclient->sock, s->data, stream_get_endp(s));
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_ZAPI_SOCKET,
+		flog_err(LIB_ERR_ZAPI_SOCKET,
 			  "Can't write to zclient sock");
 		close(zclient->sock);
 		zclient->sock = -1;
 		return -1;
 	}
 	if (ret == 0) {
-		zlog_ferr(LIB_ERR_ZAPI_SOCKET,
+		flog_err(LIB_ERR_ZAPI_SOCKET,
 			  "Zclient sock closed");
 		close(zclient->sock);
 		zclient->sock = -1;
@@ -2235,11 +2235,11 @@ int lm_get_label_chunk(struct zclient *zclient, uint8_t keep,
 
 	/* sanities */
 	if (proto != zclient->redist_default)
-		zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+		flog_err(LIB_ERR_ZAPI_ENCODE,
 			  "Wrong proto (%u) in get chunk response. Should be %u",
 			  proto, zclient->redist_default);
 	if (instance != zclient->instance)
-		zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+		flog_err(LIB_ERR_ZAPI_ENCODE,
 			  "Wrong instId (%u) in get chunk response Should be %u",
 			  instance, zclient->instance);
 
@@ -2251,14 +2251,14 @@ int lm_get_label_chunk(struct zclient *zclient, uint8_t keep,
 
 	/* not owning this response */
 	if (keep != response_keep) {
-		zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+		flog_err(LIB_ERR_ZAPI_ENCODE,
 			  "Invalid Label chunk: %u - %u, keeps mismatch %u != %u",
 			  *start, *end, keep, response_keep);
 	}
 	/* sanity */
 	if (*start > *end || *start < MPLS_LABEL_UNRESERVED_MIN
 	    || *end > MPLS_LABEL_UNRESERVED_MAX) {
-		zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+		flog_err(LIB_ERR_ZAPI_ENCODE,
 			  "Invalid Label chunk: %u - %u", *start, *end);
 		return -1;
 	}
@@ -2309,13 +2309,13 @@ int lm_release_label_chunk(struct zclient *zclient, uint32_t start,
 
 	ret = writen(zclient->sock, s->data, stream_get_endp(s));
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_ZAPI_SOCKET, "Can't write to zclient sock");
+		flog_err(LIB_ERR_ZAPI_SOCKET, "Can't write to zclient sock");
 		close(zclient->sock);
 		zclient->sock = -1;
 		return -1;
 	}
 	if (ret == 0) {
-		zlog_ferr(LIB_ERR_ZAPI_SOCKET,
+		flog_err(LIB_ERR_ZAPI_SOCKET,
 			  "Zclient sock connection closed");
 		close(zclient->sock);
 		zclient->sock = -1;
@@ -2419,14 +2419,14 @@ int tm_get_table_chunk(struct zclient *zclient, uint32_t chunk_size,
 
 	ret = writen(zclient->sock, s->data, stream_get_endp(s));
 	if (ret < 0) {
-		zlog_ferr(LIB_ERR_ZAPI_SOCKET,
+		flog_err(LIB_ERR_ZAPI_SOCKET,
 			  "%s: can't write to zclient->sock", __func__);
 		close(zclient->sock);
 		zclient->sock = -1;
 		return -1;
 	}
 	if (ret == 0) {
-		zlog_ferr(LIB_ERR_ZAPI_SOCKET,
+		flog_err(LIB_ERR_ZAPI_SOCKET,
 			  "%s: zclient->sock connection closed", __func__);
 		close(zclient->sock);
 		zclient->sock = -1;
@@ -2513,7 +2513,7 @@ int zebra_send_pw(struct zclient *zclient, int command, struct zapi_pw *pw)
 		stream_write(s, (uint8_t *)&pw->nexthop.ipv6, 16);
 		break;
 	default:
-		zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+		flog_err(LIB_ERR_ZAPI_ENCODE,
 			  "%s: unknown af", __func__);
 		return -1;
 	}
@@ -2616,14 +2616,14 @@ static int zclient_read(struct thread *thread)
 	command = stream_getw(zclient->ibuf);
 
 	if (marker != ZEBRA_HEADER_MARKER || version != ZSERV_VERSION) {
-		zlog_ferr(LIB_ERR_ZAPI_MISSMATCH,
+		flog_err(LIB_ERR_ZAPI_MISSMATCH,
 			  "%s: socket %d version mismatch, marker %d, version %d",
 			  __func__, zclient->sock, marker, version);
 		return zclient_failed(zclient);
 	}
 
 	if (length < ZEBRA_HEADER_SIZE) {
-		zlog_ferr(LIB_ERR_ZAPI_MISSMATCH,
+		flog_err(LIB_ERR_ZAPI_MISSMATCH,
 			  "%s: socket %d message length %u is less than %d ",
 			  __func__, zclient->sock, length, ZEBRA_HEADER_SIZE);
 		return zclient_failed(zclient);