rc = setsockopt(protocol_socket, IPPROTO_IPV6, IPV6_JOIN_GROUP,
(char*)&mreq, sizeof(mreq));
if(rc < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"setsockopt(IPV6_JOIN_GROUP) on interface '%s': %s",
ifp->name, safe_strerror(errno));
/* This is probably due to a missing link-local address,
rc = setsockopt(protocol_socket, IPPROTO_IPV6, IPV6_LEAVE_GROUP,
(char*)&mreq, sizeof(mreq));
if(rc < 0)
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"setsockopt(IPV6_LEAVE_GROUP) on interface '%s': %s",
ifp->name, safe_strerror(errno));
}
rc = read_random_bytes(&seed, sizeof(seed));
if(rc < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "read(random): %s",
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "read(random): %s",
safe_strerror(errno));
seed = 42;
}
fd_null = open("/dev/null", O_RDONLY);
if(fd_null < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "open(null): %s", safe_strerror(errno));
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "open(null): %s", safe_strerror(errno));
exit(1);
}
rc = dup2(fd_null, fd);
if(rc < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "dup2(null, 0): %s",
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "dup2(null, 0): %s",
safe_strerror(errno));
exit(1);
}
fd = open(state_file, O_RDONLY);
if(fd < 0 && errno != ENOENT)
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "open(babel-state: %s)",
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "open(babel-state: %s)",
safe_strerror(errno));
rc = unlink(state_file);
if(fd >= 0 && rc < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "unlink(babel-state): %s",
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "unlink(babel-state): %s",
safe_strerror(errno));
/* If we couldn't unlink it, it's probably stale. */
goto fini;
long t;
rc = read(fd, buf, 99);
if(rc < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "read(babel-state): %s",
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "read(babel-state): %s",
safe_strerror(errno));
} else {
buf[rc] = '\0';
debugf(BABEL_DEBUG_COMMON, "Save state file.");
fd = open(state_file, O_WRONLY | O_TRUNC | O_CREAT, 0644);
if(fd < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "creat(babel-state): %s",
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "creat(babel-state): %s",
safe_strerror(errno));
unlink(state_file);
} else {
/* Make socket for Babel protocol. */
protocol_socket = babel_socket(protocol_port);
if (protocol_socket < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "Couldn't create link local socket: %s",
+ flog_err_sys(EC_LIB_SOCKET, "Couldn't create link local socket: %s",
safe_strerror(errno));
goto fail;
}
(struct sockaddr*)&sin6, sizeof(sin6));
if(rc < 0) {
if(errno != EAGAIN && errno != EINTR) {
- flog_err_sys(LIB_ERR_SOCKET, "recv: %s", safe_strerror(errno));
+ flog_err_sys(EC_LIB_SOCKET, "recv: %s", safe_strerror(errno));
}
} else {
FOR_ALL_INTERFACES(vrf, ifp) {
safi = packet->safi;
if (afi == AFI_IP6) {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"BGP flowspec IPv6 not supported");
return -1;
}
offset += ret;
break;
default:
- flog_err(LIB_ERR_DEVELOPMENT, "%s: unknown type %d\n",
+ flog_err(EC_LIB_DEVELOPMENT, "%s: unknown type %d\n",
__func__, type);
}
}
if (bgp_getsockname(peer) < 0) {
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"%%bgp_getsockname() failed for %s peer %s fd %d (from_peer fd %d)",
(CHECK_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER)
? "accept"
if (from_peer->status > Active) {
if (bgp_getsockname(from_peer) < 0) {
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"%%bgp_getsockname() failed for %s from_peer %s fd %d (peer fd %d)",
(CHECK_FLAG(from_peer->sflags,
}
if (bgp_getsockname(peer) < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"%s: bgp_getsockname(): failed for peer %s, fd %d",
__FUNCTION__, peer->host, peer->fd);
bgp_notify_send(peer, BGP_NOTIFY_FSM_ERR,
ret = sockopt_ttl(peer->su.sa.sa_family, bgp_sock, peer->ttl);
if (ret) {
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"%s: Can't set TxTTL on peer (rtrid %s) socket, err = %d",
__func__,
inet_ntop(AF_INET, &peer->remote_id, buf,
ret = sockopt_ttl(peer->su.sa.sa_family, bgp_sock, MAXTTL);
if (ret) {
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"%s: Can't set TxTTL on peer (rtrid %s) socket, err = %d",
__func__,
inet_ntop(AF_INET, &peer->remote_id, buf,
MAXTTL + 1 - peer->gtsm_hops);
if (ret) {
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"%s: Can't set MinTTL on peer (rtrid %s) socket, err = %d",
__func__,
inet_ntop(AF_INET, &peer->remote_id, buf,
if (rc != 0) {
#if defined(HAVE_CUMULUS)
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"[Error] BGP SO_BINDTODEVICE get failed (%s), sock %d",
safe_strerror(errno), sock);
return -1;
/* Register accept thread. */
accept_sock = THREAD_FD(thread);
if (accept_sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "accept_sock is nevative value %d",
+ flog_err_sys(EC_LIB_SOCKET, "accept_sock is nevative value %d",
accept_sock);
return -1;
}
/* Accept client connection. */
bgp_sock = sockunion_accept(accept_sock, &su);
if (bgp_sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"[Error] BGP socket accept failed (%s)",
safe_strerror(errno));
return -1;
}
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "bind: %s", safe_strerror(en));
+ flog_err_sys(EC_LIB_SOCKET, "bind: %s", safe_strerror(en));
return ret;
}
ret = listen(sock, SOMAXCONN);
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "listen: %s",
+ flog_err_sys(EC_LIB_SOCKET, "listen: %s",
safe_strerror(errno));
return ret;
}
bgp->vrf_id);
}
if (ret != 0) {
- flog_err_sys(LIB_ERR_SOCKET, "getaddrinfo: %s",
+ flog_err_sys(EC_LIB_SOCKET, "getaddrinfo: %s",
gai_strerror(ret));
return -1;
}
? bgp->name : NULL));
}
if (sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "socket: %s",
+ flog_err_sys(EC_LIB_SOCKET, "socket: %s",
safe_strerror(errno));
continue;
}
freeaddrinfo(ainfo_save);
if (count == 0 && bgp->inst_type != BGP_INSTANCE_TYPE_VRF) {
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"%s: no usable addresses please check other programs usage of specified port %d",
__func__, port);
- flog_err_sys(LIB_ERR_SOCKET, "%s: Program cannot continue",
+ flog_err_sys(EC_LIB_SOCKET, "%s: Program cannot continue",
__func__);
exit(-1);
}
/* Get sockname. */
if ((ret = bgp_getsockname(peer)) < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"%s: bgp_getsockname() failed for peer: %s",
__FUNCTION__, peer->host);
return BGP_Stop;
if (ri->peer->pcount[table->afi][table->safi])
ri->peer->pcount[table->afi][table->safi]--;
else
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"Asked to decrement 0 prefix count for peer");
} else if (BGP_INFO_COUNTABLE(ri)
&& !CHECK_FLAG(ri->flags, BGP_INFO_COUNTED)) {
if (CHECK_FLAG(ri->flags, BGP_INFO_COUNTED)) {
pc->count[PCOUNT_COUNTED]++;
if (CHECK_FLAG(ri->flags, BGP_INFO_UNUSEABLE))
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"Attempting to count but flags say it is unusable");
} else {
if (!CHECK_FLAG(ri->flags, BGP_INFO_UNUSEABLE))
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"Not counted but flags say we should");
}
}
size);
break;
default:
- flog_err(LIB_ERR_DEVELOPMENT, "%s: Unknown group type=%d",
+ flog_err(EC_LIB_DEVELOPMENT, "%s: Unknown group type=%d",
__func__, type);
/* should never happen */
assert("Unknown type" == NULL);
criteria, search_cb);
break;
default:
- flog_err(LIB_ERR_DEVELOPMENT, "%s: Unknown group type=%d",
+ flog_err(EC_LIB_DEVELOPMENT, "%s: Unknown group type=%d",
__func__, type);
/* should never happen */
assert("Unknown type" == NULL);
break;
default:
- flog_err(LIB_ERR_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
+ flog_err(EC_LIB_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
return;
}
break;
default:
- flog_err(LIB_ERR_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
+ flog_err(EC_LIB_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
return;
}
default:
/* not expected */
- flog_err(LIB_ERR_DEVELOPMENT, "%s: bad safi %d", __func__,
+ flog_err(EC_LIB_DEVELOPMENT, "%s: bad safi %d", __func__,
safi);
return rfapiBgpInfoFilteredImportBadSafi;
}
if (!afi) {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"%s: can't get afi of route node", __func__);
return;
}
struct prefix ce_nexthop;
if (!afi) {
- flog_err(LIB_ERR_DEVELOPMENT, "%s: bad afi", __func__);
+ flog_err(EC_LIB_DEVELOPMENT, "%s: bad afi", __func__);
return;
}
afi_t afi = family2afi(rn->p.family);
if (!afi) {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"%s: can't get afi of route node", __func__);
return;
}
afi_t afi = family2afi(rn->p.family);
if (!afi) {
- flog_err(LIB_ERR_DEVELOPMENT, "%s: can't get afi route node",
+ flog_err(EC_LIB_DEVELOPMENT, "%s: can't get afi route node",
__func__);
return;
}
afi_t afi = family2afi(rfd->vn_addr.addr_family);
if (!afi) {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"%s: can't get afi of nve vn addr", __func__);
return;
}
if (afi == AFI_IP || afi == AFI_IP6) {
rt = import_table->imported_vpn[afi];
} else {
- flog_err(LIB_ERR_DEVELOPMENT, "%s: bad afi %d",
+ flog_err(EC_LIB_DEVELOPMENT, "%s: bad afi %d",
__func__, afi);
return;
}
afi_t afi = family2afi(rfd->vn_addr.addr_family);
if (!afi) {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"%s: can't get afi of nve vn addr", __func__);
return;
}
if (afi == AFI_IP || afi == AFI_IP6) {
rt = import_table->imported_vpn[afi];
} else {
- flog_err(LIB_ERR_DEVELOPMENT, "%s: bad afi %d",
+ flog_err(EC_LIB_DEVELOPMENT, "%s: bad afi %d",
__func__, afi);
return;
}
if (afi == AFI_IP || afi == AFI_IP6) {
rt = import_table->imported_vpn[afi];
} else {
- flog_err(LIB_ERR_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
+ flog_err(EC_LIB_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
return;
}
struct attr *iattr;
if (!afi) {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"%s: can't get afi of route node", __func__);
return;
}
struct vnc_export_info *eti;
if (!afi) {
- flog_err(LIB_ERR_DEVELOPMENT, "%s: can't get afi route node",
+ flog_err(EC_LIB_DEVELOPMENT, "%s: can't get afi route node",
__func__);
return;
}
*/
if (!afi) {
- flog_err(LIB_ERR_DEVELOPMENT, "%s: can't get afi of prefix",
+ flog_err(EC_LIB_DEVELOPMENT, "%s: can't get afi of prefix",
__func__);
return;
}
}
if (!afi) {
- flog_err(LIB_ERR_DEVELOPMENT, "%s: can't get afi of prefix",
+ flog_err(EC_LIB_DEVELOPMENT, "%s: can't get afi of prefix",
__func__);
return;
}
assert(rfg);
if (!afi) {
- flog_err(LIB_ERR_DEVELOPMENT, "%s: can't get afi of prefix",
+ flog_err(EC_LIB_DEVELOPMENT, "%s: can't get afi of prefix",
__func__);
return;
}
VNC_RHNCK(enter);
if (!afi) {
- flog_err(LIB_ERR_DEVELOPMENT, "%s: can't get afi of prefix",
+ flog_err(EC_LIB_DEVELOPMENT, "%s: can't get afi of prefix",
__func__);
return;
}
return;
if (rn->p.family != AF_INET && rn->p.family != AF_INET6) {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"%s: invalid route node addr family", __func__);
return;
}
return;
if (afi != AFI_IP && afi != AFI_IP6) {
- flog_err(LIB_ERR_DEVELOPMENT, "%s: invalid vn addr family",
+ flog_err(EC_LIB_DEVELOPMENT, "%s: invalid vn addr family",
__func__);
return;
}
if (afi == AFI_IP || afi == AFI_IP6) {
rt = import_table->imported_vpn[afi];
} else {
- flog_err(LIB_ERR_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
+ flog_err(EC_LIB_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
return;
}
if (!family) {
- flog_err(LIB_ERR_DEVELOPMENT, "%s: computed bad family: %d",
+ flog_err(EC_LIB_DEVELOPMENT, "%s: computed bad family: %d",
__func__, family);
return;
}
/* Get one packet from queue. */
ep = eigrp_fifo_next(ei->obuf);
if (!ep) {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"%s: Interface %s no packet on queue?",
__PRETTY_FUNCTION__, ei->ifp->name);
goto out;
stream_putw(s, length);
break;
default:
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"%s: Unexpected prefix length: %d",
__PRETTY_FUNCTION__, pe->destination->prefixlen);
return 0;
}
break;
default:
- flog_err(LIB_ERR_DEVELOPMENT, "%s: Please implement handler",
+ flog_err(EC_LIB_DEVELOPMENT, "%s: Please implement handler",
__PRETTY_FUNCTION__);
break;
}
if ((eigrp_socket = eigrp_sock_init()) < 0) {
flog_err_sys(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"eigrp_new: fatal error: eigrp_sock_init was unable to open a socket");
exit(1);
}
{
if (lsp->own_lsp) {
flog_err(
- LIB_ERR_DEVELOPMENT,
+ EC_LIB_DEVELOPMENT,
"ISIS-Upd (%s): BUG updating LSP %s still marked as own LSP",
area->area_tag, rawlspid_print(lsp->hdr.lsp_id));
lsp_clear_data(lsp);
lsp = lsp_search(lspid, lspdb);
if (!lsp) {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"ISIS-Upd (%s): lsp_regenerate: no L%d LSP found!",
area->area_tag, level);
return ISIS_ERROR;
lsp = lsp_search(lsp_id, lspdb);
if (!lsp) {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"lsp_regenerate_pseudo: no l%d LSP %s found!", level,
rawlspid_print(lsp_id));
return ISIS_ERROR;
uint8_t max_area_addrs = stream_getc(circuit->rcv_stream);
if (idrp == ISO9542_ESIS) {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"No support for ES-IS packet IDRP=%" PRIx8, idrp);
return ISIS_ERROR;
}
} else if (VTYPE_IP(vtype)) {
memcpy(&vertex->N.ip, id, sizeof(vertex->N.ip));
} else {
- flog_err(LIB_ERR_DEVELOPMENT, "Unknown Vertex Type");
+ flog_err(EC_LIB_DEVELOPMENT, "Unknown Vertex Type");
}
}
nullfd = open("/dev/null", O_RDONLY | O_NOCTTY);
if (nullfd == -1) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"%s: failed to open /dev/null: %s", __func__,
safe_strerror(errno));
} else {
msg[strlen(msg) - 1] = '\0';
switch (slm->priority) {
case LOG_EMERG:
- flog_err(LIB_ERR_SNMP,
+ flog_err(EC_LIB_SNMP,
"snmp[emerg]: %s", msg ? msg : slm->msg);
break;
case LOG_ALERT:
- flog_err(LIB_ERR_SNMP,
+ flog_err(EC_LIB_SNMP,
"snmp[alert]: %s", msg ? msg : slm->msg);
break;
case LOG_CRIT:
- flog_err(LIB_ERR_SNMP,
+ flog_err(EC_LIB_SNMP,
"snmp[crit]: %s", msg ? msg : slm->msg);
break;
case LOG_ERR:
- flog_err(LIB_ERR_SNMP,
+ flog_err(EC_LIB_SNMP,
"snmp[err]: %s", msg ? msg : slm->msg);
break;
case LOG_WARNING:
- flog_warn(LIB_WARN_SNMP, "snmp[warning]: %s",
+ flog_warn(EC_LIB_SNMP, "snmp[warning]: %s",
msg ? msg : slm->msg);
break;
case LOG_NOTICE:
} else {
/* This should absolutely never occur. */
flog_err_sys(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"%s: corruption detected: iov_small overflowed; "
"head %p, tail %p, head->next %p",
__func__, (void *)b->head,
iov_size =
((iov_index > IOV_MAX) ? IOV_MAX : iov_index);
if ((nbytes = writev(fd, c_iov, iov_size)) < 0) {
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"%s: writev to fd %d failed: %s",
__func__, fd, safe_strerror(errno));
break;
}
#else /* IOV_MAX */
if ((nbytes = writev(fd, iov, iov_index)) < 0)
- flog_err(LIB_ERR_SOCKET, "%s: writev to fd %d failed: %s",
+ flog_err(EC_LIB_SOCKET, "%s: writev to fd %d failed: %s",
__func__, fd, safe_strerror(errno));
#endif /* IOV_MAX */
if (ERRNO_IO_RETRY(errno))
/* Calling code should try again later. */
return BUFFER_PENDING;
- flog_err(LIB_ERR_SOCKET, "%s: write error on fd %d: %s",
+ flog_err(EC_LIB_SOCKET, "%s: write error on fd %d: %s",
__func__, fd, safe_strerror(errno));
return BUFFER_ERROR;
}
while (written > 0) {
if (!(d = b->head)) {
flog_err(
- LIB_ERR_DEVELOPMENT,
+ EC_LIB_DEVELOPMENT,
"%s: corruption detected: buffer queue empty, but written is %lu",
__func__, (unsigned long)written);
break;
if (ERRNO_IO_RETRY(errno))
nbytes = 0;
else {
- flog_err(LIB_ERR_SOCKET, "%s: write error on fd %d: %s",
+ flog_err(EC_LIB_SOCKET, "%s: write error on fd %d: %s",
__func__, fd, safe_strerror(errno));
return BUFFER_ERROR;
}
cwd[MAXPATHLEN] = '\0';
if (getcwd(cwd, MAXPATHLEN) == NULL) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"config_log_file: Unable to alloc mem!");
return CMD_WARNING_CONFIG_FAILED;
}
return 0;
out_err:
- flog_err(LIB_ERR_ZMQ, "ZeroMQ read error: %s(%d)", strerror(errno),
+ flog_err(EC_LIB_ZMQ, "ZeroMQ read error: %s(%d)", strerror(errno),
errno);
if (cb->read.cb_error)
cb->read.cb_error(cb->read.arg, cb->zmqsock);
return 0;
out_err:
- flog_err(LIB_ERR_ZMQ, "ZeroMQ write error: %s(%d)", strerror(errno),
+ flog_err(EC_LIB_ZMQ, "ZeroMQ write error: %s(%d)", strerror(errno),
errno);
if (cb->write.cb_error)
cb->write.cb_error(cb->write.arg, cb->zmqsock);
llts(ZEBRA_LLT_IEEE802154, "IEEE 802.15.4");
llts(ZEBRA_LLT_IEEE802154_PHY, "IEEE 802.15.4 Phy");
default:
- flog_err(LIB_ERR_DEVELOPMENT, "Unknown value %d", llt);
+ flog_err(EC_LIB_DEVELOPMENT, "Unknown value %d", llt);
return "Unknown type!";
#undef llts
}
#define IFNAME_RB_INSERT(vrf, ifp) \
if (RB_INSERT(if_name_head, &vrf->ifaces_by_name, (ifp))) \
flog_err( \
- LIB_ERR_INTERFACE, \
+ EC_LIB_INTERFACE, \
"%s(%s): corruption detected -- interface with this " \
"name exists already in VRF %u!", \
__func__, (ifp)->name, (ifp)->vrf_id);
#define IFNAME_RB_REMOVE(vrf, ifp) \
if (RB_REMOVE(if_name_head, &vrf->ifaces_by_name, (ifp)) == NULL) \
flog_err( \
- LIB_ERR_INTERFACE, \
+ EC_LIB_INTERFACE, \
"%s(%s): corruption detected -- interface with this " \
"name doesn't exist in VRF %u!", \
__func__, (ifp)->name, (ifp)->vrf_id);
#define IFINDEX_RB_INSERT(vrf, ifp) \
if (RB_INSERT(if_index_head, &vrf->ifaces_by_index, (ifp))) \
flog_err( \
- LIB_ERR_INTERFACE, \
+ EC_LIB_INTERFACE, \
"%s(%u): corruption detected -- interface with this " \
"ifindex exists already in VRF %u!", \
__func__, (ifp)->ifindex, (ifp)->vrf_id);
#define IFINDEX_RB_REMOVE(vrf, ifp) \
if (RB_REMOVE(if_index_head, &vrf->ifaces_by_index, (ifp)) == NULL) \
flog_err( \
- LIB_ERR_INTERFACE, \
+ EC_LIB_INTERFACE, \
"%s(%u): corruption detected -- interface with this " \
"ifindex doesn't exist in VRF %u!", \
__func__, (ifp)->ifindex, (ifp)->vrf_id);
/* clang-format off */
static struct log_ref ferr_lib_warn[] = {
{
- .code = LIB_WARN_SNMP,
+ .code = EC_LIB_SNMP,
.title = "SNMP has discovered a warning",
.description = "The SNMP AgentX library has returned a warning that we should report to the end user",
.suggestion = "Gather Log data and open an Issue.",
},
{
- .code = LIB_WARN_STREAM,
+ .code = EC_LIB_STREAM,
.title = "The stream subsystem has encountered an error",
.description = "During sanity checking stream.c has detected an error in the data associated with a particular stream",
.suggestion = "Gather log data and open an Issue, restart FRR",
},
{
- .code = LIB_WARN_LINUX_NS,
+ .code = EC_LIB_LINUX_NS,
.title = "The Linux namespace subsystem has encountered a parsing error",
.description = "During system startup an invalid parameter for the namesapce was give to FRR",
.suggestion = "Gather log data and open an Issue. restart FRR",
},
{
- .code = LIB_WARN_SLOW_THREAD,
+ .code = EC_LIB_SLOW_THREAD,
.title = "The Event subsystem has detected a slow process",
.description = "The Event subsystem has detected a slow process, this typically indicates that FRR is having trouble completing work in a timely manner. This can be either a misconfiguration, bug, or some combination therof.",
.suggestion = "Gather log data and open an Issue",
},
{
- .code = LIB_WARN_RMAP_RECURSION_LIMIT,
+ .code = EC_LIB_RMAP_RECURSION_LIMIT,
.title = "Reached the Route-Map Recursion Limit",
.description = "The Route-Map subsystem has detected a route-map depth of RMAP_RECURSION_LIMIT and has stopped processing",
.suggestion = "Re-work the Route-Map in question to not have so many route-map statements, or recompile FRR with a higher limit",
},
{
- .code = LIB_WARN_BACKUP_CONFIG,
+ .code = EC_LIB_BACKUP_CONFIG,
.title = "Unable to open configuration file",
.description = "The config subsystem attempted to read in it's configuration file which failed, so we are falling back to the backup config file to see if it is available",
.suggestion = "Create configuration file",
},
{
- .code = LIB_WARN_VRF_LENGTH,
+ .code = EC_LIB_VRF_LENGTH,
.title = "The VRF subsystem has encountered a parsing error",
.description = "The VRF subsystem, during initialization, has found a parsing error with input it has received",
.suggestion = "Check the length of the vrf name and adjust accordingly",
static struct log_ref ferr_lib_err[] = {
{
- .code = LIB_ERR_PRIVILEGES,
+ .code = EC_LIB_PRIVILEGES,
.title = "Failure to raise or lower privileges",
.description = "FRR attempted to raise or lower its privileges and was unable to do so",
.suggestion = "Ensure that you are running FRR as the frr user and that the user has sufficient privileges to properly access root privileges"
},
{
- .code = LIB_ERR_VRF_START,
+ .code = EC_LIB_VRF_START,
.title = "VRF Failure on Start",
.description = "Upon startup FRR failed to properly initialize and startup the VRF subsystem",
.suggestion = "Ensure that there is sufficient memory to start processes and restart FRR",
},
{
- .code = LIB_ERR_SOCKET,
+ .code = EC_LIB_SOCKET,
.title = "Socket Error",
.description = "When attempting to access a socket a system error has occured and we were unable to properly complete the request",
.suggestion = "Ensure that there are sufficient system resources available and ensure that the frr user has sufficient permisions to work. If necessary open an Issue",
},
{
- .code = LIB_ERR_ZAPI_MISSMATCH,
+ .code = EC_LIB_ZAPI_MISSMATCH,
.title = "ZAPI Error",
.description = "A version miss-match has been detected between zebra and client protocol",
.suggestion = "Two different versions of FRR have been installed and the install is not properly setup. Completely stop FRR, remove it from the system and reinstall. Typically only developers should see this issue."
},
{
- .code = LIB_ERR_ZAPI_ENCODE,
+ .code = EC_LIB_ZAPI_ENCODE,
.title = "ZAPI Error",
.description = "The ZAPI subsystem has detected an encoding issue, between zebra and a client protocol",
.suggestion = "Gather data and open an Issue, also Restart FRR"
},
{
- .code = LIB_ERR_ZAPI_SOCKET,
+ .code = EC_LIB_ZAPI_SOCKET,
.title = "ZAPI Error",
.description = "The ZAPI subsystem has detected a socket error between zebra and a client",
.suggestion = "Restart FRR"
},
{
- .code = LIB_ERR_SYSTEM_CALL,
+ .code = EC_LIB_SYSTEM_CALL,
.title = "System Call Error",
.description = "FRR has detected a error from using a vital system call and has probably already exited",
.suggestion = "Ensure permissions are correct for FRR files, users and groups are correct. Additionally check that sufficient system resources are available."
},
{
- .code = LIB_ERR_VTY,
+ .code = EC_LIB_VTY,
.title = "VTY Subsystem Error",
.description = "FRR has detected a problem with the specified configuration file",
.suggestion = "Ensure configuration file exists and has correct permissions for operations Additionally ensure that all config lines are correct as well",
},
{
- .code = LIB_ERR_SNMP,
- .title = "SNMP Subsystem Error",
- .description = "FRR has detected a problem with the snmp library it uses A callback from this subsystem has indicated some error",
- .suggestion = "Examine callback message and ensure snmp is properly setup and working"
- },
- {
- .code = LIB_ERR_INTERFACE,
+ .code = EC_LIB_INTERFACE,
.title = "Interface Subsystem Error",
.description = "FRR has detected a problem with interface data from the kernel as it deviates from what we would expect to happen via normal netlink messaging",
.suggestion = "Open an Issue with all relevant log files and restart FRR"
},
{
- .code = LIB_ERR_NS,
+ .code = EC_LIB_NS,
.title = "NameSpace Subsystem Error",
.description = "FRR has detected a problem with NameSpace data from the kernel as it deviates from what we would expect to happen via normal kernel messaging",
.suggestion = "Open an Issue with all relevant log files and restart FRR"
},
{
- .code = LIB_ERR_DEVELOPMENT,
+ .code = EC_LIB_DEVELOPMENT,
.title = "Developmental Escape Error",
.description = "FRR has detected an issue where new development has not properly updated all code paths.",
.suggestion = "Open an Issue with all relevant log files"
},
{
- .code = LIB_ERR_ZMQ,
+ .code = EC_LIB_ZMQ,
.title = "ZMQ Subsystem Error",
.description = "FRR has detected an issue with the Zero MQ subsystem and ZeroMQ is not working properly now",
.suggestion = "Open an Issue with all relevant log files and restart FRR"
},
{
- .code = LIB_ERR_UNAVAILABLE,
+ .code = EC_LIB_UNAVAILABLE,
.title = "Feature or system unavailable",
.description = "FRR was not compiled with support for a particular feature, or it is not available on the current platform",
.suggestion = "Recompile FRR with the feature enabled, or find out what platforms support the feature"
#include "lib/ferr.h"
enum lib_log_refs {
- LIB_ERR_PRIVILEGES = LIB_FERR_START,
- LIB_ERR_VRF_START,
- LIB_ERR_SOCKET,
- LIB_ERR_ZAPI_MISSMATCH,
- LIB_ERR_ZAPI_ENCODE,
- LIB_ERR_ZAPI_SOCKET,
- LIB_ERR_SYSTEM_CALL,
- LIB_ERR_VTY,
- LIB_ERR_SNMP,
- LIB_ERR_INTERFACE,
- LIB_ERR_NS,
- LIB_ERR_DEVELOPMENT,
- LIB_ERR_ZMQ,
- LIB_ERR_UNAVAILABLE,
- LIB_WARN_SNMP,
- LIB_WARN_STREAM,
- LIB_WARN_LINUX_NS,
- LIB_WARN_SLOW_THREAD,
- LIB_WARN_RMAP_RECURSION_LIMIT,
- LIB_WARN_BACKUP_CONFIG,
- LIB_WARN_VRF_LENGTH,
+ EC_LIB_PRIVILEGES = LIB_FERR_START,
+ EC_LIB_VRF_START,
+ EC_LIB_SOCKET,
+ EC_LIB_ZAPI_MISSMATCH,
+ EC_LIB_ZAPI_ENCODE,
+ EC_LIB_ZAPI_SOCKET,
+ EC_LIB_SYSTEM_CALL,
+ EC_LIB_VTY,
+ EC_LIB_INTERFACE,
+ EC_LIB_NS,
+ EC_LIB_DEVELOPMENT,
+ EC_LIB_ZMQ,
+ EC_LIB_UNAVAILABLE,
+ EC_LIB_SNMP,
+ EC_LIB_STREAM,
+ EC_LIB_LINUX_NS,
+ EC_LIB_SLOW_THREAD,
+ EC_LIB_RMAP_RECURSION_LIMIT,
+ EC_LIB_BACKUP_CONFIG,
+ EC_LIB_VRF_LENGTH,
};
extern void lib_error_init(void);
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
if (fcntl(fd, F_GETLK, &lock) < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"Could not do F_GETLK pid_file %s (%s), exiting",
path, safe_strerror(errno));
exit(1);
} else if (lock.l_type == F_WRLCK) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"Process %d has a write lock on file %s already! Error: (%s)",
lock.l_pid, path, safe_strerror(errno));
exit(1);
if (errno == EEXIST)
return;
- flog_err(LIB_ERR_SYSTEM_CALL, "failed to mkdir \"%s\": %s",
+ flog_err(EC_LIB_SYSTEM_CALL, "failed to mkdir \"%s\": %s",
path, strerror(errno));
return;
}
zprivs_get_ids(&ids);
if (chown(path, ids.uid_normal, ids.gid_normal))
- flog_err(LIB_ERR_SYSTEM_CALL, "failed to chown \"%s\": %s",
+ flog_err(EC_LIB_SYSTEM_CALL, "failed to chown \"%s\": %s",
path, strerror(errno));
}
nullfd = open("/dev/null", O_RDONLY | O_NOCTTY);
if (nullfd == -1) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"%s: failed to open /dev/null: %s", __func__,
safe_strerror(errno));
} else {
} else if (di->daemon_mode) {
int nullfd = open("/dev/null", O_RDONLY | O_NOCTTY);
if (nullfd == -1) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"%s: failed to open /dev/null: %s",
__func__, safe_strerror(errno));
} else {
size = backtrace(array, array_size(array));
if (size <= 0 || (size_t)size > array_size(array)) {
flog_err_sys(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"Cannot get backtrace, returned invalid # of frames %d "
"(valid range is between 1 and %lu)",
size, (unsigned long)(array_size(array)));
}
zlog(priority, "Backtrace for %d stack frames:", size);
if (!(strings = backtrace_symbols(array, size))) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"Cannot get backtrace symbols (out of memory?)");
for (i = 0; i < size; i++)
zlog(priority, "[bt %d] %p", i, array[i]);
void memory_oom(size_t size, const char *name)
{
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"out of memory: failed to allocate %zu bytes for %s"
"object",
size, name);
pthread_mutex_unlock(&loglock);
flog_err_sys(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"Log rotate failed: cannot open file %s for append: %s",
zl->filename, safe_strerror(save_errno));
ret = -1;
unsigned int i;
if (zroute >= array_size(route_types)) {
- flog_err(LIB_ERR_DEVELOPMENT, "unknown zebra route type: %u",
+ flog_err(EC_LIB_DEVELOPMENT, "unknown zebra route type: %u",
zroute);
return &unknown;
}
return &route_types[i];
}
}
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"internal error: cannot find route type %u in table!",
zroute);
return &unknown;
const char *zserv_command_string(unsigned int command)
{
if (command >= array_size(command_types)) {
- flog_err(LIB_ERR_DEVELOPMENT, "unknown zserv command type: %u",
+ flog_err(EC_LIB_DEVELOPMENT, "unknown zserv command type: %u",
command);
return unknown.string;
}
}
if (!ns_is_enabled(ns)) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"Can not enable NS %u: %s!", ns->ns_id,
safe_strerror(errno));
return 0;
/* Non default NS. leave */
if (ns->ns_id == NS_UNKNOWN) {
- flog_err(LIB_ERR_NS,
+ flog_err(EC_LIB_NS,
"Can not enable NS %s %u: Invalid NSID",
ns->name, ns->ns_id);
return 0;
pathname,
safe_strerror(errno));
else
- flog_warn(LIB_WARN_LINUX_NS,
+ flog_warn(EC_LIB_LINUX_NS,
"Invalid pathname for %s: %s", pathname,
safe_strerror(errno));
return NULL;
vty_out(vty, "NS name (%s) invalid: too long (>%d)\n",
check_base, NS_NAMSIZ - 1);
else
- flog_warn(LIB_WARN_LINUX_NS,
+ flog_warn(EC_LIB_LINUX_NS,
"NS name (%s) invalid: too long (>%d)",
check_base, NS_NAMSIZ - 1);
return NULL;
ns_init();
default_ns = ns_get_created_internal(NULL, NULL, default_ns_id);
if (!default_ns) {
- flog_err(LIB_ERR_NS, "%s: failed to create the default NS!",
+ flog_err(EC_LIB_NS, "%s: failed to create the default NS!",
__func__);
exit(1);
}
/* Enable the default NS. */
if (!ns_enable(default_ns, NULL)) {
- flog_err(LIB_ERR_NS, "%s: failed to enable the default NS!",
+ flog_err(EC_LIB_NS, "%s: failed to enable the default NS!",
__func__);
exit(1);
}
should
never be negative. */
if ((flags = fcntl(fd, F_GETFL)) < 0) {
- flog_err(LIB_ERR_SYSTEM_CALL,
+ flog_err(EC_LIB_SYSTEM_CALL,
"fcntl(F_GETFL) failed for fd %d: %s", fd,
safe_strerror(errno));
return -1;
}
if (fcntl(fd, F_SETFL, (flags | O_NONBLOCK)) < 0) {
- flog_err(LIB_ERR_SYSTEM_CALL,
+ flog_err(EC_LIB_SYSTEM_CALL,
"fcntl failed setting fd %d non-blocking: %s", fd,
safe_strerror(errno));
return -1;
oldumask = umask(0777 & ~PIDFILE_MASK);
fd = open(path, O_RDWR | O_CREAT, PIDFILE_MASK);
if (fd < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"Can't create pid lock file %s (%s), exiting",
path, safe_strerror(errno));
umask(oldumask);
lock.l_whence = SEEK_SET;
if (fcntl(fd, F_SETLK, &lock) < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"Could not lock pid_file %s (%s), exiting",
path, safe_strerror(errno));
exit(1);
pidsize = strlen(buf);
if ((tmp = write(fd, buf, pidsize)) != (int)pidsize)
flog_err_sys(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_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)
flog_err_sys(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"Could not truncate pid_file %s to %u bytes: %s",
path, (unsigned int)pidsize,
safe_strerror(errno));
memcpy((void *)dest->u.prefix_flowspec.ptr,
(void *)src->u.prefix_flowspec.ptr, len);
} else {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"prefix_copy(): Unknown address family %d",
src->family);
assert(0);
zprivs_state.syscaps_p->caps[i], CAP_EFFECTIVE,
&val)) {
flog_err(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"zprivs_state_caps: could not cap_get_flag, %s",
safe_strerror(errno));
return ZPRIVS_UNKNOWN;
if (recursion > RMAP_RECURSION_LIMIT) {
flog_warn(
- LIB_WARN_RMAP_RECURSION_LIMIT,
+ EC_LIB_RMAP_RECURSION_LIMIT,
"route-map recursion limit (%d) reached, discarding route",
RMAP_RECURSION_LIMIT);
recursion = 0;
sigdelset(&newmask, SIGKILL);
if ((sigprocmask(SIG_BLOCK, &newmask, &oldmask)) < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"quagga_signal_timer: couldnt block signals!");
return -1;
}
if (sigaction(sigmap[i].sigs[j], &act, NULL)
< 0)
flog_err(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"Unable to set signal handler for signal %d: %s",
sigmap[i].sigs[j],
safe_strerror(errno));
/* DEBUG */
if (!key) {
- flog_err(LIB_ERR_DEVELOPMENT, "%s: key is 0, value is %p",
+ flog_err(EC_LIB_DEVELOPMENT, "%s: key is 0, value is %p",
__func__, value);
}
size /= 2;
if (size != orig_req)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"%s: fd %d: SO_RCVBUF set to %d (requested %d)",
__func__, sock, size, orig_req);
}
size /= 2;
if (size != orig_req)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"%s: fd %d: SO_SNDBUF set to %d (requested %d)",
__func__, sock, size, orig_req);
}
int ret = getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *)&optval,
&optlen);
if (ret < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"fd %d: can't getsockopt SO_SNDBUF: %d (%s)", sock,
errno, safe_strerror(errno));
return ret;
ret = setsockopt(sock, IPPROTO_IPV6, IPV6_RECVPKTINFO, &val,
sizeof(val));
if (ret < 0)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"can't setsockopt IPV6_RECVPKTINFO : %s",
safe_strerror(errno));
#else /*RFC2292*/
ret = setsockopt(sock, IPPROTO_IPV6, IPV6_PKTINFO, &val, sizeof(val));
if (ret < 0)
- flog_err(LIB_ERR_SOCKET, "can't setsockopt IPV6_PKTINFO : %s",
+ flog_err(EC_LIB_SOCKET, "can't setsockopt IPV6_PKTINFO : %s",
safe_strerror(errno));
#endif /* INIA_IPV6 */
return ret;
ret = setsockopt(sock, IPPROTO_IPV6, IPV6_CHECKSUM, &val, sizeof(val));
#endif /* GNU_LINUX */
if (ret < 0)
- flog_err(LIB_ERR_SOCKET, "can't setsockopt IPV6_CHECKSUM");
+ flog_err(EC_LIB_SOCKET, "can't setsockopt IPV6_CHECKSUM");
return ret;
}
ret = setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &val,
sizeof(val));
if (ret < 0)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"can't setsockopt IPV6_MULTICAST_HOPS");
return ret;
}
ret = setsockopt(sock, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &val,
sizeof(val));
if (ret < 0)
- flog_err(LIB_ERR_SOCKET, "can't setsockopt IPV6_UNICAST_HOPS");
+ flog_err(EC_LIB_SOCKET, "can't setsockopt IPV6_UNICAST_HOPS");
return ret;
}
ret = setsockopt(sock, IPPROTO_IPV6, IPV6_RECVHOPLIMIT, &val,
sizeof(val));
if (ret < 0)
- flog_err(LIB_ERR_SOCKET, "can't setsockopt IPV6_RECVHOPLIMIT");
+ flog_err(EC_LIB_SOCKET, "can't setsockopt IPV6_RECVHOPLIMIT");
#else /*RFC2292*/
ret = setsockopt(sock, IPPROTO_IPV6, IPV6_HOPLIMIT, &val, sizeof(val));
if (ret < 0)
- flog_err(LIB_ERR_SOCKET, "can't setsockopt IPV6_HOPLIMIT");
+ flog_err(EC_LIB_SOCKET, "can't setsockopt IPV6_HOPLIMIT");
#endif
return ret;
}
ret = setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &val,
sizeof(val));
if (ret < 0)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"can't setsockopt IPV6_MULTICAST_LOOP");
return ret;
}
ret = setsockopt(sock, IPPROTO_IPV6, IPV6_TCLASS, &tclass,
sizeof(tclass));
if (ret < 0)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"Can't set IPV6_TCLASS option for fd %d to %#x: %s",
sock, tclass, safe_strerror(errno));
#endif
ret = setsockopt(sock, IPPROTO_IP, IP_MULTICAST_LOOP, (void *)&val,
sizeof(val));
if (ret < 0)
- flog_err(LIB_ERR_SOCKET, "can't setsockopt IP_MULTICAST_LOOP");
+ flog_err(EC_LIB_SOCKET, "can't setsockopt IP_MULTICAST_LOOP");
return ret;
}
#if defined(IP_PKTINFO)
if ((ret = setsockopt(sock, IPPROTO_IP, IP_PKTINFO, &val, sizeof(val)))
< 0)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"Can't set IP_PKTINFO option for fd %d to %d: %s",
sock, val, safe_strerror(errno));
#elif defined(IP_RECVIF)
if ((ret = setsockopt(sock, IPPROTO_IP, IP_RECVIF, &val, sizeof(val)))
< 0)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"Can't set IP_RECVIF option for fd %d to %d: %s", sock,
val, safe_strerror(errno));
#else
ret = setsockopt(sock, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
if (ret < 0)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"Can't set IP_TOS option for fd %d to %#x: %s", sock,
tos, safe_strerror(errno));
return ret;
ret = setsockopt_ipv6_pktinfo(sock, val);
break;
default:
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"setsockopt_ifindex: unknown address family %d", af);
}
return ret;
return (getsockopt_ipv6_ifindex(msgh));
break;
default:
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"getsockopt_ifindex: unknown address family %d", af);
return 0;
}
ret = 0;
else
flog_err_sys(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"sockopt_tcp_signature: setsockopt(%d): %s",
sock, safe_strerror(errno));
}
sock = socket(su->sa.sa_family, SOCK_STREAM, 0);
if (sock < 0) {
char buf[SU_ADDRSTRLEN];
- flog_err(LIB_ERR_SOCKET, "Can't make socket for %s : %s",
+ flog_err(EC_LIB_SOCKET, "Can't make socket for %s : %s",
sockunion_log(su, buf, SU_ADDRSTRLEN),
safe_strerror(errno));
return -1;
sock = socket(su->sa.sa_family, SOCK_STREAM, 0);
if (sock < 0)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"can't make socket sockunion_stream_socket");
return sock;
ret = bind(sock, (struct sockaddr *)su, size);
if (ret < 0) {
char buf[SU_ADDRSTRLEN];
- flog_err(LIB_ERR_SOCKET, "can't bind socket for %s : %s",
+ flog_err(EC_LIB_SOCKET, "can't bind socket for %s : %s",
sockunion_log(su, buf, SU_ADDRSTRLEN),
safe_strerror(errno));
}
ret = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&on,
sizeof(on));
if (ret < 0) {
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"can't set sockopt SO_REUSEADDR to socket %d", sock);
return -1;
}
ret = setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, (void *)&on,
sizeof(on));
if (ret < 0) {
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"can't set sockopt SO_REUSEPORT to socket %d", sock);
return -1;
}
ret = setsockopt(sock, IPPROTO_IP, IP_TTL, (void *)&ttl,
sizeof(int));
if (ret < 0) {
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"can't set sockopt IP_TTL %d to socket %d",
ttl, sock);
return -1;
(void *)&ttl, sizeof(int));
if (ret < 0) {
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"can't set sockopt IPV6_UNICAST_HOPS %d to socket %d",
ttl, sock);
return -1;
sizeof(minttl));
if (ret < 0)
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"can't set sockopt IP_MINTTL to %d on socket %d: %s",
minttl, sock, safe_strerror(errno));
return ret;
&minttl, sizeof(minttl));
if (ret < 0)
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"can't set sockopt IPV6_MINHOPCOUNT to %d on socket %d: %s",
minttl, sock, safe_strerror(errno));
return ret;
ret = setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&on,
sizeof(int));
if (ret < 0) {
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"can't set sockopt IPV6_V6ONLY "
"to socket %d",
sock);
ret = getsockname(fd, (struct sockaddr *)&name, &len);
if (ret < 0) {
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"Can't get local address and port by getsockname: %s",
safe_strerror(errno));
return NULL;
len = sizeof name;
ret = getpeername(fd, (struct sockaddr *)&name, &len);
if (ret < 0) {
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"Can't get remote address and port: %s",
safe_strerror(errno));
return NULL;
* using stream_put..._at() functions.
*/
#define STREAM_WARN_OFFSETS(S) \
- flog_warn(LIB_WARN_STREAM, \
+ flog_warn(EC_LIB_STREAM, \
"&(struct stream): %p, size: %lu, getp: %lu, endp: %lu\n", \
(void *)(S), (unsigned long)(S)->size, \
(unsigned long)(S)->getp, (unsigned long)(S)->endp)
#define STREAM_BOUND_WARN(S, WHAT) \
do { \
- flog_warn(LIB_WARN_STREAM, "%s: Attempt to %s out of bounds", \
+ flog_warn(EC_LIB_STREAM, "%s: Attempt to %s out of bounds", \
__func__, (WHAT)); \
STREAM_WARN_OFFSETS(S); \
assert(0); \
#define STREAM_BOUND_WARN2(S, WHAT) \
do { \
- flog_warn(LIB_WARN_STREAM, "%s: Attempt to %s out of bounds", \
+ flog_warn(EC_LIB_STREAM, "%s: Attempt to %s out of bounds", \
__func__, (WHAT)); \
STREAM_WARN_OFFSETS(S); \
} while (0)
do { \
if (((S)->endp + (Z)) > (S)->size) { \
flog_warn( \
- LIB_WARN_STREAM, \
+ EC_LIB_STREAM, \
"CHECK_SIZE: truncating requested size %lu\n", \
(unsigned long)(Z)); \
STREAM_WARN_OFFSETS(S); \
/* Error: was it transient (return -2) or fatal (return -1)? */
if (ERRNO_IO_RETRY(errno))
return -2;
- flog_err(LIB_ERR_SOCKET, "%s: read failed on fd %d: %s", __func__, fd,
+ flog_err(EC_LIB_SOCKET, "%s: read failed on fd %d: %s", __func__, fd,
safe_strerror(errno));
return -1;
}
/* Error: was it transient (return -2) or fatal (return -1)? */
if (ERRNO_IO_RETRY(errno))
return -2;
- flog_err(LIB_ERR_SOCKET, "%s: read failed on fd %d: %s", __func__, fd,
+ flog_err(EC_LIB_SOCKET, "%s: read failed on fd %d: %s", __func__, fd,
safe_strerror(errno));
return -1;
}
}
/* else die */
- flog_err(LIB_ERR_SYSTEM_CALL, "poll() error: %s",
+ flog_err(EC_LIB_SYSTEM_CALL, "poll() error: %s",
safe_strerror(errno));
pthread_mutex_unlock(&m->mtx);
fetch = NULL;
* to fix.
*/
flog_warn(
- LIB_WARN_SLOW_THREAD,
+ EC_LIB_SLOW_THREAD,
"SLOW THREAD: task %s (%lx) ran for %lums (cpu time %lums)",
thread->funcname, (unsigned long)thread->func,
realtime / 1000, cputime / 1000);
/* The default VRF always exists. */
default_vrf = vrf_get(VRF_DEFAULT, VRF_DEFAULT_NAME);
if (!default_vrf) {
- flog_err(LIB_ERR_VRF_START,
+ flog_err(EC_LIB_VRF_START,
"vrf_init: failed to create the default VRF!");
exit(1);
}
/* Enable the default VRF. */
if (!vrf_enable(default_vrf)) {
- flog_err(LIB_ERR_VRF_START,
+ flog_err(EC_LIB_VRF_START,
"vrf_init: failed to enable the default VRF!");
exit(1);
}
ret = vrf_switch_to_netns(vrf_id);
if (ret < 0)
- flog_err_sys(LIB_ERR_SOCKET, "%s: Can't switch to VRF %u (%s)",
+ flog_err_sys(EC_LIB_SOCKET, "%s: Can't switch to VRF %u (%s)",
__func__, vrf_id, safe_strerror(errno));
if (ret > 0 && interfacename && vrf_default_accepts_vrf(type)) {
save_errno = errno;
ret2 = vrf_switchback_to_initial();
if (ret2 < 0)
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"%s: Can't switchback from VRF %u (%s)", __func__,
vrf_id, safe_strerror(errno));
errno = save_errno;
vrfname, VRF_NAMSIZ);
else
flog_warn(
- LIB_WARN_VRF_LENGTH,
+ EC_LIB_VRF_LENGTH,
"%% VRF name %s invalid: length exceeds %d bytes\n",
vrfname, VRF_NAMSIZ);
return CMD_WARNING_CONFIG_FAILED;
ret = vrf_switch_to_netns(vrf_id);
if (ret < 0)
- flog_err_sys(LIB_ERR_SOCKET, "%s: Can't switch to VRF %u (%s)",
+ flog_err_sys(EC_LIB_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)
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"%s: Can't switchback from VRF %u (%s)", __func__,
vrf_id, safe_strerror(errno));
errno = save_errno;
ret = vrf_switch_to_netns(vrf_id);
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "%s: Can't switch to VRF %u (%s)",
+ flog_err_sys(EC_LIB_SOCKET, "%s: Can't switch to VRF %u (%s)",
__func__, vrf_id, safe_strerror(errno));
return 0;
}
saved_errno = errno;
ret = vrf_switchback_to_initial();
if (ret < 0)
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"%s: Can't switchback from VRF %u (%s)", __func__,
vrf_id, safe_strerror(errno));
errno = saved_errno;
ret = vrf_switch_to_netns(vrf_id);
if (ret < 0)
- flog_err_sys(LIB_ERR_SOCKET, "%s: Can't switch to VRF %u (%s)",
+ flog_err_sys(EC_LIB_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)
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"%s: Can't switchback from VRF %u (%s)", __func__,
vrf_id, safe_strerror(errno));
errno = save_errno;
/* Fatal I/O error. */
vty->monitor =
0; /* disable monitoring to avoid infinite recursion */
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"%s: write failed to vty client fd %d, closing: %s",
__func__, vty->fd, safe_strerror(errno));
buffer_reset(vty->obuf);
> CONSUMED_TIME_CHECK)
/* Warn about CPU hog that must be fixed. */
flog_warn(
- LIB_WARN_SLOW_THREAD,
+ EC_LIB_SLOW_THREAD,
"SLOW COMMAND: command took %lums (cpu time %lums): %s",
realtime / 1000, cputime / 1000, buf);
}
case TELOPT_NAWS:
if (vty->sb_len != TELNET_NAWS_SB_LEN)
flog_err(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"RFC 1073 violation detected: telnet NAWS option "
"should send %d characters, but we received %lu",
TELNET_NAWS_SB_LEN,
(unsigned long)vty->sb_len);
else if (sizeof(vty->sb_buf) < TELNET_NAWS_SB_LEN)
flog_err(
- LIB_ERR_DEVELOPMENT,
+ EC_LIB_DEVELOPMENT,
"Bug detected: sizeof(vty->sb_buf) %lu < %d, too small to handle the telnet NAWS option",
(unsigned long)sizeof(vty->sb_buf),
TELNET_NAWS_SB_LEN);
vty->monitor = 0; /* disable monitoring to avoid
infinite recursion */
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"%s: read error on vty client fd %d, closing: %s",
__func__, vty->fd, safe_strerror(errno));
buffer_reset(vty->obuf);
/* We can handle IPv4 or IPv6 socket. */
vty_sock = sockunion_accept(accept_sock, &su);
if (vty_sock < 0) {
- flog_err(LIB_ERR_SOCKET, "can't accept vty socket : %s",
+ flog_err(EC_LIB_SOCKET, "can't accept vty socket : %s",
safe_strerror(errno));
return -1;
}
ret = getaddrinfo(hostname, port_str, &req, &ainfo);
if (ret != 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "getaddrinfo failed: %s",
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "getaddrinfo failed: %s",
gai_strerror(ret));
exit(1);
}
/* Make UNIX domain socket. */
sock = socket(AF_UNIX, SOCK_STREAM, 0);
if (sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"Cannot create unix stream socket: %s",
safe_strerror(errno));
return;
ret = bind(sock, (struct sockaddr *)&serv, len);
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "Cannot bind path %s: %s", path,
+ flog_err_sys(EC_LIB_SOCKET, "Cannot bind path %s: %s", path,
safe_strerror(errno));
close(sock); /* Avoid sd leak. */
return;
ret = listen(sock, 5);
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "listen(fd %d) failed: %s", sock,
+ flog_err_sys(EC_LIB_SOCKET, "listen(fd %d) failed: %s", sock,
safe_strerror(errno));
close(sock); /* Avoid sd leak. */
return;
if ((int)ids.gid_vty > 0) {
/* set group of socket */
if (chown(path, -1, ids.gid_vty)) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"vty_serv_un: could chown socket, %s",
safe_strerror(errno));
}
(socklen_t *)&client_len);
if (sock < 0) {
- flog_err(LIB_ERR_SOCKET, "can't accept vty socket : %s",
+ flog_err(EC_LIB_SOCKET, "can't accept vty socket : %s",
safe_strerror(errno));
return -1;
}
if (set_nonblocking(sock) < 0) {
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"vtysh_accept: could not set vty socket %d to non-blocking, %s, closing",
sock, safe_strerror(errno));
close(sock);
case BUFFER_ERROR:
vty->monitor =
0; /* disable monitoring to avoid infinite recursion */
- flog_err(LIB_ERR_SOCKET, "%s: write error to fd %d, closing",
+ flog_err(EC_LIB_SOCKET, "%s: write error to fd %d, closing",
__func__, vty->fd);
buffer_reset(vty->lbuf);
buffer_reset(vty->obuf);
vty->monitor = 0; /* disable monitoring to avoid
infinite recursion */
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"%s: read failed on vtysh client fd %d, closing: %s",
__func__, sock, safe_strerror(errno));
}
nl = strchr(vty->error_buf, '\n');
if (nl)
*nl = '\0';
- flog_err(LIB_ERR_VTY,
+ flog_err(EC_LIB_VTY,
"ERROR: %s on config line %u: %s", message, line_num,
vty->error_buf);
}
if (!IS_DIRECTORY_SEP(config_file[0])) {
if (getcwd(cwd, MAXPATHLEN) == NULL) {
flog_err_sys(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"Failure to determine Current Working Directory %d!",
errno);
exit(1);
if (confp == NULL) {
flog_warn(
- LIB_WARN_BACKUP_CONFIG,
+ EC_LIB_BACKUP_CONFIG,
"%s: failed to open configuration file %s: %s, checking backup",
__func__, fullpath, safe_strerror(errno));
confp = vty_use_backup_config(fullpath);
if (confp)
flog_warn(
- LIB_WARN_BACKUP_CONFIG,
+ EC_LIB_BACKUP_CONFIG,
"WARNING: using backup configuration file!");
else {
- flog_err(LIB_ERR_VTY,
+ flog_err(EC_LIB_VTY,
"can't open configuration file [%s]",
config_file);
exit(1);
confp = fopen(config_default_dir, "r");
if (confp == NULL) {
flog_err(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"%s: failed to open configuration file %s: %s, checking backup",
__func__, config_default_dir,
safe_strerror(errno));
confp = vty_use_backup_config(config_default_dir);
if (confp) {
flog_warn(
- LIB_WARN_BACKUP_CONFIG,
+ EC_LIB_BACKUP_CONFIG,
"WARNING: using backup configuration file!");
fullpath = config_default_dir;
} else {
- flog_err(LIB_ERR_VTY,
+ flog_err(EC_LIB_VTY,
"can't open configuration file [%s]",
config_default_dir);
goto tmp_free_and_out;
* Hence not worrying about it too much.
*/
if (!chdir(SYSCONFDIR)) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"Failure to chdir to %s, errno: %d",
SYSCONFDIR, errno);
exit(-1);
}
if (getcwd(cwd, MAXPATHLEN) == NULL) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"Failure to getcwd, errno: %d", errno);
exit(-1);
}
switch (buffer_flush_available(zclient->wb, zclient->sock)) {
case BUFFER_ERROR:
flog_err(
- LIB_ERR_ZAPI_SOCKET,
+ EC_LIB_ZAPI_SOCKET,
"%s: buffer_flush_available failed on zclient fd %d, closing",
__func__, zclient->sock);
return zclient_failed(zclient);
STREAM_DATA(zclient->obuf),
stream_get_endp(zclient->obuf))) {
case BUFFER_ERROR:
- flog_err(LIB_ERR_ZAPI_SOCKET,
+ flog_err(EC_LIB_ZAPI_SOCKET,
"%s: buffer_write failed to zclient fd %d, closing",
__func__, zclient->sock);
return zclient_failed(zclient);
STREAM_GETW(s, *cmd);
if (*version != ZSERV_VERSION || *marker != ZEBRA_HEADER_MARKER) {
- flog_err(LIB_ERR_ZAPI_MISSMATCH,
+ flog_err(EC_LIB_ZAPI_MISSMATCH,
"%s: socket %d version mismatch, marker %d, version %d",
__func__, sock, *marker, *version);
return -1;
}
if (set_nonblocking(zclient->sock) < 0)
- flog_err(LIB_ERR_ZAPI_SOCKET, "%s: set_nonblocking(%d) failed",
+ flog_err(EC_LIB_ZAPI_SOCKET, "%s: set_nonblocking(%d) failed",
__func__, zclient->sock);
/* Clear fail count. */
prefix2str(&api->prefix, buf, sizeof(buf));
flog_err(
- LIB_ERR_ZAPI_ENCODE,
+ EC_LIB_ZAPI_ENCODE,
"%s: prefix %s: can't encode %u nexthops (maximum is %u)",
__func__, buf, api->nexthop_num, MULTIPATH_NUM);
return -1;
char buf[PREFIX2STR_BUFFER];
prefix2str(&api->prefix, buf,
sizeof(buf));
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"%s: prefix %s: can't encode "
"%u labels (maximum is %u)",
__func__, buf,
/* Type, flags, message. */
STREAM_GETC(s, api->type);
if (api->type > ZEBRA_ROUTE_MAX) {
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"%s: Specified route type: %d is not a legal value\n",
__PRETTY_FUNCTION__, api->type);
return -1;
case AF_INET:
if (api->prefix.prefixlen > IPV4_MAX_PREFIXLEN) {
flog_err(
- LIB_ERR_ZAPI_ENCODE,
+ EC_LIB_ZAPI_ENCODE,
"%s: V4 prefixlen is %d which should not be more than 32",
__PRETTY_FUNCTION__, api->prefix.prefixlen);
return -1;
case AF_INET6:
if (api->prefix.prefixlen > IPV6_MAX_PREFIXLEN) {
flog_err(
- LIB_ERR_ZAPI_ENCODE,
+ EC_LIB_ZAPI_ENCODE,
"%s: v6 prefixlen is %d which should not be more than 128",
__PRETTY_FUNCTION__, api->prefix.prefixlen);
return -1;
}
break;
default:
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"%s: Specified family %d is not v4 or v6",
__PRETTY_FUNCTION__, api->prefix.family);
return -1;
STREAM_GETC(s, api->src_prefix.prefixlen);
if (api->src_prefix.prefixlen > IPV6_MAX_PREFIXLEN) {
flog_err(
- LIB_ERR_ZAPI_ENCODE,
+ EC_LIB_ZAPI_ENCODE,
"%s: SRC Prefix prefixlen received: %d is too large",
__PRETTY_FUNCTION__, api->src_prefix.prefixlen);
return -1;
if (api->prefix.family != AF_INET6
|| api->src_prefix.prefixlen == 0) {
flog_err(
- LIB_ERR_ZAPI_ENCODE,
+ EC_LIB_ZAPI_ENCODE,
"%s: SRC prefix specified in some manner that makes no sense",
__PRETTY_FUNCTION__);
return -1;
if (CHECK_FLAG(api->message, ZAPI_MESSAGE_NEXTHOP)) {
STREAM_GETW(s, api->nexthop_num);
if (api->nexthop_num > MULTIPATH_NUM) {
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"%s: invalid number of nexthops (%u)",
__func__, api->nexthop_num);
return -1;
if (api_nh->label_num > MPLS_MAX_LABELS) {
flog_err(
- LIB_ERR_ZAPI_ENCODE,
+ EC_LIB_ZAPI_ENCODE,
"%s: invalid number of MPLS labels (%u)",
__func__, api_nh->label_num);
return -1;
}
STREAM_GETC(s, nhr->nexthops[i].label_num);
if (nhr->nexthops[i].label_num > MPLS_MAX_LABELS) {
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"%s: invalid number of MPLS labels (%u)",
__func__, nhr->nexthops[i].label_num);
return false;
/* Lookup this by interface index. */
ifp = if_lookup_by_name(ifname_tmp, vrf_id);
if (ifp == NULL) {
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"INTERFACE_STATE: Cannot find IF %s in VRF %d",
ifname_tmp, vrf_id);
return NULL;
for (i = 0; i < bwclassnum && i < MAX_CLASS_TYPE; i++)
iflp->unrsv_bw[i] = stream_getf(s);
if (i < bwclassnum)
- flog_err(LIB_ERR_ZAPI_MISSMATCH,
+ flog_err(EC_LIB_ZAPI_MISSMATCH,
"%s: received %d > %d (MAX_CLASS_TYPE) bw entries"
" - outdated library?",
__func__, bwclassnum, MAX_CLASS_TYPE);
struct interface *ifp = if_lookup_by_index(ifindex, VRF_DEFAULT);
if (ifp == NULL) {
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"%s: unknown ifindex %u, shouldn't happen", __func__,
ifindex);
return NULL;
/* Lookup index. */
ifp = if_lookup_by_index(ifindex, vrf_id);
if (ifp == NULL) {
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"INTERFACE_ADDRESS_%s: Cannot find IF %u in VRF %d",
(type == ZEBRA_INTERFACE_ADDRESS_ADD) ? "ADD" : "DEL",
ifindex, vrf_id);
* "peer" */
char buf[PREFIX_STRLEN];
flog_err(
- LIB_ERR_ZAPI_ENCODE,
+ EC_LIB_ZAPI_ENCODE,
"warning: interface %s address %s with peer flag set, but no peer address!",
ifp->name,
prefix2str(ifc->address, buf,
/* Lookup index. */
ifp = if_lookup_by_index(ifindex, vrf_id);
if (ifp == NULL) {
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"INTERFACE_NBR_%s: Cannot find IF %u in VRF %d",
(type == ZEBRA_INTERFACE_NBR_ADDRESS_ADD) ? "ADD"
: "DELETE",
/* Lookup interface. */
ifp = if_lookup_by_index(ifindex, vrf_id);
if (ifp == NULL) {
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"INTERFACE_VRF_UPDATE: Cannot find IF %u in VRF %d",
ifindex, vrf_id);
return NULL;
size);
}
if (ret != 0) {
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"%s: Invalid Sync Message Reply", __func__);
return -1;
}
ret = writen(zclient->sock, s->data, stream_get_endp(s));
if (ret < 0) {
- flog_err(LIB_ERR_ZAPI_SOCKET, "Can't write to zclient sock");
+ flog_err(EC_LIB_ZAPI_SOCKET, "Can't write to zclient sock");
close(zclient->sock);
zclient->sock = -1;
return -1;
}
if (ret == 0) {
- flog_err(LIB_ERR_ZAPI_SOCKET, "Zclient sock closed");
+ flog_err(EC_LIB_ZAPI_SOCKET, "Zclient sock closed");
close(zclient->sock);
zclient->sock = -1;
return -1;
/* sanity */
if (proto != zclient->redist_default)
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"Wrong proto (%u) in LM connect response. Should be %u",
proto, zclient->redist_default);
if (instance != zclient->instance)
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"Wrong instId (%u) in LM connect response. Should be %u",
instance, zclient->instance);
ret = writen(zclient->sock, s->data, stream_get_endp(s));
if (ret < 0) {
- flog_err(LIB_ERR_ZAPI_SOCKET,
+ flog_err(EC_LIB_ZAPI_SOCKET,
"Can't write to zclient sock");
close(zclient->sock);
zclient->sock = -1;
return -1;
}
if (ret == 0) {
- flog_err(LIB_ERR_ZAPI_SOCKET,
+ flog_err(EC_LIB_ZAPI_SOCKET,
"Zclient sock closed");
close(zclient->sock);
zclient->sock = -1;
/* sanities */
if (proto != zclient->redist_default)
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"Wrong proto (%u) in get chunk response. Should be %u",
proto, zclient->redist_default);
if (instance != zclient->instance)
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"Wrong instId (%u) in get chunk response Should be %u",
instance, zclient->instance);
/* not owning this response */
if (keep != response_keep) {
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_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) {
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"Invalid Label chunk: %u - %u", *start, *end);
return -1;
}
ret = writen(zclient->sock, s->data, stream_get_endp(s));
if (ret < 0) {
- flog_err(LIB_ERR_ZAPI_SOCKET, "Can't write to zclient sock");
+ flog_err(EC_LIB_ZAPI_SOCKET, "Can't write to zclient sock");
close(zclient->sock);
zclient->sock = -1;
return -1;
}
if (ret == 0) {
- flog_err(LIB_ERR_ZAPI_SOCKET,
+ flog_err(EC_LIB_ZAPI_SOCKET,
"Zclient sock connection closed");
close(zclient->sock);
zclient->sock = -1;
ret = writen(zclient->sock, s->data, stream_get_endp(s));
if (ret < 0) {
- flog_err(LIB_ERR_ZAPI_SOCKET,
+ flog_err(EC_LIB_ZAPI_SOCKET,
"%s: can't write to zclient->sock", __func__);
close(zclient->sock);
zclient->sock = -1;
return -1;
}
if (ret == 0) {
- flog_err(LIB_ERR_ZAPI_SOCKET,
+ flog_err(EC_LIB_ZAPI_SOCKET,
"%s: zclient->sock connection closed", __func__);
close(zclient->sock);
zclient->sock = -1;
stream_write(s, (uint8_t *)&pw->nexthop.ipv6, 16);
break;
default:
- flog_err(LIB_ERR_ZAPI_ENCODE,
+ flog_err(EC_LIB_ZAPI_ENCODE,
"%s: unknown af", __func__);
return -1;
}
command = stream_getw(zclient->ibuf);
if (marker != ZEBRA_HEADER_MARKER || version != ZSERV_VERSION) {
- flog_err(LIB_ERR_ZAPI_MISSMATCH,
+ flog_err(EC_LIB_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) {
- flog_err(LIB_ERR_ZAPI_MISSMATCH,
+ flog_err(EC_LIB_ZAPI_MISSMATCH,
"%s: socket %d message length %u is less than %d ",
__func__, zclient->sock, length, ZEBRA_HEADER_SIZE);
return zclient_failed(zclient);
if (length > STREAM_SIZE(zclient->ibuf)) {
struct stream *ns;
flog_err(
- LIB_ERR_ZAPI_ENCODE,
+ EC_LIB_ZAPI_ENCODE,
"%s: message size %u exceeds buffer size %lu, expanding...",
__func__, length,
(unsigned long)STREAM_SIZE(zclient->ibuf));
/* receive message */
len = ospf6_recvmsg(&src, &dst, &ifindex, iovector);
if (len > iobuflen) {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"Excess message read");
return 0;
}
/* send message */
len = ospf6_sendmsg(src, dst, &oi->interface->ifindex, iovector);
if (len != ntohs(oh->length))
- flog_err(LIB_ERR_DEVELOPMENT, "Could not send entire message");
+ flog_err(EC_LIB_DEVELOPMENT, "Could not send entire message");
}
static uint32_t ospf6_packet_max(struct ospf6_interface *oi)
sizeof(mreq6));
if (ret < 0) {
flog_err_sys(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"Network: setsockopt (%d) on ifindex %d failed: %s",
option, ifindex, safe_strerror(errno));
return ret;
if (link_error == 0 && num == table->count)
return;
- flog_err(LIB_ERR_DEVELOPMENT, "PANIC !!");
- flog_err(LIB_ERR_DEVELOPMENT, "Something has gone wrong with ospf6_route_table[%p]", table);
+ flog_err(EC_LIB_DEVELOPMENT, "PANIC !!");
+ flog_err(EC_LIB_DEVELOPMENT, "Something has gone wrong with ospf6_route_table[%p]", table);
zlog_debug("table count = %d, real number = %d", table->count, num);
zlog_debug("DUMP START");
for (r = ospf6_route_head(table); r; r = ospf6_route_next(r)) {
ifindex = (VERTEX_IS_TYPE(NETWORK, v) ? ospf6_spf_get_ifindex_from_nh(v)
: ROUTER_LSDESC_GET_IFID(lsdesc));
if (ifindex == 0) {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"No nexthop ifindex at vertex %s", v->name);
return;
}
ret = zclient_route_send(ZEBRA_ROUTE_ADD, zclient, &api);
if (ret < 0)
- flog_err(LIB_ERR_ZAPI_SOCKET,
+ flog_err(EC_LIB_ZAPI_SOCKET,
"zclient_route_send() %s failed: %s",
(type == REM ? "delete" : "add"),
safe_strerror(errno));
ifindex);
if (ret < 0)
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"can't setsockopt IP_ADD_MEMBERSHIP (fd %d, addr %s, "
"ifindex %u, AllSPFRouters): %s; perhaps a kernel limit "
"on # of multicast group memberships has been exceeded?",
p->u.prefix4, htonl(OSPF_ALLSPFROUTERS),
ifindex);
if (ret < 0)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"can't setsockopt IP_DROP_MEMBERSHIP (fd %d, addr %s, "
"ifindex %u, AllSPFRouters): %s",
top->fd, inet_ntoa(p->u.prefix4), ifindex,
ifindex);
if (ret < 0)
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"can't setsockopt IP_ADD_MEMBERSHIP (fd %d, addr %s, "
"ifindex %u, AllDRouters): %s; perhaps a kernel limit "
"on # of multicast group memberships has been exceeded?",
p->u.prefix4, htonl(OSPF_ALLDROUTERS),
ifindex);
if (ret < 0)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"can't setsockopt IP_DROP_MEMBERSHIP (fd %d, addr %s, "
"ifindex %u, AllDRouters): %s",
top->fd, inet_ntoa(p->u.prefix4), ifindex,
/* Prevent receiving self-origined multicast packets. */
ret = setsockopt_ipv4_multicast_loop(top->fd, 0);
if (ret < 0)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"can't setsockopt IP_MULTICAST_LOOP(0) for fd %d: %s",
top->fd, safe_strerror(errno));
ret = setsockopt(top->fd, IPPROTO_IP, IP_MULTICAST_TTL, (void *)&val,
len);
if (ret < 0)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"can't setsockopt IP_MULTICAST_TTL(1) for fd %d: %s",
top->fd, safe_strerror(errno));
#ifndef GNU_LINUX
*/
ret = setsockopt_ipv4_multicast_if(top->fd, p->u.prefix4, ifindex);
if (ret < 0)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"can't setsockopt IP_MULTICAST_IF(fd %d, addr %s, "
"ifindex %u): %s",
top->fd, inet_ntoa(p->u.prefix4), ifindex,
ospf_sock = vrf_socket(AF_INET, SOCK_RAW, IPPROTO_OSPFIGP,
ospf->vrf_id, ospf->name);
if (ospf_sock < 0) {
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"ospf_read_sock_init: socket: %s",
safe_strerror(errno));
exit(1);
ret = setsockopt(ospf_sock, IPPROTO_IP, IP_HDRINCL, &hincl,
sizeof(hincl));
if (ret < 0) {
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"Can't set IP_HDRINCL option for fd %d: %s",
ospf_sock, safe_strerror(errno));
close(ospf_sock);
ret = setsockopt_ipv4_tos(ospf_sock,
IPTOS_PREC_INTERNETCONTROL);
if (ret < 0) {
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"can't set sockopt IP_TOS %d to socket %d: %s",
tos, ospf_sock, safe_strerror(errno));
close(ospf_sock); /* Prevent sd leak. */
}
#else /* !IPTOS_PREC_INTERNETCONTROL */
#warning "IP_HDRINCL not available, nor is IPTOS_PREC_INTERNETCONTROL"
- flog_err(LIB_ERR_UNAVAILABLE,
+ flog_err(EC_LIB_UNAVAILABLE,
"IP_HDRINCL option not available");
#endif /* IP_HDRINCL */
ret = setsockopt_ifindex(AF_INET, ospf_sock, 1);
if (ret < 0)
- flog_err(LIB_ERR_SOCKET,
+ flog_err(EC_LIB_SOCKET,
"Can't set pktinfo option for fd %d",
ospf_sock);
if (ret < 0)
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"*** ospf_write_frags: sendmsg failed to %s,"
" id %d, off %d, len %d, mtu %u failed with %s",
inet_ntoa(iph->ip_dst), iph->ip_id, iph->ip_off,
if (ret < 0)
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"*** sendmsg in ospf_write failed to %s, "
"id %d, off %d, len %d, interface %s, mtu %u: %s",
inet_ntoa(iph.ip_dst), iph.ip_id, iph.ip_off,
if ((ospf_sock_init(new)) < 0) {
if (new->vrf_id != VRF_UNKNOWN)
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"%s: ospf_sock_init is unable to open a socket",
__func__);
return new;
if (!join) {
flog_err_sys(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"IGMP socket fd=%d could not join any group on interface address %s",
fd, inet_ntoa(ifaddr));
close(fd);
if (close(igmp->fd)) {
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"Failure closing IGMP socket %s fd=%d on interface %s: errno=%d: %s",
inet_ntoa(igmp->ifaddr), igmp->fd,
igmp->interface->name, errno, safe_strerror(errno));
msg_size = IGMP_V3_SOURCES_OFFSET + (num_sources << 2);
if (msg_size > query_buf_size) {
flog_err(
- LIB_ERR_DEVELOPMENT,
+ EC_LIB_DEVELOPMENT,
"%s %s: unable to send: msg_size=%zd larger than query_buf_size=%d",
__FILE__, __PRETTY_FUNCTION__, msg_size,
query_buf_size);
* changes; perhaps
* address this in the next release? - XXX */
flog_err(
- LIB_ERR_DEVELOPMENT,
+ EC_LIB_DEVELOPMENT,
"MSDP sa %s SPT teardown is causing the local entry to be removed",
sa->sg_str);
return;
/* If getsockopt is fail, this is fatal error. */
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"can't get sockopt for nonblocking connect");
pim_msdp_peer_reset_tcp_conn(mp, "connect-failed");
return;
socklen_t optlen = sizeof(optval);
if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &optval, &optlen) < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"getsockopt of SO_SNDBUF failed %s\n",
safe_strerror(errno));
return;
if (optval < size) {
if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size))
< 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"Couldn't increase send buffer: %s\n",
safe_strerror(errno));
}
/* re-register accept thread */
accept_sock = THREAD_FD(thread);
if (accept_sock < 0) {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"accept_sock is negative value %d", accept_sock);
return -1;
}
/* accept client connection. */
msdp_sock = sockunion_accept(accept_sock, &su);
if (msdp_sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "pim_msdp_sock_accept failed (%s)",
+ flog_err_sys(EC_LIB_SOCKET, "pim_msdp_sock_accept failed (%s)",
safe_strerror(errno));
return -1;
}
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "socket: %s",
+ flog_err_sys(EC_LIB_SOCKET, "socket: %s",
safe_strerror(errno));
return sock;
}
struct interface *ifp =
if_lookup_by_name(pim->vrf->name, pim->vrf_id);
if (!ifp) {
- flog_err(LIB_ERR_INTERFACE,
+ flog_err(EC_LIB_INTERFACE,
"%s: Unable to lookup vrf interface: %s",
__PRETTY_FUNCTION__, pim->vrf->name);
close(sock);
return -1;
}
if (pim_socket_bind(sock, ifp)) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"%s: Unable to bind to socket: %s",
__PRETTY_FUNCTION__, safe_strerror(errno));
close(sock);
}
if (rc < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"pim_msdp_socket bind to port %d: %s",
ntohs(sin.sin_port), safe_strerror(errno));
close(sock);
rc = listen(sock, 3 /* backlog */);
if (rc < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "pim_msdp_socket listen: %s",
+ flog_err_sys(EC_LIB_SOCKET, "pim_msdp_socket listen: %s",
safe_strerror(errno));
close(sock);
return rc;
/* Make socket for the peer. */
mp->fd = sockunion_socket(&mp->su_peer);
if (mp->fd < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"pim_msdp_socket socket failure: %s",
safe_strerror(errno));
return -1;
struct interface *ifp =
if_lookup_by_name(mp->pim->vrf->name, mp->pim->vrf_id);
if (!ifp) {
- flog_err(LIB_ERR_INTERFACE,
+ flog_err(EC_LIB_INTERFACE,
"%s: Unable to lookup vrf interface: %s",
__PRETTY_FUNCTION__, mp->pim->vrf->name);
return -1;
}
if (pim_socket_bind(mp->fd, ifp)) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"%s: Unable to bind to socket: %s",
__PRETTY_FUNCTION__, safe_strerror(errno));
close(mp->fd);
/* source bind */
rc = sockunion_bind(mp->fd, &mp->su_local, 0, &mp->su_local);
if (rc < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"pim_msdp_socket connect bind failure: %s",
safe_strerror(errno));
close(mp->fd);
if (neigh->prefix_list == addr_list) {
if (addr_list) {
flog_err(
- LIB_ERR_DEVELOPMENT,
+ EC_LIB_DEVELOPMENT,
"%s: internal error: trying to replace same prefix list=%p",
__PRETTY_FUNCTION__, (void *)addr_list);
}
rp_info = XCALLOC(MTYPE_PIM_RP, sizeof(*rp_info));
if (!str2prefix("224.0.0.0/4", &rp_info->group)) {
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"Unable to convert 224.0.0.0/4 to prefix");
list_delete_and_null(&pim->rp_list);
route_table_finish(pim->rp_table);
rn = route_node_match(pim->rp_table, group);
if (!rn) {
flog_err(
- LIB_ERR_DEVELOPMENT,
+ EC_LIB_DEVELOPMENT,
"%s: BUG We should have found default group information\n",
__PRETTY_FUNCTION__);
return best;
if (rn) {
if (rn->info != rp_info)
flog_err(
- LIB_ERR_DEVELOPMENT,
+ EC_LIB_DEVELOPMENT,
"Expected rn->info to be equal to rp_info");
if (PIM_DEBUG_TRACE) {
}
#else
flog_err(
- LIB_ERR_DEVELOPMENT,
+ EC_LIB_DEVELOPMENT,
"%s %s: Missing IP_PKTINFO and IP_RECVDSTADDR: unable to get dst addr from recvmsg()",
__FILE__, __PRETTY_FUNCTION__);
close(fd);
sprintf(ifaddr_str, "<ifaddr?>");
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"Failure socket joining fd=%d group %s on interface address %s: errno=%d: %s",
fd, group_str, ifaddr_str, errno, safe_strerror(errno));
return ret;
if (first) {
if (!str2prefix(PIM_SSM_STANDARD_RANGE, &group_ssm))
- flog_err(LIB_ERR_DEVELOPMENT,
+ flog_err(EC_LIB_DEVELOPMENT,
"%s: Failure to Read Group Address: %s",
__PRETTY_FUNCTION__, PIM_SSM_STANDARD_RANGE);
fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (fd < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"%s: could not create socket: errno=%d: %s",
__PRETTY_FUNCTION__, errno, safe_strerror(errno));
return -1;
}
#else
flog_err(
- LIB_ERR_DEVELOPMENT,
+ EC_LIB_DEVELOPMENT,
"%s %s: missing IP_PKTINFO and IP_RECVDSTADDR: unable to get dst addr from recvmsg()",
__FILE__, __PRETTY_FUNCTION__);
close(fd);
result = gettimeofday(tv, 0);
if (result) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"%s: gettimeofday() failure: errno=%d: %s",
__PRETTY_FUNCTION__, errno, safe_strerror(errno));
}
struct timeval now_tv;
if (gettime_monotonic(&now_tv)) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"%s: gettime_monotonic() failure: errno=%d: %s",
__PRETTY_FUNCTION__, errno, safe_strerror(errno));
return -1;
int64_t now_dsec;
if (gettime_monotonic(&now_tv)) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"%s: gettime_monotonic() failure: errno=%d: %s",
__PRETTY_FUNCTION__, errno, safe_strerror(errno));
return -1;
int64_t now_dsec;
if (gettime_monotonic(&now_tv)) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"%s: gettime_monotonic() failure: errno=%d: %s",
__PRETTY_FUNCTION__, errno, safe_strerror(errno));
return -1;
{
zlookup = zclient_new_notify(master, &zclient_options_default);
if (!zlookup) {
- flog_err(LIB_ERR_ZAPI_SOCKET, "%s: zclient_new() failure",
+ flog_err(EC_LIB_ZAPI_SOCKET, "%s: zclient_new() failure",
__PRETTY_FUNCTION__);
return;
}
err = zclient_read_header(s, zlookup->sock, &length, &marker,
&version, &vrf_id, &command);
if (err < 0) {
- flog_err(LIB_ERR_ZAPI_MISSMATCH,
+ flog_err(EC_LIB_ZAPI_MISSMATCH,
"%s: zclient_read_header() failed",
__PRETTY_FUNCTION__);
zclient_lookup_failed(zlookup);
/* Check socket. */
if (zlookup->sock < 0) {
- flog_err(LIB_ERR_ZAPI_SOCKET,
+ flog_err(EC_LIB_ZAPI_SOCKET,
"%s: zclient lookup socket is not connected",
__PRETTY_FUNCTION__);
zclient_lookup_failed(zlookup);
ret = writen(zlookup->sock, s->data, stream_get_endp(s));
if (ret < 0) {
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"%s: writen() failure: %d writing to zclient lookup socket",
__PRETTY_FUNCTION__, errno);
zclient_lookup_failed(zlookup);
return -2;
}
if (ret == 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"%s: connection closed on zclient lookup socket",
__PRETTY_FUNCTION__);
zclient_lookup_failed(zlookup);
ret = writen(zlookup->sock, s->data, count);
if (ret <= 0) {
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"%s: writen() failure: %d writing to zclient lookup socket",
__PRETTY_FUNCTION__, errno);
return -1;
err = zclient_read_header(s, zlookup->sock, &length, &marker,
&version, &vrf_id, &command);
if (err < 0) {
- flog_err(LIB_ERR_ZAPI_MISSMATCH,
+ flog_err(EC_LIB_ZAPI_MISSMATCH,
"%s: zclient_read_header() failed",
__PRETTY_FUNCTION__);
zclient_lookup_failed(zlookup);
more.src = c_oil->oil.mfcc_origin;
more.grp = c_oil->oil.mfcc_mcastgrp;
flog_err(
- LIB_ERR_ZAPI_MISSMATCH,
+ EC_LIB_ZAPI_MISSMATCH,
"%s: Received wrong %s(%s) information requested",
__PRETTY_FUNCTION__, pim_str_sg_dump(&more),
c_oil->pim->vrf->name);
{
if (!inet_aton(PIM_ALL_PIM_ROUTERS, &qpim_all_pim_routers_addr)) {
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"%s %s: could not solve %s to group address: errno=%d: %s",
__FILE__, __PRETTY_FUNCTION__, PIM_ALL_PIM_ROUTERS,
errno, safe_strerror(errno));
/* Join to multicast group. */
if (rip_multicast_join(ifp, rip->sock) < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"multicast join failed, interface %s not running",
ifp->name);
return 0;
/* Make datagram socket. */
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
+ flog_err_sys(EC_LIB_SOCKET, "Cannot create UDP socket: %s",
safe_strerror(errno));
exit(1);
}
/* Join to multicast group. */
if (ripng_multicast_join(ifp) < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"multicast join failed, interface %s not running",
ifp->name);
return 0;
sock = socket(AF_INET6, SOCK_DGRAM, 0);
if (sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "Can't make ripng socket");
+ flog_err_sys(EC_LIB_SOCKET, "Can't make ripng socket");
return sock;
}
if (ret < 0) {
if (to)
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"RIPng send fail on %s to %s: %s",
ifp->name, inet6_ntoa(to->sin6_addr),
safe_strerror(errno));
else
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"RIPng send fail on %s: %s", ifp->name,
safe_strerror(errno));
}
switch (child = fork()) {
case -1:
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"fork failed, cannot run command [%s]: %s",
shell_cmd, safe_strerror(errno));
return -1;
char dashc[] = "-c";
char *const argv[4] = {shell, dashc, shell_cmd, NULL};
execv("/bin/sh", argv);
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"execv(/bin/sh -c '%s') failed: %s",
shell_cmd, safe_strerror(errno));
_exit(127);
}
default:
/* Parent process: we will reap the child later. */
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"Forked background command [pid %d]: %s",
(int)child, shell_cmd);
return child;
switch (child = waitpid(-1, &status, WNOHANG)) {
case -1:
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "waitpid failed: %s",
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "waitpid failed: %s",
safe_strerror(errno));
return;
case 0:
gettimeofday(&restart->time, NULL);
} else {
flog_err_sys(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"waitpid returned status for an unknown child process %d",
(int)child);
name = "(unknown)";
name, (int)child);
} else
flog_err_sys(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"cannot interpret %s %s process %d wait status 0x%x",
what, name, (int)child, status);
phase_check();
of creating a socket. */
if (access(addr.sun_path, W_OK) < 0) {
if (errno != ENOENT)
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"%s: access to socket %s denied: %s",
dmn->name, addr.sun_path,
safe_strerror(errno));
}
if ((sock = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "%s(%s): cannot make socket: %s",
+ flog_err_sys(EC_LIB_SOCKET, "%s(%s): cannot make socket: %s",
__func__, addr.sun_path, safe_strerror(errno));
return -1;
}
if (set_nonblocking(sock) < 0 || set_cloexec(sock) < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"%s(%s): set_nonblocking/cloexec(%d) failed",
__func__, addr.sun_path, sock);
close(sock);
/* Normally SIOCGIFCONF works with AF_INET socket. */
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"Can't make AF_INET socket stream: %s",
safe_strerror(errno));
return -1;
ret = ioctl(sock, SIOCGIFCONF, &ifconf);
if (ret < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "SIOCGIFCONF: %s",
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "SIOCGIFCONF: %s",
safe_strerror(errno));
goto end;
}
ret = getifaddrs(&ifap);
if (ret != 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "getifaddrs(): %s",
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "getifaddrs(): %s",
safe_strerror(errno));
return -1;
}
for (ifapfree = ifap; ifap; ifap = ifap->ifa_next) {
if (ifap->ifa_addr == NULL) {
flog_err(
- LIB_ERR_INTERFACE,
+ EC_LIB_INTERFACE,
"%s: nonsensical ifaddr with NULL ifa_addr, ifname %s",
__func__,
(ifap->ifa_name ? ifap->ifa_name : "(null)"));
ifp = if_lookup_by_name(ifap->ifa_name, VRF_DEFAULT);
if (ifp == NULL) {
- flog_err(LIB_ERR_INTERFACE,
+ flog_err(EC_LIB_INTERFACE,
"if_getaddrs(): Can't lookup interface %s\n",
ifap->ifa_name);
continue;
}
if (sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "Can't make %s socket stream: %s",
+ flog_err_sys(EC_LIB_SOCKET, "Can't make %s socket stream: %s",
(af == AF_INET ? "AF_INET" : "AF_INET6"),
safe_strerror(errno));
return -1;
}
if (ret < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"interface_list_ioctl: SIOCGLIFNUM failed %s",
safe_strerror(errno));
close(sock);
if (errno == EINVAL)
goto calculate_lifc_len;
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "SIOCGLIFCONF: %s",
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "SIOCGLIFCONF: %s",
safe_strerror(errno));
goto end;
}
ret = -1;
if (ret < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "SIOCGLIFINDEX(%s) failed",
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "SIOCGLIFINDEX(%s) failed",
ifp->name);
return ret;
}
if (ret < 0) {
if (errno != EADDRNOTAVAIL) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"SIOCGLIFNETMASK (%s) fail: %s",
ifp->name, safe_strerror(errno));
return ret;
if (ifp->flags & IFF_POINTOPOINT)
prefixlen = IPV6_MAX_BITLEN;
else
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"SIOCGLIFSUBNET (%s) fail: %s",
ifp->name, safe_strerror(errno));
} else {
&& (oifp != ifp)) {
if (ifi_index == IFINDEX_INTERNAL)
flog_err(
- LIB_ERR_INTERFACE,
+ EC_LIB_INTERFACE,
"Netlink is setting interface %s ifindex to reserved internal value %u",
ifp->name, ifi_index);
else {
ifi_index, oifp->name, ifp->name);
if (if_is_up(oifp))
flog_err(
- LIB_ERR_INTERFACE,
+ EC_LIB_INTERFACE,
"interface rename detected on up interface: index %d was renamed from %s to %s, results are uncertain!",
ifi_index, oifp->name, ifp->name);
if_delete_update(oifp);
vrf = vrf_get((vrf_id_t)ifi->ifi_index,
name); // It would create vrf
if (!vrf) {
- flog_err(LIB_ERR_INTERFACE, "VRF %s id %u not created",
+ flog_err(EC_LIB_INTERFACE, "VRF %s id %u not created",
name, ifi->ifi_index);
return;
}
/* Enable the created VRF. */
if (!vrf_enable(vrf)) {
- flog_err(LIB_ERR_INTERFACE,
+ flog_err(EC_LIB_INTERFACE,
"Failed to enable VRF %s id %u", name,
ifi->ifi_index);
return;
ifp = if_lookup_by_index_per_ns(zns, ifa->ifa_index);
if (ifp == NULL) {
flog_err(
- LIB_ERR_INTERFACE,
+ EC_LIB_INTERFACE,
"netlink_interface_addr can't find interface by index %d",
ifa->ifa_index);
return -1;
if (if_is_up(ifp)) {
flog_err(
- LIB_ERR_INTERFACE,
+ EC_LIB_INTERFACE,
"interface %s vrf %u index %d is still up while being deleted.",
ifp->name, ifp->vrf_id, ifp->ifindex);
return;
ret = vrf_if_ioctl(SIOCGIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);
if (ret < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"vrf_if_ioctl(SIOCGIFFLAGS) failed: %s",
safe_strerror(errno));
return;
/* Seems not all interfaces implement this ioctl */
if (if_ioctl(SIOCGIFMEDIA, (caddr_t)&ifmr) < 0)
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"if_ioctl(SIOCGIFMEDIA) failed: %s",
safe_strerror(errno));
else if (ifmr.ifm_status & IFM_AVALID) /* Link state is valid */
{
char addrbuf[PREFIX_STRLEN];
- flog_warn(LIB_ERR_DEVELOPMENT, "Can't set %s on interface %s",
+ flog_warn(EC_LIB_DEVELOPMENT, "Can't set %s on interface %s",
prefix2str(ifc->address, addrbuf, sizeof(addrbuf)),
ifp->name);
{
char addrbuf[PREFIX_STRLEN];
- flog_warn(LIB_ERR_DEVELOPMENT, "Can't delete %s on interface %s",
+ flog_warn(EC_LIB_DEVELOPMENT, "Can't delete %s on interface %s",
prefix2str(ifc->address, addrbuf, sizeof(addrbuf)),
ifp->name);
else if (cmd == ND_GET)
snprintf(nd_buf, ND_BUFFER_SIZE, "%s", parameter);
else {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"internal error - inappropriate command given to "
"solaris_nd()%s:%d",
__FILE__, __LINE__);
frr_elevate_privs(&zserv_privs) {
if ((fd = open(device, O_RDWR)) < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"failed to open device %s - %s", device,
safe_strerror(errno));
return -1;
}
if (ioctl(fd, I_STR, &strioctl) < 0) {
close(fd);
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"ioctl I_STR failed on device %s - %s",
device, safe_strerror(errno));
return -1;
len = sizeof ipforwarding;
if (sysctl(mib, MIB_SIZ, &ipforwarding, &len, 0, 0) < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "Can't get ipforwarding value");
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "Can't get ipforwarding value");
return -1;
}
return ipforwarding;
len = sizeof ipforwarding;
frr_elevate_privs(&zserv_privs) {
if (sysctl(mib, MIB_SIZ, NULL, NULL, &ipforwarding, len) < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"Can't set ipforwarding on");
return -1;
}
len = sizeof ipforwarding;
frr_elevate_privs(&zserv_privs) {
if (sysctl(mib, MIB_SIZ, NULL, NULL, &ipforwarding, len) < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"Can't set ipforwarding on");
return -1;
}
len = sizeof ip6forwarding;
frr_elevate_privs(&zserv_privs) {
if (sysctl(mib_ipv6, MIB_SIZ, &ip6forwarding, &len, 0, 0) < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"can't get ip6forwarding value");
return -1;
}
frr_elevate_privs(&zserv_privs) {
if (sysctl(mib_ipv6, MIB_SIZ, NULL, NULL, &ip6forwarding, len)
< 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"can't get ip6forwarding value");
return -1;
}
frr_elevate_privs(&zserv_privs) {
if (sysctl(mib_ipv6, MIB_SIZ, NULL, NULL, &ip6forwarding, len)
< 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"can't get ip6forwarding value");
return -1;
}
ret = setsockopt(sock, IPPROTO_IP, add_leave, (char *)&m,
sizeof(struct ip_mreq));
if (ret < 0)
- flog_err_sys(LIB_ERR_SOCKET, "IRDP: %s can't setsockopt %s: %s",
+ flog_err_sys(EC_LIB_SOCKET, "IRDP: %s can't setsockopt %s: %s",
add_leave == IP_ADD_MEMBERSHIP ? "join group"
: "leave group",
inet_2a(group, b1), safe_strerror(errno));
}
if (sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"IRDP: can't create irdp socket %s",
safe_strerror(save_errno));
return sock;
i = 1;
ret = setsockopt(sock, IPPROTO_IP, IP_TTL, (void *)&i, sizeof(i));
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "IRDP: can't do irdp sockopt %s",
+ flog_err_sys(EC_LIB_SOCKET, "IRDP: can't do irdp sockopt %s",
safe_strerror(errno));
close(sock);
return ret;
ret = setsockopt_ifindex(AF_INET, sock, 1);
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "IRDP: can't do irdp sockopt %s",
+ flog_err_sys(EC_LIB_SOCKET, "IRDP: can't do irdp sockopt %s",
safe_strerror(errno));
close(sock);
return ret;
ret = recvmsg(sock, &msg, 0);
if (ret < 0) {
- flog_warn(LIB_ERR_SOCKET, "IRDP: recvmsg: read error %s",
+ flog_warn(EC_LIB_SOCKET, "IRDP: recvmsg: read error %s",
safe_strerror(errno));
return ret;
}
if (msg.msg_flags & MSG_TRUNC) {
- flog_warn(LIB_ERR_SOCKET, "IRDP: recvmsg: truncated message");
+ flog_warn(EC_LIB_SOCKET, "IRDP: recvmsg: truncated message");
return ret;
}
if (msg.msg_flags & MSG_CTRUNC) {
- flog_warn(LIB_ERR_SOCKET,
+ flog_warn(EC_LIB_SOCKET,
"IRDP: recvmsg: truncated control message");
return ret;
}
ret = irdp_recvmsg(irdp_sock, (uint8_t *)buf, IRDP_RX_BUF, &ifindex);
if (ret < 0)
- flog_warn(LIB_ERR_SOCKET, "IRDP: RX Error length = %d", ret);
+ flog_warn(EC_LIB_SOCKET, "IRDP: RX Error length = %d", ret);
ifp = if_lookup_by_index(ifindex, VRF_DEFAULT);
if (!ifp)
ret = getsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &oldsize, &oldlen);
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"Can't get %s receive buffer size: %s", nl->name,
safe_strerror(errno));
return -1;
ret = setsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF,
&nl_rcvbufsize, sizeof(nl_rcvbufsize));
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"Can't set %s receive buffer size: %s", nl->name,
safe_strerror(errno));
return -1;
ret = getsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &newsize, &newlen);
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"Can't get %s receive buffer size: %s", nl->name,
safe_strerror(errno));
return -1;
namelen = sizeof snl;
ret = getsockname(sock, (struct sockaddr *)&snl, (socklen_t *)&namelen);
if (ret < 0 || namelen != sizeof snl) {
- flog_err_sys(LIB_ERR_SOCKET, "Can't get %s socket name: %s",
+ flog_err_sys(EC_LIB_SOCKET, "Can't get %s socket name: %s",
nl->name, safe_strerror(errno));
close(sock);
return -1;
if (setsockopt(sock, SOL_SOCKET, SO_ATTACH_FILTER, &prog, sizeof(prog))
< 0)
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"Can't install socket filter: %s\n",
safe_strerror(errno));
}
}
if (status == 0) {
- flog_err_sys(LIB_ERR_SOCKET, "%s EOF", nl->name);
+ flog_err_sys(EC_LIB_SOCKET, "%s EOF", nl->name);
return -1;
}
}
if (status < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "netlink_talk sendmsg() error: %s",
+ flog_err_sys(EC_LIB_SOCKET, "netlink_talk sendmsg() error: %s",
safe_strerror(save_errno));
return -1;
}
/* Check netlink socket. */
if (nl->sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "%s socket isn't active.",
+ flog_err_sys(EC_LIB_SOCKET, "%s socket isn't active.",
nl->name);
return -1;
}
/* Register kernel socket. */
if (fcntl(zns->netlink.sock, F_SETFL, O_NONBLOCK) < 0)
- flog_err_sys(LIB_ERR_SOCKET, "Can't set %s socket flags: %s",
+ flog_err_sys(EC_LIB_SOCKET, "Can't set %s socket flags: %s",
zns->netlink.name, safe_strerror(errno));
if (fcntl(zns->netlink_cmd.sock, F_SETFL, O_NONBLOCK) < 0)
if (errno == ESRCH)
return ZEBRA_ERR_RTNOEXIST;
- flog_err_sys(LIB_ERR_SOCKET, "%s: write : %s (%d)", __func__,
+ flog_err_sys(EC_LIB_SOCKET, "%s: write : %s (%d)", __func__,
safe_strerror(errno), errno);
return ZEBRA_ERR_KERNEL;
}
if (nbytes <= 0) {
if (nbytes < 0 && errno != EWOULDBLOCK && errno != EAGAIN)
- flog_err_sys(LIB_ERR_SOCKET, "routing socket error: %s",
+ flog_err_sys(EC_LIB_SOCKET, "routing socket error: %s",
safe_strerror(errno));
return 0;
}
}
if (routing_sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"Can't init kernel routing socket");
return;
}
case ZEBRA_ERR_RTEXIST:
if (cmd != RTM_ADD)
flog_err(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"%s: rtm_write() returned %d for command %d",
__func__, error, cmd);
continue;
case ZEBRA_ERR_RTUNREACH:
default:
flog_err(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"%s: %s: rtm_write() unexpectedly returned %d for command %s",
__func__,
prefix2str(p, prefix_buf,
ret = sendmsg(sock, &msg, 0);
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"%s(%u): Tx RA failed, socket %u error %d (%s)",
ifp->name, ifp->ifindex, sock, errno,
safe_strerror(errno));
&hoplimit);
if (len < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"RA/RS recv failed, socket %u error %s", sock,
safe_strerror(errno));
return len;
ret = setsockopt(sock, IPPROTO_IPV6, IPV6_JOIN_GROUP, (char *)&mreq,
sizeof mreq);
if (ret < 0)
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"%s(%u): Failed to join group, socket %u error %s",
ifp->name, ifp->ifindex, sock,
safe_strerror(errno));
sizeof mreq);
if (ret < 0)
flog_err_sys(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"%s(%u): Failed to leave group, socket %u error %s",
ifp->name, ifp->ifindex, sock, safe_strerror(errno));
int flags, dev, retval, process;
if ((dev = open(_PATH_GETMSG_ROUTE, O_RDWR)) == -1) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "can't open %s: %s",
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "can't open %s: %s",
_PATH_GETMSG_ROUTE, safe_strerror(errno));
return;
}
flags = 0;
if (putmsg(dev, &msgdata, NULL, flags) == -1) {
- flog_err_sys(LIB_ERR_SOCKET, "putmsg failed: %s",
+ flog_err_sys(EC_LIB_SOCKET, "putmsg failed: %s",
safe_strerror(errno));
goto exit;
}
retval = getmsg(dev, &msgdata, NULL, &flags);
if (retval == -1) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"getmsg(ctl) failed: %s",
safe_strerror(errno));
goto exit;
retval = getmsg(dev, NULL, &msgdata, &flags);
if (retval == -1) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"getmsg(data) failed: %s",
safe_strerror(errno));
goto exit;
enum dp_req_result kernel_add_pbr_rule(struct zebra_pbr_rule *rule)
{
- flog_err(LIB_ERR_UNAVAILABLE, "%s not Implemented for this platform",
+ flog_err(EC_LIB_UNAVAILABLE, "%s not Implemented for this platform",
__PRETTY_FUNCTION__);
return DP_REQUEST_FAILURE;
}
enum dp_req_result kernel_del_pbr_rule(struct zebra_pbr_rule *rule)
{
- flog_err(LIB_ERR_UNAVAILABLE, "%s not Implemented for this platform",
+ flog_err(EC_LIB_UNAVAILABLE, "%s not Implemented for this platform",
__PRETTY_FUNCTION__);
return DP_REQUEST_FAILURE;
}
}
if (ret == -1)
- flog_err_sys(LIB_ERR_SOCKET, "%s: %s", __func__,
+ flog_err_sys(EC_LIB_SOCKET, "%s: %s", __func__,
safe_strerror(errno));
return ret;
}
if (ret == -1)
- flog_err_sys(LIB_ERR_SOCKET, "%s: %s", __func__,
+ flog_err_sys(EC_LIB_SOCKET, "%s: %s", __func__,
safe_strerror(errno));
return ret;
strlcpy(ifr.ifr_name, pw->ifname, sizeof(ifr.ifr_name));
ifr.ifr_data = (caddr_t)&imr;
if (ioctl(kr_state.ioctl_fd, SIOCSETMPWCFG, &ifr) == -1) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "ioctl SIOCSETMPWCFG: %s",
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "ioctl SIOCSETMPWCFG: %s",
safe_strerror(errno));
return -1;
}
strlcpy(ifr.ifr_name, pw->ifname, sizeof(ifr.ifr_name));
ifr.ifr_data = (caddr_t)&imr;
if (ioctl(kr_state.ioctl_fd, SIOCSETMPWCFG, &ifr) == -1) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL, "ioctl SIOCSETMPWCFG: %s",
+ flog_err_sys(EC_LIB_SYSTEM_CALL, "ioctl SIOCSETMPWCFG: %s",
safe_strerror(errno));
return -1;
}
socklen_t optlen;
if ((kr_state.fd = socket(AF_ROUTE, SOCK_RAW, 0)) == -1) {
- flog_err_sys(LIB_ERR_SOCKET, "%s: socket", __func__);
+ flog_err_sys(EC_LIB_SOCKET, "%s: socket", __func__);
return -1;
}
if ((kr_state.ioctl_fd = socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, 0))
== -1) {
- flog_err_sys(LIB_ERR_SOCKET, "%s: ioctl socket", __func__);
+ flog_err_sys(EC_LIB_SOCKET, "%s: ioctl socket", __func__);
return -1;
}
if (getsockopt(kr_state.fd, SOL_SOCKET, SO_RCVBUF, &default_rcvbuf,
&optlen)
== -1)
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"kr_init getsockopt SOL_SOCKET SO_RCVBUF");
else
for (rcvbuf = MAX_RTSOCK_BUF;
ret = sendto(sock, (const void *)nlh, (size_t)nlh->nlmsg_len, 0,
(struct sockaddr *)&snl, (socklen_t)sizeof(snl));
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "netlink( %u) sendmsg() error: %s",
+ flog_err_sys(EC_LIB_SOCKET, "netlink( %u) sendmsg() error: %s",
sock, safe_strerror(errno));
return -1;
}
};
ret = recvmsg(sock, &msg, 0);
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"netlink recvmsg: error %d (errno %u)", ret,
errno);
return -1;
/* netlink socket */
sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "netlink( %u) socket() error: %s",
+ flog_err_sys(EC_LIB_SOCKET, "netlink( %u) socket() error: %s",
sock, safe_strerror(errno));
close(fd);
return NS_UNKNOWN;
snl.nl_pid = 0; /* AUTO PID */
ret = bind(sock, (struct sockaddr *)&snl, sizeof(snl));
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"netlink( %u) socket() bind error: %s", sock,
safe_strerror(errno));
close(sock);
if (ret <= 0) {
if (errno != EEXIST && ret != 0) {
flog_err(
- LIB_ERR_SOCKET,
+ EC_LIB_SOCKET,
"netlink( %u) recvfrom() error 2 when reading: %s",
fd, safe_strerror(errno));
close(sock);
DIR *srcdir = opendir(NS_RUN_DIR);
if (srcdir == NULL) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"NS parsing init: failed to parse %s", NS_RUN_DIR);
return;
}
continue;
if (fstatat(dirfd(srcdir), dent->d_name, &st, 0) < 0) {
flog_err_sys(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"NS parsing init: failed to parse entry %s",
dent->d_name);
continue;
fd_monitor = inotify_init();
if (fd_monitor < 0) {
flog_err_sys(
- LIB_ERR_SYSTEM_CALL,
+ EC_LIB_SYSTEM_CALL,
"NS notify init: failed to initialize inotify (%s)",
safe_strerror(errno));
}
if (inotify_add_watch(fd_monitor, NS_RUN_DIR,
IN_CREATE | IN_DELETE) < 0) {
- flog_err_sys(LIB_ERR_SYSTEM_CALL,
+ flog_err_sys(EC_LIB_SYSTEM_CALL,
"NS notify watch: failed to add watch (%s)",
safe_strerror(errno));
}
switch (buffer_flush_available(ptm_cb.wb, ptm_cb.ptm_sock)) {
case BUFFER_ERROR:
- flog_err_sys(LIB_ERR_SOCKET, "%s ptm socket error: %s",
+ flog_err_sys(EC_LIB_SOCKET, "%s ptm socket error: %s",
__func__, safe_strerror(errno));
close(ptm_cb.ptm_sock);
ptm_cb.ptm_sock = -1;
errno = 0;
switch (buffer_write(ptm_cb.wb, ptm_cb.ptm_sock, data, size)) {
case BUFFER_ERROR:
- flog_err_sys(LIB_ERR_SOCKET, "%s ptm socket error: %s",
+ flog_err_sys(EC_LIB_SOCKET, "%s ptm socket error: %s",
__func__, safe_strerror(errno));
close(ptm_cb.ptm_sock);
ptm_cb.ptm_sock = -1;
if (((rc == 0) && !errno)
|| (errno && (errno != EWOULDBLOCK) && (errno != EAGAIN))) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"%s routing socket error: %s(%d) bytes %d",
__func__, safe_strerror(errno), errno, rc);
client_sock = accept(accept_sock, (struct sockaddr *)&client, &len);
if (client_sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "Can't accept zebra socket: %s",
+ flog_err_sys(EC_LIB_SOCKET, "Can't accept zebra socket: %s",
safe_strerror(errno));
return -1;
}
/* Make UNIX domain socket. */
zebrad.sock = socket(sa.ss_family, SOCK_STREAM, 0);
if (zebrad.sock < 0) {
- flog_err_sys(LIB_ERR_SOCKET, "Can't create zserv socket: %s",
+ flog_err_sys(EC_LIB_SOCKET, "Can't create zserv socket: %s",
safe_strerror(errno));
return;
}
ret = bind(zebrad.sock, (struct sockaddr *)&sa, sa_len);
}
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"Can't bind zserv socket on %s: %s", path,
safe_strerror(errno));
close(zebrad.sock);
ret = listen(zebrad.sock, 5);
if (ret < 0) {
- flog_err_sys(LIB_ERR_SOCKET,
+ flog_err_sys(EC_LIB_SOCKET,
"Can't listen to zserv socket %s: %s", path,
safe_strerror(errno));
close(zebrad.sock);
projects / mirror_frr.git / commitdiff