if (babel_ifp->ipv4 == NULL) {
babel_ifp->ipv4 = malloc(4);
if (babel_ifp->ipv4 == NULL) {
- zlog_ferr(BABEL_ERR_MEMORY, "not enough memory");
+ flog_err(BABEL_ERR_MEMORY, "not enough memory");
} else {
memcpy(babel_ifp->ipv4, &prefix->u.prefix4, 4);
}
tmp = babel_ifp->sendbuf;
babel_ifp->sendbuf = realloc(babel_ifp->sendbuf, babel_ifp->bufsize);
if(babel_ifp->sendbuf == NULL) {
- zlog_ferr(BABEL_ERR_MEMORY, "Couldn't reallocate sendbuf.");
+ flog_err(BABEL_ERR_MEMORY, "Couldn't reallocate sendbuf.");
free(tmp);
babel_ifp->bufsize = 0;
return -1;
rc = setsockopt(protocol_socket, IPPROTO_IPV6, IPV6_JOIN_GROUP,
(char*)&mreq, sizeof(mreq));
if(rc < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_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)
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"setsockopt(IPV6_LEAVE_GROUP) on interface '%s': %s",
ifp->name, safe_strerror(errno));
}
}
route_stream_done(routes);
} else {
- zlog_ferr(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
+ flog_err(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
}
xroutes = xroute_stream();
if(xroutes) {
}
xroute_stream_done(xroutes);
} else {
- zlog_ferr(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
+ flog_err(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
}
return CMD_SUCCESS;
}
}
route_stream_done(routes);
} else {
- zlog_ferr(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
+ flog_err(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
}
xroutes = xroute_stream();
if(xroutes) {
}
xroute_stream_done(xroutes);
} else {
- zlog_ferr(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
+ flog_err(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
}
return CMD_SUCCESS;
}
}
route_stream_done(routes);
} else {
- zlog_ferr(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
+ flog_err(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
}
xroutes = xroute_stream();
if(xroutes) {
}
xroute_stream_done(xroutes);
} else {
- zlog_ferr(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
+ flog_err(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
}
return CMD_SUCCESS;
}
}
route_stream_done(routes);
} else {
- zlog_ferr(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
+ flog_err(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
}
xroutes = xroute_stream();
if(xroutes) {
}
xroute_stream_done(xroutes);
} else {
- zlog_ferr(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
+ flog_err(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
}
return CMD_SUCCESS;
}
rc = read_random_bytes(&seed, sizeof(seed));
if(rc < 0) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL, "read(random): %s",
+ flog_err(LIB_ERR_SYSTEM_CALL, "read(random): %s",
safe_strerror(errno));
seed = 42;
}
fd_null = open("/dev/null", O_RDONLY);
if(fd_null < 0) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL, "open(null): %s", safe_strerror(errno));
+ flog_err(LIB_ERR_SYSTEM_CALL, "open(null): %s", safe_strerror(errno));
exit(1);
}
rc = dup2(fd_null, fd);
if(rc < 0) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL, "dup2(null, 0): %s",
+ flog_err(LIB_ERR_SYSTEM_CALL, "dup2(null, 0): %s",
safe_strerror(errno));
exit(1);
}
fd = open(state_file, O_RDONLY);
if(fd < 0 && errno != ENOENT)
- zlog_ferr(LIB_ERR_SYSTEM_CALL, "open(babel-state: %s)",
+ flog_err(LIB_ERR_SYSTEM_CALL, "open(babel-state: %s)",
safe_strerror(errno));
rc = unlink(state_file);
if(fd >= 0 && rc < 0) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL, "unlink(babel-state): %s",
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL, "read(babel-state): %s",
+ flog_err(LIB_ERR_SYSTEM_CALL, "read(babel-state): %s",
safe_strerror(errno));
} else {
buf[rc] = '\0';
unsigned char sid[8];
rc = parse_eui64(buf2, sid);
if(rc < 0) {
- zlog_ferr(BABEL_ERR_CONFIG, "Couldn't parse babel-state.");
+ flog_err(BABEL_ERR_CONFIG, "Couldn't parse babel-state.");
} else {
struct timeval realnow;
debugf(BABEL_DEBUG_COMMON,
if(memcmp(sid, myid, 8) == 0)
myseqno = seqno_plus(s, 1);
else
- zlog_ferr(BABEL_ERR_CONFIG,
+ flog_err(BABEL_ERR_CONFIG,
"ID mismatch in babel-state. id=%s; old=%s",
format_eui64(myid),
format_eui64(sid));
}
} else {
- zlog_ferr(BABEL_ERR_CONFIG, "Couldn't parse babel-state.");
+ flog_err(BABEL_ERR_CONFIG, "Couldn't parse babel-state.");
}
}
goto fini;
debugf(BABEL_DEBUG_COMMON, "Save state file.");
fd = open(state_file, O_WRONLY | O_TRUNC | O_CREAT, 0644);
if(fd < 0) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL, "creat(babel-state): %s",
+ flog_err(LIB_ERR_SYSTEM_CALL, "creat(babel-state): %s",
safe_strerror(errno));
unlink(state_file);
} else {
format_eui64(myid), (int)myseqno,
(long)realnow.tv_sec);
if(rc < 0 || rc >= 100) {
- zlog_ferr(BABEL_ERR_CONFIG, "write(babel-state): overflow.");
+ flog_err(BABEL_ERR_CONFIG, "write(babel-state): overflow.");
unlink(state_file);
} else {
rc = write(fd, buf, rc);
if(rc < 0) {
- zlog_ferr(BABEL_ERR_CONFIG, "write(babel-state): %s",
+ flog_err(BABEL_ERR_CONFIG, "write(babel-state): %s",
safe_strerror(errno));
unlink(state_file);
}
/* Make socket for Babel protocol. */
protocol_socket = babel_socket(protocol_port);
if (protocol_socket < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "Couldn't create link local socket: %s",
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_SOCKET, "recv: %s", safe_strerror(errno));
+ flog_err(LIB_ERR_SOCKET, "recv: %s", safe_strerror(errno));
}
} else {
FOR_ALL_INTERFACES(vrf, ifp) {
return;
}
- zlog_ferr(BABEL_ERR_CONFIG,
+ flog_err(BABEL_ERR_CONFIG,
"Warning: couldn't find router id -- using random value.");
rc = read_random_bytes(myid, 8);
if(rc < 0) {
- zlog_ferr(BABEL_ERR_CONFIG, "read(random): %s (cannot assign an ID)",
+ flog_err(BABEL_ERR_CONFIG, "read(random): %s (cannot assign an ID)",
safe_strerror(errno));
exit(1);
}
if(receive_buffer == NULL) {
receive_buffer = malloc(size);
if(receive_buffer == NULL) {
- zlog_ferr(BABEL_ERR_MEMORY, "malloc(receive_buffer): %s",
+ flog_err(BABEL_ERR_MEMORY, "malloc(receive_buffer): %s",
safe_strerror(errno));
return -1;
}
unsigned char *new;
new = realloc(receive_buffer, size);
if(new == NULL) {
- zlog_ferr(BABEL_ERR_MEMORY, "realloc(receive_buffer): %s",
+ flog_err(BABEL_ERR_MEMORY, "realloc(receive_buffer): %s",
safe_strerror(errno));
return -1;
}
}
if(i + 1 > alen) {
- zlog_ferr(BABEL_ERR_PACKET, "Received truncated attributes.");
+ flog_err(BABEL_ERR_PACKET, "Received truncated attributes.");
return;
}
len = a[i + 1];
if(i + len > alen) {
- zlog_ferr(BABEL_ERR_PACKET, "Received truncated attributes.");
+ flog_err(BABEL_ERR_PACKET, "Received truncated attributes.");
return;
}
/* Nothing. */
} else if(type == SUBTLV_DIVERSITY) {
if(len > DIVERSITY_HOPS) {
- zlog_ferr(BABEL_ERR_PACKET,
+ flog_err(BABEL_ERR_PACKET,
"Received overlong channel information (%d > %d).n",
len, DIVERSITY_HOPS);
len = DIVERSITY_HOPS;
}
if(memchr(a + i + 2, 0, len) != NULL) {
/* 0 is reserved. */
- zlog_ferr(BABEL_ERR_PACKET, "Channel information contains 0!");
+ flog_err(BABEL_ERR_PACKET, "Channel information contains 0!");
return;
}
memset(channels, 0, DIVERSITY_HOPS);
}
if(i + 1 > alen) {
- zlog_ferr(BABEL_ERR_PACKET,
+ flog_err(BABEL_ERR_PACKET,
"Received truncated sub-TLV on Hello message.");
return -1;
}
len = a[i + 1];
if(i + len > alen) {
- zlog_ferr(BABEL_ERR_PACKET,
+ flog_err(BABEL_ERR_PACKET,
"Received truncated sub-TLV on Hello message.");
return -1;
}
DO_NTOHL(*hello_send_us, a + i + 2);
ret = 1;
} else {
- zlog_ferr(BABEL_ERR_PACKET,
+ flog_err(BABEL_ERR_PACKET,
"Received incorrect RTT sub-TLV on Hello message.");
}
} else {
}
if(i + 1 > alen) {
- zlog_ferr(BABEL_ERR_PACKET,
+ flog_err(BABEL_ERR_PACKET,
"Received truncated sub-TLV on IHU message.");
return -1;
}
len = a[i + 1];
if(i + len > alen) {
- zlog_ferr(BABEL_ERR_PACKET,
+ flog_err(BABEL_ERR_PACKET,
"Received truncated sub-TLV on IHU message.");
return -1;
}
ret = 1;
}
else {
- zlog_ferr(BABEL_ERR_PACKET,
+ flog_err(BABEL_ERR_PACKET,
"Received incorrect RTT sub-TLV on IHU message.");
}
} else {
}
if(!linklocal(from)) {
- zlog_ferr(BABEL_ERR_PACKET,
+ flog_err(BABEL_ERR_PACKET,
"Received packet from non-local address %s.",
format_address(from));
return;
}
if (babel_packet_examin (packet, packetlen)) {
- zlog_ferr(BABEL_ERR_PACKET,
+ flog_err(BABEL_ERR_PACKET,
"Received malformed packet on %s from %s.",
ifp->name, format_address(from));
return;
neigh = find_neighbour(from, ifp);
if(neigh == NULL) {
- zlog_ferr(BABEL_ERR_PACKET, "Couldn't allocate neighbour.");
+ flog_err(BABEL_ERR_PACKET, "Couldn't allocate neighbour.");
return;
}
DO_NTOHS(bodylen, packet + 2);
if(bodylen + 4 > packetlen) {
- zlog_ferr(BABEL_ERR_PACKET, "Received truncated packet (%d + 4 > %d).",
+ flog_err(BABEL_ERR_PACKET, "Received truncated packet (%d + 4 > %d).",
bodylen, packetlen);
bodylen = packetlen - 4;
}
have_router_id = 1;
}
if(!have_router_id && message[2] != 0) {
- zlog_ferr(BABEL_ERR_PACKET,
+ flog_err(BABEL_ERR_PACKET,
"Received prefix with no router id.");
goto fail;
}
if(message[2] == 0) {
if(metric < 0xFFFF) {
- zlog_ferr(BABEL_ERR_PACKET,
+ flog_err(BABEL_ERR_PACKET,
"Received wildcard update with finite metric.");
goto done;
}
continue;
fail:
- zlog_ferr(BABEL_ERR_PACKET,
+ flog_err(BABEL_ERR_PACKET,
"Couldn't parse packet (%d, %d) from %s on %s.",
message[0], message[1], format_address(from), ifp->name);
goto done;
DO_HTONL(babel_ifp->sendbuf + babel_ifp->buffered_hello + 10, time);
return 1;
} else {
- zlog_ferr(BABEL_ERR_PACKET, "No space left for timestamp sub-TLV "
+ flog_err(BABEL_ERR_PACKET, "No space left for timestamp sub-TLV "
"(this shouldn't happen)");
return -1;
}
babel_ifp->sendbuf, babel_ifp->buffered,
(struct sockaddr*)&sin6, sizeof(sin6));
if(rc < 0)
- zlog_ferr(BABEL_ERR_PACKET, "send: %s", safe_strerror(errno));
+ flog_err(BABEL_ERR_PACKET, "send: %s", safe_strerror(errno));
} else {
- zlog_ferr(BABEL_ERR_PACKET,
+ flog_err(BABEL_ERR_PACKET,
"Warning: bucket full, dropping packet to %s.",
ifp->name);
}
if(!unicast_buffer)
unicast_buffer = malloc(UNICAST_BUFSIZE);
if(!unicast_buffer) {
- zlog_ferr(BABEL_ERR_MEMORY, "malloc(unicast_buffer): %s",
+ flog_err(BABEL_ERR_MEMORY, "malloc(unicast_buffer): %s",
safe_strerror(errno));
return -1;
}
unicast_buffer, unicast_buffered,
(struct sockaddr*)&sin6, sizeof(sin6));
if(rc < 0)
- zlog_ferr(BABEL_ERR_PACKET, "send(unicast): %s",
+ flog_err(BABEL_ERR_PACKET, "send(unicast): %s",
safe_strerror(errno));
} else {
- zlog_ferr(BABEL_ERR_PACKET,
+ flog_err(BABEL_ERR_PACKET,
"Warning: bucket full, dropping unicast packet to %s if %s.",
format_address(unicast_neighbour->address),
unicast_neighbour->ifp->name);
again:
babel_ifp->buffered_updates = malloc(n *sizeof(struct buffered_update));
if(babel_ifp->buffered_updates == NULL) {
- zlog_ferr(BABEL_ERR_MEMORY, "malloc(buffered_updates): %s",
+ flog_err(BABEL_ERR_MEMORY, "malloc(buffered_updates): %s",
safe_strerror(errno));
if(n > 4) {
/* Try again with a tiny buffer. */
}
route_stream_done(routes);
} else {
- zlog_ferr(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
+ flog_err(BABEL_ERR_MEMORY, "Couldn't allocate route stream.");
}
set_timeout(&babel_ifp->update_timeout, babel_ifp->update_interval);
babel_ifp->last_update_time = babel_now.tv_sec;
}
xroute_stream_done(xroutes);
} else {
- zlog_ferr(BABEL_ERR_MEMORY, "Couldn't allocate xroute stream.");
+ flog_err(BABEL_ERR_MEMORY, "Couldn't allocate xroute stream.");
}
}
neigh = malloc(sizeof(struct neighbour));
if(neigh == NULL) {
- zlog_ferr(BABEL_ERR_MEMORY, "malloc(neighbour): %s",
+ flog_err(BABEL_ERR_MEMORY, "malloc(neighbour): %s",
safe_strerror(errno));
return NULL;
}
return;
if(!route_feasible(route))
- zlog_ferr(BABEL_ERR_ROUTE, "WARNING: installing unfeasible route "
+ flog_err(BABEL_ERR_ROUTE, "WARNING: installing unfeasible route "
"(this shouldn't happen).");
i = find_route_slot(route->src->prefix, route->src->plen, NULL);
assert(i >= 0 && i < route_slots);
if(routes[i] != route && routes[i]->installed) {
- zlog_ferr(BABEL_ERR_ROUTE,
+ flog_err(BABEL_ERR_ROUTE,
"WARNING: attempting to install duplicate route "
"(this shouldn't happen).");
return;
metric_to_kernel(route_metric(route)), NULL, 0, 0);
if(rc < 0) {
int save = errno;
- zlog_ferr(BABEL_ERR_ROUTE, "kernel_route(ADD): %s",
+ flog_err(BABEL_ERR_ROUTE, "kernel_route(ADD): %s",
safe_strerror(errno));
if(save != EEXIST)
return;
route->neigh->ifp->ifindex,
metric_to_kernel(route_metric(route)), NULL, 0, 0);
if(rc < 0)
- zlog_ferr(BABEL_ERR_ROUTE, "kernel_route(FLUSH): %s",
+ flog_err(BABEL_ERR_ROUTE, "kernel_route(FLUSH): %s",
safe_strerror(errno));
route->installed = 0;
return;
if(!route_feasible(new))
- zlog_ferr(BABEL_ERR_ROUTE, "WARNING: switching to unfeasible route "
+ flog_err(BABEL_ERR_ROUTE, "WARNING: switching to unfeasible route "
"(this shouldn't happen).");
rc = kernel_route(ROUTE_MODIFY, old->src->prefix, old->src->plen,
new->nexthop, new->neigh->ifp->ifindex,
metric_to_kernel(route_metric(new)));
if(rc < 0) {
- zlog_ferr(BABEL_ERR_ROUTE, "kernel_route(MODIFY): %s",
+ flog_err(BABEL_ERR_ROUTE, "kernel_route(MODIFY): %s",
safe_strerror(errno));
return;
}
route->nexthop, route->neigh->ifp->ifindex,
new);
if(rc < 0) {
- zlog_ferr(BABEL_ERR_ROUTE, "kernel_route(MODIFY metric): %s",
+ flog_err(BABEL_ERR_ROUTE, "kernel_route(MODIFY metric): %s",
safe_strerror(errno));
return;
}
return NULL;
if(martian_prefix(prefix, plen)) {
- zlog_ferr(BABEL_ERR_ROUTE, "Rejecting martian route to %s through %s.",
+ flog_err(BABEL_ERR_ROUTE, "Rejecting martian route to %s through %s.",
format_prefix(prefix, plen), format_address(nexthop));
return NULL;
}
route->next = NULL;
new_route = insert_route(route);
if(new_route == NULL) {
- zlog_ferr(BABEL_ERR_ROUTE, "Couldn't insert route.");
+ flog_err(BABEL_ERR_ROUTE, "Couldn't insert route.");
free(route);
return NULL;
}
src = malloc(sizeof(struct source));
if(src == NULL) {
- zlog_ferr(BABEL_ERR_MEMORY, "malloc(source): %s", safe_strerror(errno));
+ flog_err(BABEL_ERR_MEMORY, "malloc(source): %s", safe_strerror(errno));
return NULL;
}
for (i = 0; i <= 2; i++) /* O,T,P, but not E */
if (CHECK_FLAG(desired_flags, attr_flag_str[i].key)
!= CHECK_FLAG(real_flags, attr_flag_str[i].key)) {
- zlog_ferr(
+ flog_err(
BGP_ERR_ATTR_FLAG,
"%s attribute must%s be flagged as \"%s\"",
lookup_msg(attr_str, attr_code, NULL),
*/
if (!CHECK_FLAG(BGP_ATTR_FLAG_OPTIONAL, flags)
&& !CHECK_FLAG(BGP_ATTR_FLAG_TRANS, flags)) {
- zlog_ferr(
+ flog_err(
BGP_ERR_ATTR_FLAG,
"%s well-known attributes must have transitive flag set (%x)",
lookup_msg(attr_str, attr_code, NULL), flags);
*/
if (CHECK_FLAG(flags, BGP_ATTR_FLAG_PARTIAL)) {
if (!CHECK_FLAG(flags, BGP_ATTR_FLAG_OPTIONAL)) {
- zlog_ferr(BGP_ERR_ATTR_FLAG,
+ flog_err(BGP_ERR_ATTR_FLAG,
"%s well-known attribute "
"must NOT have the partial flag set (%x)",
lookup_msg(attr_str, attr_code, NULL), flags);
}
if (CHECK_FLAG(flags, BGP_ATTR_FLAG_OPTIONAL)
&& !CHECK_FLAG(flags, BGP_ATTR_FLAG_TRANS)) {
- zlog_ferr(BGP_ERR_ATTR_FLAG,
+ flog_err(BGP_ERR_ATTR_FLAG,
"%s optional + transitive attribute "
"must NOT have the partial flag set (%x)",
lookup_msg(attr_str, attr_code, NULL), flags);
field contains the erroneous attribute (type, length and
value). */
if (length != 1) {
- zlog_ferr(BGP_ERR_ATTR_LEN,
+ flog_err(BGP_ERR_ATTR_LEN,
"Origin attribute length is not one %d", length);
return bgp_attr_malformed(args, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
args->total);
contains the unrecognized attribute (type, length and value). */
if ((attr->origin != BGP_ORIGIN_IGP) && (attr->origin != BGP_ORIGIN_EGP)
&& (attr->origin != BGP_ORIGIN_INCOMPLETE)) {
- zlog_ferr(BGP_ERR_ATTR_ORIGIN,
+ flog_err(BGP_ERR_ATTR_ORIGIN,
"Origin attribute value is invalid %d", attr->origin);
return bgp_attr_malformed(args, BGP_NOTIFY_UPDATE_INVAL_ORIGIN,
args->total);
/* In case of IBGP, length will be zero. */
if (!attr->aspath) {
- zlog_ferr(BGP_ERR_ATTR_MAL_AS_PATH,
+ flog_err(BGP_ERR_ATTR_MAL_AS_PATH,
"Malformed AS path from %s, length is %d", peer->host,
length);
return bgp_attr_malformed(args, BGP_NOTIFY_UPDATE_MAL_AS_PATH,
&& !aspath_left_confed_check(attr->aspath))
|| (peer->sort == BGP_PEER_EBGP
&& aspath_confed_check(attr->aspath))) {
- zlog_ferr(BGP_ERR_ATTR_MAL_AS_PATH, "Malformed AS path from %s",
+ flog_err(BGP_ERR_ATTR_MAL_AS_PATH, "Malformed AS path from %s",
peer->host);
bgp_notify_send(peer, BGP_NOTIFY_UPDATE_ERR,
BGP_NOTIFY_UPDATE_MAL_AS_PATH);
if (CHECK_FLAG(peer->flags, PEER_FLAG_ENFORCE_FIRST_AS)) {
if (peer->sort == BGP_PEER_EBGP
&& !aspath_firstas_check(attr->aspath, peer->as)) {
- zlog_ferr(BGP_ERR_ATTR_FIRST_AS,
+ flog_err(BGP_ERR_ATTR_FIRST_AS,
"%s incorrect first AS (must be %u)",
peer->host, peer->as);
bgp_notify_send(peer, BGP_NOTIFY_UPDATE_ERR,
/* In case of IBGP, length will be zero. */
if (!*as4_path) {
- zlog_ferr(BGP_ERR_ATTR_MAL_AS_PATH,
+ flog_err(BGP_ERR_ATTR_MAL_AS_PATH,
"Malformed AS4 path from %s, length is %d",
peer->host, length);
return bgp_attr_malformed(args, BGP_NOTIFY_UPDATE_MAL_AS_PATH,
/* Check nexthop attribute length. */
if (length != 4) {
- zlog_ferr(BGP_ERR_ATTR_LEN,
+ flog_err(BGP_ERR_ATTR_LEN,
"Nexthop attribute length isn't four [%d]", length);
return bgp_attr_malformed(args, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
{
char buf[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &nexthop_n, buf, INET_ADDRSTRLEN);
- zlog_ferr(BGP_ERR_ATTR_MARTIAN_NH, "Martian nexthop %s", buf);
+ flog_err(BGP_ERR_ATTR_MARTIAN_NH, "Martian nexthop %s", buf);
return bgp_attr_malformed(
args, BGP_NOTIFY_UPDATE_INVAL_NEXT_HOP, args->total);
}
/* Length check. */
if (length != 4) {
- zlog_ferr(BGP_ERR_ATTR_LEN,
+ flog_err(BGP_ERR_ATTR_LEN,
"MED attribute length isn't four [%d]", length);
return bgp_attr_malformed(args, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
/* Length check. */
if (length != 4) {
- zlog_ferr(BGP_ERR_ATTR_LEN,
+ flog_err(BGP_ERR_ATTR_LEN,
"LOCAL_PREF attribute length isn't 4 [%u]", length);
return bgp_attr_malformed(args, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
args->total);
/* Length check. */
if (length != 0) {
- zlog_ferr(BGP_ERR_ATTR_LEN,
+ flog_err(BGP_ERR_ATTR_LEN,
"ATOMIC_AGGREGATE attribute length isn't 0 [%u]",
length);
return bgp_attr_malformed(args, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
wantedlen = 8;
if (length != wantedlen) {
- zlog_ferr(BGP_ERR_ATTR_LEN,
+ flog_err(BGP_ERR_ATTR_LEN,
"AGGREGATOR attribute length isn't %u [%u]",
wantedlen, length);
return bgp_attr_malformed(args, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
const bgp_size_t length = args->length;
if (length != 8) {
- zlog_ferr(BGP_ERR_ATTR_LEN,
+ flog_err(BGP_ERR_ATTR_LEN,
"New Aggregator length is not 8 [%d]", length);
return bgp_attr_malformed(args, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
0);
/* Length check. */
if (length != 4) {
- zlog_ferr(BGP_ERR_ATTR_LEN, "Bad originator ID length %d",
+ flog_err(BGP_ERR_ATTR_LEN, "Bad originator ID length %d",
length);
return bgp_attr_malformed(args, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
/* Check length. */
if (length % 4) {
- zlog_ferr(BGP_ERR_ATTR_LEN, "Bad cluster list length %d",
+ flog_err(BGP_ERR_ATTR_LEN, "Bad cluster list length %d",
length);
return bgp_attr_malformed(args, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
if (type == BGP_PREFIX_SID_LABEL_INDEX) {
if (length != BGP_PREFIX_SID_LABEL_INDEX_LENGTH) {
- zlog_ferr(
+ flog_err(
BGP_ERR_ATTR_LEN,
"Prefix SID label index length is %d instead of %d",
length, BGP_PREFIX_SID_LABEL_INDEX_LENGTH);
/* Placeholder code for the IPv6 SID type */
else if (type == BGP_PREFIX_SID_IPV6) {
if (length != BGP_PREFIX_SID_IPV6_LENGTH) {
- zlog_ferr(BGP_ERR_ATTR_LEN,
+ flog_err(BGP_ERR_ATTR_LEN,
"Prefix SID IPv6 length is %d instead of %d",
length, BGP_PREFIX_SID_IPV6_LENGTH);
return bgp_attr_malformed(args,
length -= 2;
if (length % BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH) {
- zlog_ferr(
+ flog_err(
BGP_ERR_ATTR_LEN,
"Prefix SID Originator SRGB length is %d, it must be a multiple of %d ",
length, BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH);
tlength -= length + 3;
if (tlength < 0) {
- zlog_ferr(
+ flog_err(
BGP_ERR_ATTR_LEN,
"Prefix SID internal length %d causes us to read beyond the total Prefix SID length",
length);
* can only support that.
*/
if (length < 2) {
- zlog_ferr(BGP_ERR_ATTR_LEN,
+ flog_err(BGP_ERR_ATTR_LEN,
"Bad PMSI tunnel attribute length %d", length);
return bgp_attr_malformed(args, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
args->total);
stream_getc(peer->curr); /* Flags */
tnl_type = stream_getc(peer->curr);
if (tnl_type > PMSI_TNLTYPE_MAX) {
- zlog_ferr(BGP_ERR_ATTR_PMSI_TYPE,
+ flog_err(BGP_ERR_ATTR_PMSI_TYPE,
"Invalid PMSI tunnel attribute type %d", tnl_type);
return bgp_attr_malformed(args, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR,
args->total);
}
if (tnl_type == PMSI_TNLTYPE_INGR_REPL) {
if (length != 9) {
- zlog_ferr(BGP_ERR_ATTR_PMSI_LEN,
+ flog_err(BGP_ERR_ATTR_PMSI_LEN,
"Bad PMSI tunnel attribute length %d for IR",
length);
return bgp_attr_malformed(
break;
default:
if (safi != SAFI_FLOWSPEC)
- zlog_ferr(
+ flog_err(
BGP_ERR_ATTR_NH_SEND_LEN,
"Bad nexthop when sending to %s, AFI %u SAFI %u nhlen %d",
peer->host, afi, safi, attr->mp_nexthop_len);
bgp_def = bgp_get_default();
if (!bgp_def) {
- zlog_ferr(BGP_ERR_NO_DFLT,
+ flog_err(BGP_ERR_NO_DFLT,
"vrf import rt new - def instance not created yet");
return NULL;
}
bgp_def = bgp_get_default();
if (!bgp_def) {
- zlog_ferr(BGP_ERR_NO_DFLT,
+ flog_err(BGP_ERR_NO_DFLT,
"vrf import rt free - def instance not created yet");
return;
}
bgp_def = bgp_get_default();
if (!bgp_def) {
- zlog_ferr(
+ flog_err(
BGP_ERR_NO_DFLT,
"vrf import rt lookup - def instance not created yet");
return NULL;
if (is_evpn_prefix_ipaddr_v4(p))
stream_put_in_addr(s, &p->prefix.imet_addr.ip.ipaddr_v4);
else if (is_evpn_prefix_ipaddr_v6(p)) {
- zlog_ferr(
+ flog_err(
BGP_ERR_VTEP_INVALID,
"Bad remote IP when trying to %s remote VTEP for VNI %u",
add ? "ADD" : "DEL", vpn->vni);
* We shouldn't see the same route from any other vtep.
*/
if (remote_ri) {
- zlog_ferr(
+ flog_err(
BGP_ERR_ES_INVALID,
"%u ERROR: local es route for ESI: %s Vtep %s also learnt from remote",
bgp->vrf_id,
&attr, 1, &ri,
&route_changed);
if (ret != 0) {
- zlog_ferr(
+ flog_err(
BGP_ERR_ES_INVALID,
"%u ERROR: Failed to updated ES route ESI: %s VTEP %s",
bgp->vrf_id,
build_evpn_type4_prefix(&p, &es->esi, es->originator_ip.ipaddr_v4);
ret = delete_evpn_type4_route(bgp, es, &p);
if (ret) {
- zlog_ferr(BGP_ERR_EVPN_ROUTE_DELETE,
+ flog_err(BGP_ERR_EVPN_ROUTE_DELETE,
"%u failed to delete type-4 route for ESI %s",
bgp->vrf_id, esi_to_str(&es->esi, buf, sizeof(buf)));
}
bgp, es, evp, ri);
if (ret) {
- zlog_ferr(
+ flog_err(
BGP_ERR_EVPN_FAIL,
"Failed to %s EVPN %s route in ESI %s",
install ? "install"
bgp_vrf, evp, ri);
if (ret) {
- zlog_ferr(
+ flog_err(
BGP_ERR_EVPN_FAIL,
"Failed to %s EVPN %s route in VRF %s",
install ? "install"
bgp, vpn, evp, ri);
if (ret) {
- zlog_ferr(
+ flog_err(
BGP_ERR_EVPN_FAIL,
"%u: Failed to %s EVPN %s route in VNI %u",
bgp->vrf_id,
ret = uninstall_evpn_route_entry_in_es(bgp, es, evp, ri);
if (ret) {
- zlog_ferr(
+ flog_err(
BGP_ERR_EVPN_FAIL,
"%u: Failed to %s EVPN %s route in ESI %s", bgp->vrf_id,
install ? "install" : "uninstall", "ES",
ri);
if (ret) {
- zlog_ferr(BGP_ERR_EVPN_FAIL,
+ flog_err(BGP_ERR_EVPN_FAIL,
"%u: Failed to %s prefix %s in VRF %s",
bgp_def->vrf_id,
install ? "install" : "uninstall",
ret = uninstall_evpn_route_entry(bgp, vpn, evp, ri);
if (ret) {
- zlog_ferr(
+ flog_err(
BGP_ERR_EVPN_FAIL,
"%u: Failed to %s EVPN %s route in VNI %u",
bgp->vrf_id, install ? "install" : "uninstall",
*/
if (psize != 33 && psize != 37 && psize != 49 && psize != 36
&& psize != 40 && psize != 52) {
- zlog_ferr(BGP_ERR_EVPN_ROUTE_INVALID,
+ flog_err(BGP_ERR_EVPN_ROUTE_INVALID,
"%u:%s - Rx EVPN Type-2 NLRI with invalid length %d",
peer->bgp->vrf_id, peer->host, psize);
return -1;
memcpy(&p.prefix.macip_addr.mac.octet, pfx, ETH_ALEN);
pfx += ETH_ALEN;
} else {
- zlog_ferr(
+ flog_err(
BGP_ERR_EVPN_ROUTE_INVALID,
"%u:%s - Rx EVPN Type-2 NLRI with unsupported MAC address length %d",
peer->bgp->vrf_id, peer->host, macaddr_len);
ipaddr_len = *pfx++;
if (ipaddr_len != 0 && ipaddr_len != IPV4_MAX_BITLEN
&& ipaddr_len != IPV6_MAX_BITLEN) {
- zlog_ferr(
+ flog_err(
BGP_ERR_EVPN_ROUTE_INVALID,
"%u:%s - Rx EVPN Type-2 NLRI with unsupported IP address length %d",
peer->bgp->vrf_id, peer->host, ipaddr_len);
* IP len (1) and IP (4 or 16).
*/
if (psize != 17 && psize != 29) {
- zlog_ferr(BGP_ERR_EVPN_ROUTE_INVALID,
+ flog_err(BGP_ERR_EVPN_ROUTE_INVALID,
"%u:%s - Rx EVPN Type-3 NLRI with invalid length %d",
peer->bgp->vrf_id, peer->host, psize);
return -1;
p.prefix.imet_addr.ip.ipa_type = IPADDR_V4;
memcpy(&p.prefix.imet_addr.ip.ip.addr, pfx, IPV4_MAX_BYTELEN);
} else {
- zlog_ferr(
+ flog_err(
BGP_ERR_EVPN_ROUTE_INVALID,
"%u:%s - Rx EVPN Type-3 NLRI with unsupported IP address length %d",
peer->bgp->vrf_id, peer->host, ipaddr_len);
* RD (8), ESI (10), ip-len (1), ip (4 or 16)
*/
if (psize != 23 && psize != 35) {
- zlog_ferr(BGP_ERR_EVPN_ROUTE_INVALID,
+ flog_err(BGP_ERR_EVPN_ROUTE_INVALID,
"%u:%s - Rx EVPN Type-4 NLRI with invalid length %d",
peer->bgp->vrf_id, peer->host, psize);
return -1;
if (ipaddr_len == IPV4_MAX_BITLEN) {
memcpy(&vtep_ip, pfx, IPV4_MAX_BYTELEN);
} else {
- zlog_ferr(
+ flog_err(
BGP_ERR_EVPN_ROUTE_INVALID,
"%u:%s - Rx EVPN Type-4 NLRI with unsupported IP address length %d",
peer->bgp->vrf_id, peer->host, ipaddr_len);
* Note that the IP and GW should both be IPv4 or both IPv6.
*/
if (psize != 34 && psize != 58) {
- zlog_ferr(BGP_ERR_EVPN_ROUTE_INVALID,
+ flog_err(BGP_ERR_EVPN_ROUTE_INVALID,
"%u:%s - Rx EVPN Type-5 NLRI with invalid length %d",
peer->bgp->vrf_id, peer->host, psize);
return -1;
/* Fetch IP prefix length. */
ippfx_len = *pfx++;
if (ippfx_len > IPV6_MAX_BITLEN) {
- zlog_ferr(
+ flog_err(
BGP_ERR_EVPN_ROUTE_INVALID,
"%u:%s - Rx EVPN Type-5 NLRI with invalid IP Prefix length %d",
peer->bgp->vrf_id, peer->host, ippfx_len);
build_type5_prefix_from_ip_prefix(&evp, p);
ret = delete_evpn_type5_route(bgp_vrf, &evp);
if (ret) {
- zlog_ferr(
+ flog_err(
BGP_ERR_EVPN_ROUTE_DELETE,
"%u failed to delete type-5 route for prefix %s in vrf %s",
bgp_vrf->vrf_id, prefix2str(p, buf, sizeof(buf)),
build_type5_prefix_from_ip_prefix(&evp, p);
ret = update_evpn_type5_route(bgp_vrf, &evp, src_attr);
if (ret)
- zlog_ferr(BGP_ERR_EVPN_ROUTE_CREATE,
+ flog_err(BGP_ERR_EVPN_ROUTE_CREATE,
"%u: Failed to create type-5 route for prefix %s",
bgp_vrf->vrf_id, prefix2str(p, buf, sizeof(buf)));
}
if (process_type2_route(peer, afi, safi,
withdraw ? NULL : attr, pnt,
psize, addpath_id)) {
- zlog_ferr(
+ flog_err(
BGP_ERR_EVPN_FAIL,
"%u:%s - Error in processing EVPN type-2 NLRI size %d",
peer->bgp->vrf_id, peer->host, psize);
if (process_type3_route(peer, afi, safi,
withdraw ? NULL : attr, pnt,
psize, addpath_id)) {
- zlog_ferr(
+ flog_err(
BGP_ERR_PKT_PROCESS,
"%u:%s - Error in processing EVPN type-3 NLRI size %d",
peer->bgp->vrf_id, peer->host, psize);
if (process_type4_route(peer, afi, safi,
withdraw ? NULL : attr, pnt,
psize, addpath_id)) {
- zlog_ferr(
+ flog_err(
BGP_ERR_PKT_PROCESS,
"%u:%s - Error in processing EVPN type-4 NLRI size %d",
peer->bgp->vrf_id, peer->host, psize);
case BGP_EVPN_IP_PREFIX_ROUTE:
if (process_type5_route(peer, afi, safi, attr, pnt,
psize, addpath_id, withdraw)) {
- zlog_ferr(
+ flog_err(
BGP_ERR_PKT_PROCESS,
"%u:%s - Error in processing EVPN type-5 NLRI size %d",
peer->bgp->vrf_id, peer->host, psize);
char buf[ETHER_ADDR_STRLEN];
char buf2[INET6_ADDRSTRLEN];
- zlog_ferr(
+ flog_err(
BGP_ERR_EVPN_ROUTE_CREATE,
"%u:Failed to create Type-2 route, VNI %u %s MAC %s IP %s (flags: 0x%x)",
bgp->vrf_id, vpn->vni,
*/
bgp_def = bgp_get_default();
if (!bgp_def) {
- zlog_ferr(
+ flog_err(
BGP_ERR_NO_DFLT,
"Cannot process L3VNI %u ADD - default BGP instance not yet created",
l3vni);
BGP_INSTANCE_TYPE_VRF);
switch (ret) {
case BGP_ERR_MULTIPLE_INSTANCE_NOT_SET:
- zlog_ferr(BGP_ERR_MULTI_INSTANCE,
+ flog_err(BGP_ERR_MULTI_INSTANCE,
"'bgp multiple-instance' not present\n");
return -1;
case BGP_ERR_AS_MISMATCH:
- zlog_ferr(BGP_ERR_EVPN_AS_MISMATCH,
+ flog_err(BGP_ERR_EVPN_AS_MISMATCH,
"BGP is already running; AS is %u\n", as);
return -1;
case BGP_ERR_INSTANCE_MISMATCH:
- zlog_ferr(BGP_ERR_EVPN_INSTANCE_MISMATCH,
+ flog_err(BGP_ERR_EVPN_INSTANCE_MISMATCH,
"BGP instance name and AS number mismatch\n");
return -1;
}
bgp_vrf = bgp_lookup_by_vrf_id(vrf_id);
if (!bgp_vrf) {
- zlog_ferr(
+ flog_err(
BGP_ERR_NO_DFLT,
"Cannot process L3VNI %u Del - Could not find BGP instance",
l3vni);
bgp_def = bgp_get_default();
if (!bgp_def) {
- zlog_ferr(
+ flog_err(
BGP_ERR_NO_DFLT,
"Cannot process L3VNI %u Del - Could not find default BGP instance",
l3vni);
if (!vpn) {
vpn = bgp_evpn_new(bgp, vni, originator_ip, tenant_vrf_id);
if (!vpn) {
- zlog_ferr(
+ flog_err(
BGP_ERR_VNI,
"%u: Failed to allocate VNI entry for VNI %u - at Add",
bgp->vrf_id, vni);
/* Create EVPN type-3 route and schedule for processing. */
build_evpn_type3_prefix(&p, vpn->originator_ip);
if (update_evpn_route(bgp, vpn, &p, 0)) {
- zlog_ferr(BGP_ERR_EVPN_ROUTE_CREATE,
+ flog_err(BGP_ERR_EVPN_ROUTE_CREATE,
"%u: Type3 route creation failure for VNI %u",
bgp->vrf_id, vni);
return -1;
struct evpnes *es = NULL;
if (!bgp->esihash) {
- zlog_ferr(BGP_ERR_ES_CREATE, "%u: ESI hash not yet created",
+ flog_err(BGP_ERR_ES_CREATE, "%u: ESI hash not yet created",
bgp->vrf_id);
return -1;
}
struct prefix_evpn p;
if (!bgp->esihash) {
- zlog_ferr(BGP_ERR_ES_CREATE, "%u: ESI hash not yet created",
+ flog_err(BGP_ERR_ES_CREATE, "%u: ESI hash not yet created",
bgp->vrf_id);
return -1;
}
if (!es) {
es = bgp_evpn_es_new(bgp, esi, originator_ip);
if (!es) {
- zlog_ferr(
+ flog_err(
BGP_ERR_ES_CREATE,
"%u: Failed to allocate ES entry for ESI %s - at Local ES Add",
bgp->vrf_id, esi_to_str(esi, buf, sizeof(buf)));
build_evpn_type4_prefix(&p, esi, originator_ip->ipaddr_v4);
if (update_evpn_type4_route(bgp, es, &p)) {
- zlog_ferr(BGP_ERR_EVPN_ROUTE_CREATE,
+ flog_err(BGP_ERR_EVPN_ROUTE_CREATE,
"%u: Type4 route creation failure for ESI %s",
bgp->vrf_id, esi_to_str(esi, buf, sizeof(buf)));
return -1;
*/
vpn = bgp_evpn_new(bgp, vni, bgp->router_id, 0);
if (!vpn) {
- zlog_ferr(
+ flog_err(
BGP_ERR_VNI,
"%u: Failed to allocate VNI entry for VNI %u - at Config",
bgp->vrf_id, vni);
safi = packet->safi;
if (afi == AFI_IP6) {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_DEVELOPMENT,
"BGP flowspec IPv6 not supported");
return -1;
}
if (packet->length >= FLOWSPEC_NLRI_SIZELIMIT) {
- zlog_ferr(BGP_ERR_FLOWSPEC_PACKET,
+ flog_err(BGP_ERR_FLOWSPEC_PACKET,
"BGP flowspec nlri length maximum reached (%u)",
packet->length);
return -1;
/* When packet overflow occur return immediately. */
if (pnt + psize > lim) {
- zlog_ferr(BGP_ERR_FLOWSPEC_PACKET,
+ flog_err(BGP_ERR_FLOWSPEC_PACKET,
"Flowspec NLRI length inconsistent ( size %u seen)",
psize);
return -1;
}
if (bgp_fs_nlri_validate(pnt, psize) < 0) {
- zlog_ferr(BGP_ERR_FLOWSPEC_PACKET,
+ flog_err(BGP_ERR_FLOWSPEC_PACKET,
"Bad flowspec format or NLRI options not supported");
return -1;
}
ZEBRA_ROUTE_BGP, BGP_ROUTE_NORMAL,
NULL, NULL, 0, NULL);
if (ret) {
- zlog_ferr(BGP_ERR_FLOWSPEC_INSTALLATION,
+ flog_err(BGP_ERR_FLOWSPEC_INSTALLATION,
"Flowspec NLRI failed to be %s.",
attr ? "added" : "withdrawn");
return -1;
len,
mval, error);
if (*error < 0)
- zlog_ferr(BGP_ERR_FLOWSPEC_PACKET,
+ flog_err(BGP_ERR_FLOWSPEC_PACKET,
"%s: flowspec_op_decode error %d",
__func__, *error);
else
len - offset,
prefix, &error);
if (error < 0)
- zlog_ferr(BGP_ERR_FLOWSPEC_PACKET,
+ flog_err(BGP_ERR_FLOWSPEC_PACKET,
"%s: flowspec_ip_address error %d",
__func__, error);
else
len - offset,
&bpem->tcpflags, &error);
if (error < 0)
- zlog_ferr(BGP_ERR_FLOWSPEC_PACKET,
+ flog_err(BGP_ERR_FLOWSPEC_PACKET,
"%s: flowspec_tcpflags_decode error %d",
__func__, error);
else
len - offset, &bpem->fragment,
&error);
if (error < 0)
- zlog_ferr(BGP_ERR_FLOWSPEC_PACKET,
+ flog_err(BGP_ERR_FLOWSPEC_PACKET,
"%s: flowspec_fragment_type_decode error %d",
__func__, error);
else
offset += ret;
break;
default:
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: unknown type %d\n",
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: unknown type %d\n",
__func__, type);
}
}
* runs in our pthread.
*/
if (peer->curr) {
- zlog_ferr(
+ flog_err(
BGP_ERR_PKT_PROCESS,
"[%s] Dropping pending packet on connection transfer:",
peer->host);
}
if (bgp_getsockname(peer) < 0) {
- zlog_ferr(
+ flog_err(
LIB_ERR_SOCKET,
"%%bgp_getsockname() failed for %s peer %s fd %d (from_peer fd %d)",
(CHECK_FLAG(peer->sflags, PEER_STATUS_ACCEPT_PEER)
}
if (from_peer->status > Active) {
if (bgp_getsockname(from_peer) < 0) {
- zlog_ferr(
+ flog_err(
LIB_ERR_SOCKET,
"%%bgp_getsockname() failed for %s from_peer %s fd %d (peer fd %d)",
static int bgp_connect_success(struct peer *peer)
{
if (peer->fd < 0) {
- zlog_ferr(BGP_ERR_CONNECT,
+ flog_err(BGP_ERR_CONNECT,
"bgp_connect_success peer's fd is negative value %d",
peer->fd);
bgp_stop(peer);
}
if (bgp_getsockname(peer) < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s: bgp_getsockname(): failed for peer %s, fd %d",
__FUNCTION__, peer->host, peer->fd);
bgp_notify_send(peer, BGP_NOTIFY_FSM_ERR,
if (BGP_PEER_START_SUPPRESSED(peer)) {
if (bgp_debug_neighbor_events(peer))
- zlog_ferr(BGP_ERR_FSM,
+ flog_err(BGP_ERR_FSM,
"%s [FSM] Trying to start suppressed peer"
" - this is never supposed to happen!",
peer->host);
if (peer->bgp->vrf_id == VRF_UNKNOWN) {
if (bgp_debug_neighbor_events(peer))
- zlog_ferr(
+ flog_err(
BGP_ERR_FSM,
"%s [FSM] In a VRF that is not initialised yet",
peer->host);
"%s [FSM] Non blocking connect waiting result, fd %d",
peer->host, peer->fd);
if (peer->fd < 0) {
- zlog_ferr(BGP_ERR_FSM,
+ flog_err(BGP_ERR_FSM,
"bgp_start peer's fd is negative value %d",
peer->fd);
return -1;
peer and change to Idle status. */
static int bgp_fsm_event_error(struct peer *peer)
{
- zlog_ferr(BGP_ERR_FSM,
+ flog_err(BGP_ERR_FSM,
"%s [FSM] unexpected packet received in state %s", peer->host,
lookup_msg(bgp_status_msg, peer->status, NULL));
other = peer->doppelganger;
peer = peer_xfer_conn(peer);
if (!peer) {
- zlog_ferr(BGP_ERR_CONNECT, "%%Neighbor failed in xfer_conn");
+ flog_err(BGP_ERR_CONNECT, "%%Neighbor failed in xfer_conn");
return -1;
}
/* This is empty event. */
static int bgp_ignore(struct peer *peer)
{
- zlog_ferr(
+ flog_err(
BGP_ERR_FSM,
"%s [FSM] Ignoring event %s in state %s, prior events %s, %s, fd %d",
peer->host, bgp_event_str[peer->cur_event],
/* This is to handle unexpected events.. */
static int bgp_fsm_exeption(struct peer *peer)
{
- zlog_ferr(
+ flog_err(
BGP_ERR_FSM,
"%s [FSM] Unexpected event %s in state %s, prior events %s, %s, fd %d",
peer->host, bgp_event_str[peer->cur_event],
* code.
*/
if (!dyn_nbr && !passive_conn && peer->bgp) {
- zlog_ferr(
+ flog_err(
BGP_ERR_FSM,
"%s [FSM] Failure handling event %s in state %s, "
"prior events %s, %s, fd %d",
SET_FLAG(status, BGP_IO_TRANS_ERR);
/* Fatal error; tear down session */
} else if (nbytes < 0) {
- zlog_ferr(BGP_ERR_UPDATE_RCV,
+ flog_err(BGP_ERR_UPDATE_RCV,
"%s [Error] bgp_read_packet error: %s", peer->host,
safe_strerror(errno));
/* sanity check against packet data */
if ((pnt + psize) > lim) {
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s [Error] Update packet error / L-U (prefix length %d exceeds packet size %u)",
peer->host, prefixlen, (uint)(lim - pnt));
/* There needs to be at least one label */
if (prefixlen < 24) {
- zlog_ferr(BGP_ERR_UPDATE_RCV,
+ flog_err(BGP_ERR_UPDATE_RCV,
"%s [Error] Update packet error"
" (wrong label length %d)",
peer->host, prefixlen);
* be logged locally, and the prefix SHOULD be
* ignored.
*/
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s: IPv4 labeled-unicast NLRI is multicast address %s, ignoring",
peer->host, inet_ntoa(p.u.prefix4));
if (IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6)) {
char buf[BUFSIZ];
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s: IPv6 labeled-unicast NLRI is link-local address %s, ignoring",
peer->host,
if (IN6_IS_ADDR_MULTICAST(&p.u.prefix6)) {
char buf[BUFSIZ];
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s: IPv6 unicast NLRI is multicast address %s, ignoring",
peer->host,
/* Packet length consistency check. */
if (pnt != lim) {
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s [Error] Update packet error / L-U (%zu data remaining after parsing)",
peer->host, lim - pnt);
if (lcbq->label == MPLS_LABEL_NONE) {
/* shouldn't happen */
- zlog_ferr(BGP_ERR_LABEL, "%s: error: label==MPLS_LABEL_NONE",
+ flog_err(BGP_ERR_LABEL, "%s: error: label==MPLS_LABEL_NONE",
__func__);
return WQ_SUCCESS;
}
if (rc) {
/* shouldn't happen */
- zlog_ferr(BGP_ERR_LABEL,
+ flog_err(BGP_ERR_LABEL,
"%s: can't insert new LCB into ledger list",
__func__);
XFREE(MTYPE_BGP_LABEL_CB, lcb);
struct lp_fifo *lf;
if (last < first) {
- zlog_ferr(BGP_ERR_LABEL,
+ flog_err(BGP_ERR_LABEL,
"%s: zebra label chunk invalid: first=%u, last=%u",
__func__, first, last);
return;
multipath_num = atoi(optarg);
if (multipath_num > MULTIPATH_NUM
|| multipath_num <= 0) {
- zlog_ferr(
+ flog_err(
BGP_ERR_MULTIPATH,
"Multipath Number specified must be less than %d and greater than 0",
MULTIPATH_NUM);
psize = PSIZE(prefixlen);
if (prefixlen < VPN_PREFIXLEN_MIN_BYTES * 8) {
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s [Error] Update packet error / VPN (prefix length %d less than VPN min length)",
peer->host, prefixlen);
/* sanity check against packet data */
if ((pnt + psize) > lim) {
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s [Error] Update packet error / VPN (prefix length %d exceeds packet size %u)",
peer->host, prefixlen, (uint)(lim - pnt));
/* sanity check against storage for the IP address portion */
if ((psize - VPN_PREFIXLEN_MIN_BYTES) > (ssize_t)sizeof(p.u)) {
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s [Error] Update packet error / VPN (psize %d exceeds storage size %zu)",
peer->host,
/* Sanity check against max bitlen of the address family */
if ((psize - VPN_PREFIXLEN_MIN_BYTES) > prefix_blen(&p)) {
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s [Error] Update packet error / VPN (psize %d exceeds family (%u) max byte len %u)",
peer->host,
#endif
default:
- zlog_ferr(BGP_ERR_UPDATE_RCV, "Unknown RD type %d",
+ flog_err(BGP_ERR_UPDATE_RCV, "Unknown RD type %d",
type);
break; /* just report */
}
}
/* Packet length consistency check. */
if (pnt != lim) {
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s [Error] Update packet error / VPN (%zu data remaining after parsing)",
peer->host, lim - pnt);
return 0;
}
/* Shouldn't happen: different label allocation */
- zlog_ferr(BGP_ERR_LABEL,
+ flog_err(BGP_ERR_LABEL,
"%s: %s had label %u but got new assignment %u",
__func__, vp->bgp->name_pretty, vp->tovpn_label,
label);
#if HAVE_DECL_TCP_MD5SIG
if (bgpd_privs.change(ZPRIVS_RAISE)) {
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not raise privs",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not raise privs",
__func__);
return ret;
}
ret = bgp_md5_set_socket(socket, su, password);
if (bgpd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not lower privs",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not lower privs",
__func__);
#endif /* HAVE_TCP_MD5SIG */
struct bgp_listener *listener;
if (bgpd_privs.change(ZPRIVS_RAISE)) {
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not raise privs",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not raise privs",
__func__);
return -1;
}
}
if (bgpd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not lower privs",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not lower privs",
__func__);
return ret;
if (!peer->gtsm_hops && (peer_sort(peer) == BGP_PEER_EBGP)) {
ret = sockopt_ttl(peer->su.sa.sa_family, bgp_sock, peer->ttl);
if (ret) {
- zlog_ferr(
+ flog_err(
LIB_ERR_SOCKET,
"%s: Can't set TxTTL on peer (rtrid %s) socket, err = %d",
__func__,
*/
ret = sockopt_ttl(peer->su.sa.sa_family, bgp_sock, MAXTTL);
if (ret) {
- zlog_ferr(
+ flog_err(
LIB_ERR_SOCKET,
"%s: Can't set TxTTL on peer (rtrid %s) socket, err = %d",
__func__,
ret = sockopt_minttl(peer->su.sa.sa_family, bgp_sock,
MAXTTL + 1 - peer->gtsm_hops);
if (ret) {
- zlog_ferr(
+ flog_err(
LIB_ERR_SOCKET,
"%s: Can't set MinTTL on peer (rtrid %s) socket, err = %d",
__func__,
rc = getsockopt(sock, SOL_SOCKET, SO_BINDTODEVICE, name, &name_len);
if (rc != 0) {
#if defined(HAVE_CUMULUS)
- zlog_ferr(
+ flog_err(
LIB_ERR_SOCKET,
"[Error] BGP SO_BINDTODEVICE get failed (%s), sock %d",
safe_strerror(errno), sock);
/* Register accept thread. */
accept_sock = THREAD_FD(thread);
if (accept_sock < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "accept_sock is nevative value %d",
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"[Error] BGP socket accept failed (%s)",
safe_strerror(errno));
return -1;
return 0;
}
if (bgpd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
/* Make socket for the peer. */
peer->fd = vrf_sockunion_socket(&peer->su, peer->bgp->vrf_id,
bgp_get_bound_name(peer));
if (bgpd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
if (peer->fd < 0)
return -1;
#ifdef IPTOS_PREC_INTERNETCONTROL
if (bgpd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not raise privs",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not raise privs",
__func__);
if (sockunion_family(&peer->su) == AF_INET)
setsockopt_ipv4_tos(peer->fd, IPTOS_PREC_INTERNETCONTROL);
else if (sockunion_family(&peer->su) == AF_INET6)
setsockopt_ipv6_tclass(peer->fd, IPTOS_PREC_INTERNETCONTROL);
if (bgpd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not lower privs",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not lower privs",
__func__);
#endif
if (bgp_nexthop_set(peer->su_local, peer->su_remote, &peer->nexthop,
peer)) {
#if defined(HAVE_CUMULUS)
- zlog_ferr(
+ flog_err(
BGP_ERR_NH_UPD,
"%s: nexthop_set failed, resetting connection - intf %p",
peer->host, peer->nexthop.ifp);
sockopt_reuseport(sock);
if (bgpd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not raise privs",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not raise privs",
__func__);
#ifdef IPTOS_PREC_INTERNETCONTROL
ret = bind(sock, sa, salen);
en = errno;
if (bgpd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not lower privs",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not lower privs",
__func__);
if (ret < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "bind: %s", safe_strerror(en));
+ flog_err(LIB_ERR_SOCKET, "bind: %s", safe_strerror(en));
return ret;
}
ret = listen(sock, SOMAXCONN);
if (ret < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "listen: %s", safe_strerror(errno));
+ flog_err(LIB_ERR_SOCKET, "listen: %s", safe_strerror(errno));
return ret;
}
port_str[sizeof(port_str) - 1] = '\0';
if (bgpd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
ret = vrf_getaddrinfo(address, port_str, &req, &ainfo_save,
bgp->vrf_id);
if (bgpd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
if (ret != 0) {
- zlog_ferr(LIB_ERR_SOCKET, "getaddrinfo: %s", gai_strerror(ret));
+ flog_err(LIB_ERR_SOCKET, "getaddrinfo: %s", gai_strerror(ret));
return -1;
}
continue;
if (bgpd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
sock = vrf_socket(ainfo->ai_family, ainfo->ai_socktype,
ainfo->ai_protocol, bgp->vrf_id,
(bgp->inst_type == BGP_INSTANCE_TYPE_VRF ?
bgp->name : NULL));
if (bgpd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
if (sock < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "socket: %s",
+ flog_err(LIB_ERR_SOCKET, "socket: %s",
safe_strerror(errno));
continue;
}
}
freeaddrinfo(ainfo_save);
if (count == 0 && bgp->inst_type != BGP_INSTANCE_TYPE_VRF) {
- zlog_ferr(
+ flog_err(
LIB_ERR_SOCKET,
"%s: no usable addresses please check other programs usage of specified port %d",
__func__, port);
- zlog_ferr(LIB_ERR_SOCKET, "%s: Program cannot continue",
+ flog_err(LIB_ERR_SOCKET, "%s: Program cannot continue",
__func__);
exit(-1);
}
bgp = bgp_lookup_by_vrf_id(vrf_id);
if (!bgp) {
- zlog_ferr(
+ flog_err(
BGP_ERR_NH_UPD,
"parse nexthop update: instance not found for vrf_id %u",
vrf_id);
SET_FLAG(peer->cap, PEER_CAP_AS4_RCV);
if (hdr->length != CAPABILITY_CODE_AS4_LEN) {
- zlog_ferr(BGP_ERR_PKT_OPEN,
+ flog_err(BGP_ERR_PKT_OPEN,
"%s AS4 capability has incorrect data length %d",
peer->host, hdr->length);
return 0;
&& !peer->afc_nego[AFI_IP6][SAFI_ENCAP]
&& !peer->afc_nego[AFI_IP6][SAFI_FLOWSPEC]
&& !peer->afc_nego[AFI_L2VPN][SAFI_EVPN]) {
- zlog_ferr(BGP_ERR_PKT_OPEN,
+ flog_err(BGP_ERR_PKT_OPEN,
"%s [Error] Configured AFI/SAFIs do not "
"overlap with received MP capabilities",
peer->host);
/* Just in case we have a silly peer who sends AS4 capability set to 0
*/
if (CHECK_FLAG(peer->cap, PEER_CAP_AS4_RCV) && !as4) {
- zlog_ferr(BGP_ERR_PKT_OPEN,
+ flog_err(BGP_ERR_PKT_OPEN,
"%s bad OPEN, got AS4 capability, but AS4 set to 0",
peer->host);
bgp_notify_send_with_data(peer, BGP_NOTIFY_OPEN_ERR,
* BGP_AS_TRANS, for some unknown reason.
*/
if (as4 == BGP_AS_TRANS) {
- zlog_ferr(
+ flog_err(
BGP_ERR_PKT_OPEN,
"%s [AS4] NEW speaker using AS_TRANS for AS4, not allowed",
peer->host);
if (CHECK_FLAG(peer->cap, PEER_CAP_AS4_RCV)
&& as4 != remote_as) {
/* raise error, log this, close session */
- zlog_ferr(
+ flog_err(
BGP_ERR_PKT_OPEN,
"%s bad OPEN, got AS4 capability, but remote_as %u"
" mismatch with 16bit 'myasn' %u in open",
/* Get sockname. */
if ((ret = bgp_getsockname(peer)) < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s: bgp_getsockname() failed for peer: %s",
__FUNCTION__, peer->host);
return BGP_Stop;
|| peer->afc_nego[AFI_IP][SAFI_ENCAP]) {
if (!peer->nexthop.v4.s_addr) {
#if defined(HAVE_CUMULUS)
- zlog_ferr(
+ flog_err(
BGP_ERR_SND_FAIL,
"%s: No local IPv4 addr resetting connection, fd %d",
peer->host, peer->fd);
|| peer->afc_nego[AFI_IP6][SAFI_ENCAP]) {
if (IN6_IS_ADDR_UNSPECIFIED(&peer->nexthop.v6_global)) {
#if defined(HAVE_CUMULUS)
- zlog_ferr(
+ flog_err(
BGP_ERR_SND_FAIL,
"%s: No local IPv6 addr resetting connection, fd %d",
peer->host, peer->fd);
/* Status must be Established. */
if (peer->status != Established) {
- zlog_ferr(BGP_ERR_INVALID_STATUS,
+ flog_err(BGP_ERR_INVALID_STATUS,
"%s [FSM] Update packet received under status %s",
peer->host,
lookup_msg(bgp_status_msg, peer->status, NULL));
Attribute Length + 23 exceeds the message Length), then the Error
Subcode is set to Malformed Attribute List. */
if (stream_pnt(s) + 2 > end) {
- zlog_ferr(BGP_ERR_UPDATE_RCV,
+ flog_err(BGP_ERR_UPDATE_RCV,
"%s [Error] Update packet error"
" (packet length is short for unfeasible length)",
peer->host);
/* Unfeasible Route Length check. */
if (stream_pnt(s) + withdraw_len > end) {
- zlog_ferr(BGP_ERR_UPDATE_RCV,
+ flog_err(BGP_ERR_UPDATE_RCV,
"%s [Error] Update packet error"
" (packet unfeasible length overflow %d)",
peer->host, withdraw_len);
ret = bgp_dump_attr(&attr, peer->rcvd_attr_str, BUFSIZ);
if (attr_parse_ret == BGP_ATTR_PARSE_WITHDRAW)
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s rcvd UPDATE with errors in attr(s)!! Withdrawing route.",
peer->host);
}
if (nlri_ret < 0) {
- zlog_ferr(BGP_ERR_UPDATE_RCV,
+ flog_err(BGP_ERR_UPDATE_RCV,
"%s [Error] Error parsing NLRI", peer->host);
if (peer->status == Established)
bgp_notify_send(
/* If peer does not have the capability, send notification. */
if (!CHECK_FLAG(peer->cap, PEER_CAP_REFRESH_ADV)) {
- zlog_ferr(BGP_ERR_NO_CAP,
+ flog_err(BGP_ERR_NO_CAP,
"%s [Error] BGP route refresh is not enabled",
peer->host);
bgp_notify_send(peer, BGP_NOTIFY_HEADER_ERR,
/* Status must be Established. */
if (peer->status != Established) {
- zlog_ferr(
+ flog_err(
BGP_ERR_INVALID_STATUS,
"%s [Error] Route refresh packet received under status %s",
peer->host,
/* If peer does not have the capability, send notification. */
if (!CHECK_FLAG(peer->cap, PEER_CAP_DYNAMIC_ADV)) {
- zlog_ferr(BGP_ERR_NO_CAP,
+ flog_err(BGP_ERR_NO_CAP,
"%s [Error] BGP dynamic capability is not enabled",
peer->host);
bgp_notify_send(peer, BGP_NOTIFY_HEADER_ERR,
/* Status must be Established. */
if (peer->status != Established) {
- zlog_ferr(
+ flog_err(
BGP_ERR_NO_CAP,
"%s [Error] Dynamic capability packet received under status %s",
peer->host,
memory_order_relaxed);
mprc = bgp_open_receive(peer, size);
if (mprc == BGP_Stop)
- zlog_ferr(
+ flog_err(
BGP_ERR_PKT_OPEN,
"%s: BGP OPEN receipt failed for peer: %s",
__FUNCTION__, peer->host);
peer->readtime = monotime(NULL);
mprc = bgp_update_receive(peer, size);
if (mprc == BGP_Stop)
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s: BGP UPDATE receipt failed for peer: %s",
__FUNCTION__, peer->host);
memory_order_relaxed);
mprc = bgp_notify_receive(peer, size);
if (mprc == BGP_Stop)
- zlog_ferr(
+ flog_err(
BGP_ERR_NOTIFY_RCV,
"%s: BGP NOTIFY receipt failed for peer: %s",
__FUNCTION__, peer->host);
memory_order_relaxed);
mprc = bgp_keepalive_receive(peer, size);
if (mprc == BGP_Stop)
- zlog_ferr(
+ flog_err(
BGP_ERR_KEEP_RCV,
"%s: BGP KEEPALIVE receipt failed for peer: %s",
__FUNCTION__, peer->host);
memory_order_relaxed);
mprc = bgp_route_refresh_receive(peer, size);
if (mprc == BGP_Stop)
- zlog_ferr(
+ flog_err(
BGP_ERR_RFSH_RCV,
"%s: BGP ROUTEREFRESH receipt failed for peer: %s",
__FUNCTION__, peer->host);
memory_order_relaxed);
mprc = bgp_capability_receive(peer, size);
if (mprc == BGP_Stop)
- zlog_ferr(
+ flog_err(
BGP_ERR_CAP_RCV,
"%s: BGP CAPABILITY receipt failed for peer: %s",
__FUNCTION__, peer->host);
action_count++;
if (action_count > ACTIONS_MAX_NUM) {
if (BGP_DEBUG(pbr, PBR_ERROR))
- zlog_ferr(BGP_ERR_FLOWSPEC_PACKET,
+ flog_err(BGP_ERR_FLOWSPEC_PACKET,
"%s: flowspec actions exceeds limit (max %u)",
__func__, action_count);
break;
if (!bgp_zebra_tm_chunk_obtained()) {
if (BGP_DEBUG(pbr, PBR_ERROR))
- zlog_ferr(BGP_ERR_TABLE_CHUNK,
+ flog_err(BGP_ERR_TABLE_CHUNK,
"%s: table chunk not obtained yet",
__func__);
return;
if (bgp_pbr_build_and_validate_entry(p, info, &api) < 0) {
if (BGP_DEBUG(pbr, PBR_ERROR))
- zlog_ferr(BGP_ERR_FLOWSPEC_INSTALLATION,
+ flog_err(BGP_ERR_FLOWSPEC_INSTALLATION,
"%s: cancel updating entry %p in bgp pbr",
__func__, info);
return;
/* Prefix length check. */
if (p.prefixlen > prefix_blen(&p) * 8) {
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s [Error] Update packet error (wrong prefix length %d for afi %u)",
peer->host, p.prefixlen, packet->afi);
/* When packet overflow occur return immediately. */
if (pnt + psize > lim) {
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s [Error] Update packet error (prefix length %d overflows packet)",
peer->host, p.prefixlen);
/* Defensive coding, double-check the psize fits in a struct
* prefix */
if (psize > (ssize_t)sizeof(p.u)) {
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s [Error] Update packet error (prefix length %d too large for prefix storage %zu)",
peer->host, p.prefixlen, sizeof(p.u));
* be logged locally, and the prefix SHOULD be
* ignored.
*/
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s: IPv4 unicast NLRI is multicast address %s, ignoring",
peer->host, inet_ntoa(p.u.prefix4));
if (IN6_IS_ADDR_LINKLOCAL(&p.u.prefix6)) {
char buf[BUFSIZ];
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s: IPv6 unicast NLRI is link-local address %s, ignoring",
peer->host,
if (IN6_IS_ADDR_MULTICAST(&p.u.prefix6)) {
char buf[BUFSIZ];
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s: IPv6 unicast NLRI is multicast address %s, ignoring",
peer->host,
/* Packet length consistency check. */
if (pnt != lim) {
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDATE_RCV,
"%s [Error] Update packet error (prefix length mismatch with total length)",
peer->host);
if (!updgrp) {
updgrp = update_group_create(paf);
if (!updgrp) {
- zlog_ferr(BGP_ERR_UPDGRP_CREATE,
+ flog_err(BGP_ERR_UPDGRP_CREATE,
"couldn't create update group for peer %s",
paf->peer->host);
return;
* NLRI then
* return */
if (space_remaining < space_needed) {
- zlog_ferr(
+ flog_err(
BGP_ERR_UPDGRP_ATTR_LEN,
"u%" PRIu64 ":s%" PRIu64
" attributes too long, cannot send UPDATE",
for (ALL_LIST_ELEMENTS(bm->bgp, node, nnode, bgp)) {
if (use_json) {
if (!(json = json_object_new_object())) {
- zlog_ferr(
+ flog_err(
BGP_ERR_JSON_MEM_ERROR,
"Unable to allocate memory for JSON object");
vty_out(vty,
return -1;
ret = tm_get_table_chunk(zclient, chunk_size, start, end);
if (ret < 0) {
- zlog_ferr(BGP_ERR_TABLE_CHUNK,
+ flog_err(BGP_ERR_TABLE_CHUNK,
"BGP: Error getting table chunk %u", chunk_size);
return -1;
}
ipa_len = stream_getl(s);
if (ipa_len != 0 && ipa_len != IPV4_MAX_BYTELEN
&& ipa_len != IPV6_MAX_BYTELEN) {
- zlog_ferr(BGP_ERR_MACIP_LEN,
+ flog_err(BGP_ERR_MACIP_LEN,
"%u:Recv MACIP %s with invalid IP addr length %d",
vrf_id, (command == ZEBRA_MACIP_ADD) ? "Add" : "Del",
ipa_len);
STREAM_GETL(s, last);
if (zclient->redist_default != proto) {
- zlog_ferr(BGP_ERR_LM_ERROR, "Got LM msg with wrong proto %u",
+ flog_err(BGP_ERR_LM_ERROR, "Got LM msg with wrong proto %u",
proto);
return;
}
if (zclient->instance != instance) {
- zlog_ferr(BGP_ERR_LM_ERROR, "Got LM msg with wrong instance %u",
+ flog_err(BGP_ERR_LM_ERROR, "Got LM msg with wrong instance %u",
proto);
return;
}
first < MPLS_LABEL_UNRESERVED_MIN ||
last > MPLS_LABEL_UNRESERVED_MAX) {
- zlog_ferr(BGP_ERR_LM_ERROR, "%s: Invalid Label chunk: %u - %u",
+ flog_err(BGP_ERR_LM_ERROR, "%s: Invalid Label chunk: %u - %u",
__func__, first, last);
return;
}
int active;
if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
- zlog_ferr(BGP_ERR_PEER_GROUP, "%s was called for peer-group %s",
+ flog_err(BGP_ERR_PEER_GROUP, "%s was called for peer-group %s",
__func__, peer->host);
return 1;
}
safi_t safi)
{
if (CHECK_FLAG(peer->sflags, PEER_STATUS_GROUP)) {
- zlog_ferr(BGP_ERR_PEER_GROUP, "%s was called for peer-group %s",
+ flog_err(BGP_ERR_PEER_GROUP, "%s was called for peer-group %s",
__func__, peer->host);
return 1;
}
peer->afc[afi][safi] = 0;
if (peer_af_delete(peer, afi, safi) != 0) {
- zlog_ferr(BGP_ERR_PEER_DELETE,
+ flog_err(BGP_ERR_PEER_DELETE,
"couldn't delete af structure for peer %s",
peer->host);
return 1;
group = peer->group;
if (peer_af_delete(peer, afi, safi) != 0) {
- zlog_ferr(BGP_ERR_PEER_DELETE,
+ flog_err(BGP_ERR_PEER_DELETE,
"couldn't delete af structure for peer %s",
peer->host);
}
size);
break;
default:
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: Unknown group type=%d",
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: Unknown group type=%d",
__func__, type);
/* should never happen */
assert("Unknown type" == NULL);
criteria, search_cb);
break;
default:
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: Unknown group type=%d",
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: Unknown group type=%d",
__func__, type);
/* should never happen */
assert("Unknown type" == NULL);
break;
default:
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
return;
}
break;
default:
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
return;
}
default:
/* not expected */
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: bad safi %d", __func__,
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: bad safi %d", __func__,
safi);
return rfapiBgpInfoFilteredImportBadSafi;
}
if (!afi) {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_DEVELOPMENT,
"%s: can't get afi of route node", __func__);
return;
}
struct prefix ce_nexthop;
if (!afi) {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: bad afi", __func__);
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: bad afi", __func__);
return;
}
afi_t afi = family2afi(rn->p.family);
if (!afi) {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_DEVELOPMENT,
"%s: can't get afi of route node", __func__);
return;
}
afi_t afi = family2afi(rn->p.family);
if (!afi) {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: can't get afi route node",
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: can't get afi route node",
__func__);
return;
}
afi_t afi = family2afi(rfd->vn_addr.addr_family);
if (!afi) {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_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 {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: bad afi %d",
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: bad afi %d",
__func__, afi);
return;
}
afi_t afi = family2afi(rfd->vn_addr.addr_family);
if (!afi) {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_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 {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: bad afi %d",
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: bad afi %d",
__func__, afi);
return;
}
if (afi == AFI_IP || afi == AFI_IP6) {
rt = import_table->imported_vpn[afi];
} else {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
return;
}
struct attr *iattr;
if (!afi) {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_DEVELOPMENT,
"%s: can't get afi of route node", __func__);
return;
}
struct vnc_export_info *eti;
if (!afi) {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: can't get afi route node",
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: can't get afi route node",
__func__);
return;
}
*/
if (!afi) {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: can't get afi of prefix",
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: can't get afi of prefix",
__func__);
return;
}
}
if (!afi) {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: can't get afi of prefix",
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: can't get afi of prefix",
__func__);
return;
}
assert(rfg);
if (!afi) {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: can't get afi of prefix",
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: can't get afi of prefix",
__func__);
return;
}
VNC_RHNCK(enter);
if (!afi) {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: can't get afi of prefix",
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: can't get afi of prefix",
__func__);
return;
}
return;
if (rn->p.family != AF_INET && rn->p.family != AF_INET6) {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_DEVELOPMENT,
"%s: invalid route node addr family", __func__);
return;
}
return;
if (afi != AFI_IP && afi != AFI_IP6) {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: invalid vn addr family",
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: invalid vn addr family",
__func__);
return;
}
if (afi == AFI_IP || afi == AFI_IP6) {
rt = import_table->imported_vpn[afi];
} else {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: bad afi %d", __func__, afi);
return;
}
if (!family) {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: computed bad family: %d",
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: computed bad family: %d",
__func__, family);
return;
}
ret = sscanf(ver_string, "%" SCNu32 ".%" SCNu32, &FRR_MAJOR,
&FRR_MINOR);
if (ret != 2)
- zlog_ferr(EIGRP_ERR_PACKET,
+ flog_err(EIGRP_ERR_PACKET,
"Did not Properly parse %s, please fix VERSION string",
VERSION);
}
void eigrp_nbr_hard_restart(struct eigrp_neighbor *nbr, struct vty *vty)
{
if (nbr == NULL) {
- zlog_ferr(EIGRP_ERR_CONFIG,
+ flog_err(EIGRP_ERR_CONFIG,
"Nbr Hard restart: Neighbor not specified.");
return;
}
#endif
if (eigrpd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"eigrp_sock_init: could not raise privs, %s",
safe_strerror(errno));
if (eigrp_sock < 0) {
int save_errno = errno;
if (eigrpd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"eigrp_sock_init: could not lower privs, %s",
safe_strerror(errno));
- zlog_ferr(LIB_ERR_SOCKET, "eigrp_read_sock_init: socket: %s",
+ flog_err(LIB_ERR_SOCKET, "eigrp_read_sock_init: socket: %s",
safe_strerror(save_errno));
exit(1);
}
if (ret < 0) {
int save_errno = errno;
if (eigrpd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"eigrp_sock_init: could not lower privs, %s",
safe_strerror(errno));
zlog_warn("Can't set IP_HDRINCL option for fd %d: %s",
if (ret < 0) {
int save_errno = errno;
if (eigrpd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"eigrpd_sock_init: could not lower privs, %s",
safe_strerror(errno));
zlog_warn("can't set sockopt IP_TOS %d to socket %d: %s", tos,
zlog_warn("Can't set pktinfo option for fd %d", eigrp_sock);
if (eigrpd_privs.change(ZPRIVS_LOWER)) {
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"eigrp_sock_init: could not lower privs, %s",
safe_strerror(errno));
}
if (eigrp->maxsndbuflen >= buflen)
return;
if (eigrpd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not raise privs, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not raise privs, %s",
__func__, safe_strerror(errno));
/* Now we try to set SO_SNDBUF to what our caller has requested
else
zlog_warn("%s: failed to get SO_SNDBUF", __func__);
if (eigrpd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not lower privs, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not lower privs, %s",
__func__, safe_strerror(errno));
}
/* Get one packet from queue. */
ep = eigrp_fifo_next(ei->obuf);
if (!ep) {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_DEVELOPMENT,
"%s: Interface %s no packet on queue?",
__PRETTY_FUNCTION__, ei->ifp->name);
goto out;
}
if (ep->length < EIGRP_HEADER_LEN) {
- zlog_ferr(EIGRP_ERR_PACKET,
+ flog_err(EIGRP_ERR_PACKET,
"%s: Packet just has a header?", __PRETTY_FUNCTION__);
eigrp_header_dump((struct eigrp_header *)ep->s->data);
eigrp_packet_delete(ei);
stream_putw(s, length);
break;
default:
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_DEVELOPMENT,
"%s: Unexpected prefix length: %d",
__PRETTY_FUNCTION__, pe->destination->prefixlen);
return 0;
if (!dest) {
char buf[PREFIX_STRLEN];
- zlog_ferr(EIGRP_ERR_PACKET,
+ flog_err(EIGRP_ERR_PACKET,
"%s: Received prefix %s which we do not know about",
__PRETTY_FUNCTION__,
prefix2str(&dest_addr, buf, sizeof(buf)));
}
break;
default:
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: Please implement handler",
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: Please implement handler",
__PRETTY_FUNCTION__);
break;
}
eigrp->networks = eigrp_topology_new();
if ((eigrp_socket = eigrp_sock_init()) < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"eigrp_new: fatal error: eigrp_sock_init was unable to open a socket");
exit(1);
}
int retval = ISIS_OK;
if (isisd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not raise privs, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not raise privs, %s",
__func__, safe_strerror(errno));
retval = open_bpf_dev(circuit);
end:
if (isisd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not lower privs, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not lower privs, %s",
__func__, safe_strerror(errno));
return retval;
return ISIS_OK;
if (circuit->area->lsp_mtu > isis_circuit_pdu_size(circuit)) {
- zlog_ferr(
+ flog_err(
ISIS_ERR_CONFIG,
"Interface MTU %zu on %s is too low to support area lsp mtu %u!",
isis_circuit_pdu_size(circuit),
if (circuit->circ_type == CIRCUIT_T_BROADCAST) {
circuit->circuit_id = isis_circuit_id_gen(isis, circuit->interface);
if (!circuit->circuit_id) {
- zlog_ferr(
+ flog_err(
ISIS_ERR_CONFIG,
"There are already 255 broadcast circuits active!");
return ISIS_ERROR;
case IF_UP_FROM_Z:
isis_circuit_if_add(circuit, (struct interface *)arg);
if (isis_circuit_up(circuit) != ISIS_OK) {
- zlog_ferr(
+ flog_err(
ISIS_ERR_CONFIG,
"Could not bring up %s because of invalid config.",
circuit->interface->name);
- zlog_ferr(
+ flog_err(
ISIS_ERR_CONFIG,
"Clearing config for %s. Please re-examine it.",
circuit->interface->name);
int retval = ISIS_OK;
if (isisd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not raise privs, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not raise privs, %s",
__func__, safe_strerror(errno));
retval = open_dlpi_dev(circuit);
end:
if (isisd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not lower privs, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not lower privs, %s",
__func__, safe_strerror(errno));
return retval;
return; /* No change */
if (!(newtype & circuit->area->is_type)) {
- zlog_ferr(
+ flog_err(
ISIS_ERR_CONFIG,
"ISIS-Evt (%s) circuit type change - invalid level %s because area is %s",
circuit->area->area_tag, circuit_t2string(newtype),
struct isis_area *area, int level, bool confusion)
{
if (lsp->own_lsp) {
- zlog_ferr(
+ flog_err(
LIB_ERR_DEVELOPMENT,
"ISIS-Upd (%s): BUG updating LSP %s still marked as own LSP",
area->area_tag, rawlspid_print(lsp->hdr.lsp_id));
lsp = lsp_search(lspid, lspdb);
if (!lsp) {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_DEVELOPMENT,
"lsp_regenerate_pseudo: no l%d LSP %s found!", level,
rawlspid_print(lsp_id));
return ISIS_ERROR;
retval = circuit->tx(circuit, level);
if (retval != ISIS_OK)
- zlog_ferr(ISIS_ERR_PACKET,
+ flog_err(ISIS_ERR_PACKET,
"ISIS-Upd (%s): Send L%d LSP PSNP on %s failed",
circuit->area->area_tag, level,
circuit->interface->name);
}
if (!p2p_hello && !(level & iih.circ_type)) {
- zlog_ferr(ISIS_ERR_PACKET,
+ flog_err(ISIS_ERR_PACKET,
"Level %d LAN Hello with Circuit Type %d", level,
iih.circ_type);
return ISIS_ERROR;
/* Verify that at least the 8 bytes fixed header have been received */
if (stream_get_endp(circuit->rcv_stream) < ISIS_FIXED_HDR_LEN) {
- zlog_ferr(ISIS_ERR_PACKET, "PDU is too short to be IS-IS.");
+ flog_err(ISIS_ERR_PACKET, "PDU is too short to be IS-IS.");
return ISIS_ERROR;
}
uint8_t max_area_addrs = stream_getc(circuit->rcv_stream);
if (idrp == ISO9542_ESIS) {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_DEVELOPMENT,
"No support for ES-IS packet IDRP=%" PRIx8, idrp);
return ISIS_ERROR;
}
if (idrp != ISO10589_ISIS) {
- zlog_ferr(ISIS_ERR_PACKET, "Not an IS-IS packet IDRP=%" PRIx8,
+ flog_err(ISIS_ERR_PACKET, "Not an IS-IS packet IDRP=%" PRIx8,
idrp);
return ISIS_ERROR;
}
}
if (id_len != 0 && id_len != ISIS_SYS_ID_LEN) {
- zlog_ferr(
+ flog_err(
ISIS_ERR_PACKET,
"IDFieldLengthMismatch: ID Length field in a received PDU %" PRIu8
", while the parameter for this IS is %u",
}
if (length != expected_length) {
- zlog_ferr(ISIS_ERR_PACKET,
+ flog_err(ISIS_ERR_PACKET,
"Exepected fixed header length = %" PRIu8
" but got %" PRIu8,
expected_length, length);
}
if (stream_get_endp(circuit->rcv_stream) < length) {
- zlog_ferr(
+ flog_err(
ISIS_ERR_PACKET,
"PDU is too short to contain fixed header of given PDU type.");
return ISIS_ERROR;
/* either 3 or 0 */
if (max_area_addrs != 0 && max_area_addrs != isis->max_area_addrs) {
- zlog_ferr(
+ flog_err(
ISIS_ERR_PACKET,
"maximumAreaAddressesMismatch: maximumAreaAdresses in a received PDU %" PRIu8
" while the parameter for this IS is %u",
retval = circuit->tx(circuit, level);
if (retval != ISIS_OK)
- zlog_ferr(ISIS_ERR_PACKET,
+ flog_err(ISIS_ERR_PACKET,
"ISIS-Adj (%s): Send L%d IIH on %s failed",
circuit->area->area_tag, level,
circuit->interface->name);
int retval = circuit->tx(circuit, level);
if (retval != ISIS_OK) {
- zlog_ferr(ISIS_ERR_PACKET,
+ flog_err(ISIS_ERR_PACKET,
"ISIS-Snp (%s): Send L%d CSNP on %s failed",
circuit->area->area_tag, level,
circuit->interface->name);
int retval = circuit->tx(circuit, level);
if (retval != ISIS_OK) {
- zlog_ferr(ISIS_ERR_PACKET,
+ flog_err(ISIS_ERR_PACKET,
"ISIS-Snp (%s): Send L%d PSNP on %s failed",
circuit->area->area_tag, level,
circuit->interface->name);
* than
* the circuit's MTU. So handle and log this case here. */
if (stream_get_endp(lsp->pdu) > stream_get_size(circuit->snd_stream)) {
- zlog_ferr(
+ flog_err(
ISIS_ERR_PACKET,
"ISIS-Upd (%s): Can't send L%d LSP %s, seq 0x%08" PRIx32
", cksum 0x%04" PRIx16 ", lifetime %" PRIu16
clear_srm = 0;
retval = circuit->tx(circuit, lsp->level);
if (retval != ISIS_OK) {
- zlog_ferr(ISIS_ERR_PACKET,
+ flog_err(ISIS_ERR_PACKET,
"ISIS-Upd (%s): Send L%d LSP on %s failed %s",
circuit->area->area_tag, lsp->level,
circuit->interface->name,
int retval = ISIS_OK;
if (isisd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not raise privs, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not raise privs, %s",
__func__, safe_strerror(errno));
retval = open_packet_socket(circuit);
end:
if (isisd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not lower privs, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not lower privs, %s",
__func__, safe_strerror(errno));
return retval;
} else if (VTYPE_IP(vtype)) {
memcpy(&vertex->N.ip, &n->ip, sizeof(n->ip));
} else {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "Unknown Vertex Type");
+ flog_err(LIB_ERR_DEVELOPMENT, "Unknown Vertex Type");
}
}
nullfd = open("/dev/null", O_RDONLY | O_NOCTTY);
if (nullfd == -1) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"%s: failed to open /dev/null: %s", __func__,
safe_strerror(errno));
} else {
msg[strlen(msg) - 1] = '\0';
switch (slm->priority) {
case LOG_EMERG:
- zlog_ferr(LIB_ERR_SNMP,
+ flog_err(LIB_ERR_SNMP,
"snmp[emerg]: %s", msg ? msg : slm->msg);
break;
case LOG_ALERT:
- zlog_ferr(LIB_ERR_SNMP,
+ flog_err(LIB_ERR_SNMP,
"snmp[alert]: %s", msg ? msg : slm->msg);
break;
case LOG_CRIT:
- zlog_ferr(LIB_ERR_SNMP,
+ flog_err(LIB_ERR_SNMP,
"snmp[crit]: %s", msg ? msg : slm->msg);
break;
case LOG_ERR:
- zlog_ferr(LIB_ERR_SNMP,
+ flog_err(LIB_ERR_SNMP,
"snmp[err]: %s", msg ? msg : slm->msg);
break;
case LOG_WARNING:
iov_alloc * sizeof(*iov));
} else {
/* This should absolutely never occur. */
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"%s: corruption detected: iov_small overflowed; "
"head %p, tail %p, head->next %p",
__func__, (void *)b->head,
while (written > 0) {
struct buffer_data *d;
if (!(d = b->head)) {
- zlog_ferr(
+ flog_err(
LIB_ERR_DEVELOPMENT,
"%s: corruption detected: buffer queue empty, but written is %lu",
__func__, (unsigned long)written);
cwd[MAXPATHLEN] = '\0';
if (getcwd(cwd, MAXPATHLEN) == NULL) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"config_log_file: Unable to alloc mem!");
return CMD_WARNING_CONFIG_FAILED;
}
return 0;
out_err:
- zlog_ferr(LIB_ERR_ZMQ, "ZeroMQ read error: %s(%d)", strerror(errno),
+ flog_err(LIB_ERR_ZMQ, "ZeroMQ read error: %s(%d)", strerror(errno),
errno);
if (cb->read.cb_error)
cb->read.cb_error(cb->read.arg, cb->zmqsock);
return 0;
out_err:
- zlog_ferr(LIB_ERR_ZMQ, "ZeroMQ write error: %s(%d)", strerror(errno),
+ flog_err(LIB_ERR_ZMQ, "ZeroMQ write error: %s(%d)", strerror(errno),
errno);
if (cb->write.cb_error)
cb->write.cb_error(cb->write.arg, cb->zmqsock);
#define IFNAME_RB_INSERT(vrf, ifp) \
if (RB_INSERT(if_name_head, &vrf->ifaces_by_name, (ifp))) \
- zlog_ferr( \
+ flog_err( \
LIB_ERR_INTERFACE, \
"%s(%s): corruption detected -- interface with this " \
"name exists already in VRF %u!", \
#define IFNAME_RB_REMOVE(vrf, ifp) \
if (RB_REMOVE(if_name_head, &vrf->ifaces_by_name, (ifp)) == NULL) \
- zlog_ferr( \
+ flog_err( \
LIB_ERR_INTERFACE, \
"%s(%s): corruption detected -- interface with this " \
"name doesn't exist in VRF %u!", \
#define IFINDEX_RB_INSERT(vrf, ifp) \
if (RB_INSERT(if_index_head, &vrf->ifaces_by_index, (ifp))) \
- zlog_ferr( \
+ flog_err( \
LIB_ERR_INTERFACE, \
"%s(%u): corruption detected -- interface with this " \
"ifindex exists already in VRF %u!", \
#define IFINDEX_RB_REMOVE(vrf, ifp) \
if (RB_REMOVE(if_index_head, &vrf->ifaces_by_index, (ifp)) == NULL) \
- zlog_ferr( \
+ flog_err( \
LIB_ERR_INTERFACE, \
"%s(%u): corruption detected -- interface with this " \
"ifindex doesn't exist in VRF %u!", \
nullfd = open("/dev/null", O_RDONLY | O_NOCTTY);
if (nullfd == -1) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"%s: failed to open /dev/null: %s", __func__,
safe_strerror(errno));
} else {
} else if (di->daemon_mode) {
int nullfd = open("/dev/null", O_RDONLY | O_NOCTTY);
if (nullfd == -1) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"%s: failed to open /dev/null: %s", __func__,
safe_strerror(errno));
} else {
size = backtrace(array, array_size(array));
if (size <= 0 || (size_t)size > array_size(array)) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"Cannot get backtrace, returned invalid # of frames %d "
"(valid range is between 1 and %lu)",
size, (unsigned long)(array_size(array)));
}
zlog(priority, "Backtrace for %d stack frames:", size);
if (!(strings = backtrace_symbols(array, size))) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"Cannot get backtrace symbols (out of memory?)");
for (i = 0; i < size; i++)
zlog(priority, "[bt %d] %p", i, array[i]);
void memory_oom(size_t size, const char *name)
{
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"out of memory: failed to allocate %zu bytes for %s"
"object",
size, name);
save_errno = errno;
umask(oldumask);
if (zl->fp == NULL) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"Log rotate failed: cannot open file %s for append: %s",
zl->filename, safe_strerror(save_errno));
ret = -1;
unsigned int i;
if (zroute >= array_size(route_types)) {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "unknown zebra route type: %u",
+ flog_err(LIB_ERR_DEVELOPMENT, "unknown zebra route type: %u",
zroute);
return &unknown;
}
return &route_types[i];
}
}
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_DEVELOPMENT,
"internal error: cannot find route type %u in table!",
zroute);
return &unknown;
const char *zserv_command_string(unsigned int command)
{
if (command >= array_size(command_types)) {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "unknown zserv command type: %u",
+ flog_err(LIB_ERR_DEVELOPMENT, "unknown zserv command type: %u",
command);
return unknown.string;
}
extern void zlog_debug(const char *format, ...) PRINTF_ATTRIBUTE(1, 2);
/* For logs which have error codes associated with them */
-#define zlog_ferr(ferr_id, format, ...) \
+#define flog_err(ferr_id, format, ...) \
zlog_err("[EC %d] " format, ferr_id, ##__VA_ARGS__)
}
if (!ns_is_enabled(ns)) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"Can not enable NS %u: %s!", ns->ns_id,
safe_strerror(errno));
return 0;
/* Non default NS. leave */
if (ns->ns_id == NS_UNKNOWN) {
- zlog_ferr(LIB_ERR_NS,
+ flog_err(LIB_ERR_NS,
"Can not enable NS %s %u: Invalid NSID",
ns->name, ns->ns_id);
return 0;
if (have_netns_enabled < 0) {
ns_default_ns_fd = open(NS_DEFAULT_NAME, O_RDONLY);
if (ns_default_ns_fd == -1)
- zlog_ferr(LIB_ERR_NS,
+ flog_err(LIB_ERR_NS,
"NS initialization failure %d(%s)", errno,
safe_strerror(errno));
} else {
ns_init();
default_ns = ns_get_created_internal(NULL, NULL, default_ns_id);
if (!default_ns) {
- zlog_ferr(LIB_ERR_NS, "%s: failed to create the default NS!",
+ flog_err(LIB_ERR_NS, "%s: failed to create the default NS!",
__func__);
exit(1);
}
/* Enable the default NS. */
if (!ns_enable(default_ns, NULL)) {
- zlog_ferr(LIB_ERR_NS, "%s: failed to enable the default NS!",
+ flog_err(LIB_ERR_NS, "%s: failed to enable the default NS!",
__func__);
exit(1);
}
oldumask = umask(0777 & ~PIDFILE_MASK);
fd = open(path, O_RDWR | O_CREAT, PIDFILE_MASK);
if (fd < 0) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"Can't create pid lock file %s (%s), exiting", path,
safe_strerror(errno));
umask(oldumask);
lock.l_whence = SEEK_SET;
if (fcntl(fd, F_SETLK, &lock) < 0) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"Could not lock pid_file %s (%s), exiting",
path, safe_strerror(errno));
exit(1);
sprintf(buf, "%d\n", (int)pid);
pidsize = strlen(buf);
if ((tmp = write(fd, buf, pidsize)) != (int)pidsize)
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"Could not write pid %d to pid_file %s, rc was %d: %s",
(int)pid, path, tmp, safe_strerror(errno));
else if (ftruncate(fd, pidsize) < 0)
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"Could not truncate pid_file %s to %u bytes: %s",
path, (unsigned int)pidsize,
safe_strerror(errno));
memcpy((void *)dest->u.prefix_flowspec.ptr,
(void *)src->u.prefix_flowspec.ptr, len);
} else {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_DEVELOPMENT,
"prefix_copy(): Unknown address family %d",
src->family);
assert(0);
sigdelset(&newmask, SIGKILL);
if ((sigprocmask(SIG_BLOCK, &newmask, &oldmask)) < 0) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"quagga_signal_timer: couldnt block signals!");
return -1;
}
/* DEBUG */
if (!key) {
- zlog_ferr(LIB_ERR_DEVELOPMENT, "%s: key is 0, value is %p",
+ flog_err(LIB_ERR_DEVELOPMENT, "%s: key is 0, value is %p",
__func__, value);
}
int ret = getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *)&optval,
&optlen);
if (ret < 0) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"fd %d: can't getsockopt SO_SNDBUF: %d (%s)", sock,
errno, safe_strerror(errno));
return ret;
if (ENOENT == errno)
ret = 0;
else
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"sockopt_tcp_signature: setsockopt(%d): %s",
sock, safe_strerror(errno));
}
int ret;
if (cap->change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"routing_socket: Can't raise privileges");
ret = setsockopt(sock, SOL_SOCKET, SO_MARK, &mark, sizeof(mark));
if (cap->change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"routing_socket: Can't lower privileges");
return ret;
/* The default VRF always exists. */
default_vrf = vrf_get(VRF_DEFAULT, VRF_DEFAULT_NAME);
if (!default_vrf) {
- zlog_ferr(LIB_ERR_VRF_START,
+ flog_err(LIB_ERR_VRF_START,
"vrf_init: failed to create the default VRF!");
exit(1);
}
/* Enable the default VRF. */
if (!vrf_enable(default_vrf)) {
- zlog_ferr(LIB_ERR_VRF_START,
+ flog_err(LIB_ERR_VRF_START,
"vrf_init: failed to enable the default VRF!");
exit(1);
}
ret = vrf_switch_to_netns(vrf_id);
if (ret < 0)
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s: Can't switch to VRF %u (%s)", __func__, vrf_id,
safe_strerror(errno));
save_errno = errno;
ret2 = vrf_switchback_to_initial();
if (ret2 < 0)
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s: Can't switchback from VRF %u (%s)", __func__,
vrf_id, safe_strerror(errno));
errno = save_errno;
return CMD_WARNING_CONFIG_FAILED;
if (vrf_daemon_privs && vrf_daemon_privs->change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: Can't raise privileges",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: Can't raise privileges",
__func__);
ret = vrf_netns_handler_create(vty, vrf, pathname,
NS_UNKNOWN, NS_UNKNOWN);
if (vrf_daemon_privs && vrf_daemon_privs->change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: Can't lower privileges",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: Can't lower privileges",
__func__);
return ret;
}
ret = vrf_switch_to_netns(vrf_id);
if (ret < 0)
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s: Can't switch to VRF %u (%s)", __func__, vrf_id,
safe_strerror(errno));
ret = getaddrinfo(node, service, hints, res);
save_errno = errno;
ret2 = vrf_switchback_to_initial();
if (ret2 < 0)
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s: Can't switchback from VRF %u (%s)", __func__,
vrf_id, safe_strerror(errno));
errno = save_errno;
ret = vrf_switch_to_netns(vrf_id);
if (ret < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s: Can't switch to VRF %u (%s)", __func__, vrf_id,
safe_strerror(errno));
return 0;
saved_errno = errno;
ret = vrf_switchback_to_initial();
if (ret < 0)
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s: Can't switchback from VRF %u (%s)", __func__,
vrf_id, safe_strerror(errno));
errno = saved_errno;
ret = vrf_switch_to_netns(vrf_id);
if (ret < 0)
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s: Can't switch to VRF %u (%s)", __func__, vrf_id,
safe_strerror(errno));
ret = sockunion_socket(su);
save_errno = errno;
ret2 = vrf_switchback_to_initial();
if (ret2 < 0)
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s: Can't switchback from VRF %u (%s)", __func__,
vrf_id, safe_strerror(errno));
errno = save_errno;
TELNET_NAWS_SB_LEN,
(unsigned long)vty->sb_len);
else if (sizeof(vty->sb_buf) < TELNET_NAWS_SB_LEN)
- zlog_ferr(
+ flog_err(
LIB_ERR_DEVELOPMENT,
"Bug detected: sizeof(vty->sb_buf) %lu < %d, too small to handle the telnet NAWS option",
(unsigned long)sizeof(vty->sb_buf),
ret = getaddrinfo(hostname, port_str, &req, &ainfo);
if (ret != 0) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"getaddrinfo failed: %s", gai_strerror(ret));
exit(1);
}
/* Make UNIX domain socket. */
sock = socket(AF_UNIX, SOCK_STREAM, 0);
if (sock < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"Cannot create unix stream socket: %s",
safe_strerror(errno));
return;
ret = bind(sock, (struct sockaddr *)&serv, len);
if (ret < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"Cannot bind path %s: %s",
path, safe_strerror(errno));
close(sock); /* Avoid sd leak. */
ret = listen(sock, 5);
if (ret < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"listen(fd %d) failed: %s", sock,
safe_strerror(errno));
close(sock); /* Avoid sd leak. */
if ((int)ids.gid_vty > 0) {
/* set group of socket */
if (chown(path, -1, ids.gid_vty)) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"vty_serv_un: could chown socket, %s",
safe_strerror(errno));
}
nl = strchr(vty->error_buf, '\n');
if (nl)
*nl = '\0';
- zlog_ferr(LIB_ERR_VTY,
+ flog_err(LIB_ERR_VTY,
"ERROR: %s on config line %u: %s", message, line_num,
vty->error_buf);
}
if (config_file != NULL) {
if (!IS_DIRECTORY_SEP(config_file[0])) {
if (getcwd(cwd, MAXPATHLEN) == NULL) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"Failure to determine Current Working Directory %d!",
errno);
exit(1);
zlog_warn(
"WARNING: using backup configuration file!");
else {
- zlog_ferr(LIB_ERR_VTY,
+ flog_err(LIB_ERR_VTY,
"can't open configuration file [%s]",
config_file);
exit(1);
"WARNING: using backup configuration file!");
fullpath = config_default_dir;
} else {
- zlog_ferr(LIB_ERR_VTY,
+ flog_err(LIB_ERR_VTY,
"can't open configuration file [%s]",
config_default_dir);
goto tmp_free_and_out;
* Hence not worrying about it too much.
*/
if (!chdir(SYSCONFDIR)) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"Failure to chdir to %s, errno: %d",
SYSCONFDIR, errno);
exit(-1);
}
if (getcwd(cwd, MAXPATHLEN) == NULL) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"Failure to getcwd, errno: %d", errno);
exit(-1);
}
STREAM_GETW(s, *cmd);
if (*version != ZSERV_VERSION || *marker != ZEBRA_HEADER_MARKER) {
- zlog_ferr(LIB_ERR_ZAPI_MISSMATCH,
+ flog_err(LIB_ERR_ZAPI_MISSMATCH,
"%s: socket %d version mismatch, marker %d, version %d",
__func__, sock, *marker, *version);
return -1;
char buf[PREFIX2STR_BUFFER];
prefix2str(&api->prefix, buf,
sizeof(buf));
- zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+ flog_err(LIB_ERR_ZAPI_ENCODE,
"%s: prefix %s: can't encode "
"%u labels (maximum is %u)",
__func__, buf,
for (i = 0; i < bwclassnum && i < MAX_CLASS_TYPE; i++)
iflp->unrsv_bw[i] = stream_getf(s);
if (i < bwclassnum)
- zlog_ferr(LIB_ERR_ZAPI_MISSMATCH,
+ flog_err(LIB_ERR_ZAPI_MISSMATCH,
"%s: received %d > %d (MAX_CLASS_TYPE) bw entries"
" - outdated library?",
__func__, bwclassnum, MAX_CLASS_TYPE);
struct interface *ifp = if_lookup_by_index(ifindex, VRF_DEFAULT);
if (ifp == NULL) {
- zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+ flog_err(LIB_ERR_ZAPI_ENCODE,
"%s: unknown ifindex %u, shouldn't happen", __func__,
ifindex);
return NULL;
size);
}
if (ret != 0) {
- zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+ flog_err(LIB_ERR_ZAPI_ENCODE,
"%s: Invalid Sync Message Reply", __func__);
return -1;
}
ret = writen(zclient->sock, s->data, stream_get_endp(s));
if (ret < 0) {
- zlog_ferr(LIB_ERR_ZAPI_SOCKET, "Can't write to zclient sock");
+ flog_err(LIB_ERR_ZAPI_SOCKET, "Can't write to zclient sock");
close(zclient->sock);
zclient->sock = -1;
return -1;
}
if (ret == 0) {
- zlog_ferr(LIB_ERR_ZAPI_SOCKET, "Zclient sock closed");
+ flog_err(LIB_ERR_ZAPI_SOCKET, "Zclient sock closed");
close(zclient->sock);
zclient->sock = -1;
return -1;
/* sanity */
if (proto != zclient->redist_default)
- zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+ flog_err(LIB_ERR_ZAPI_ENCODE,
"Wrong proto (%u) in LM connect response. Should be %u",
proto, zclient->redist_default);
if (instance != zclient->instance)
- zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+ flog_err(LIB_ERR_ZAPI_ENCODE,
"Wrong instId (%u) in LM connect response. Should be %u",
instance, zclient->instance);
ret = writen(zclient->sock, s->data, stream_get_endp(s));
if (ret < 0) {
- zlog_ferr(LIB_ERR_ZAPI_SOCKET,
+ flog_err(LIB_ERR_ZAPI_SOCKET,
"Can't write to zclient sock");
close(zclient->sock);
zclient->sock = -1;
return -1;
}
if (ret == 0) {
- zlog_ferr(LIB_ERR_ZAPI_SOCKET,
+ flog_err(LIB_ERR_ZAPI_SOCKET,
"Zclient sock closed");
close(zclient->sock);
zclient->sock = -1;
/* sanities */
if (proto != zclient->redist_default)
- zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+ flog_err(LIB_ERR_ZAPI_ENCODE,
"Wrong proto (%u) in get chunk response. Should be %u",
proto, zclient->redist_default);
if (instance != zclient->instance)
- zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+ flog_err(LIB_ERR_ZAPI_ENCODE,
"Wrong instId (%u) in get chunk response Should be %u",
instance, zclient->instance);
/* not owning this response */
if (keep != response_keep) {
- zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+ flog_err(LIB_ERR_ZAPI_ENCODE,
"Invalid Label chunk: %u - %u, keeps mismatch %u != %u",
*start, *end, keep, response_keep);
}
/* sanity */
if (*start > *end || *start < MPLS_LABEL_UNRESERVED_MIN
|| *end > MPLS_LABEL_UNRESERVED_MAX) {
- zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+ flog_err(LIB_ERR_ZAPI_ENCODE,
"Invalid Label chunk: %u - %u", *start, *end);
return -1;
}
ret = writen(zclient->sock, s->data, stream_get_endp(s));
if (ret < 0) {
- zlog_ferr(LIB_ERR_ZAPI_SOCKET, "Can't write to zclient sock");
+ flog_err(LIB_ERR_ZAPI_SOCKET, "Can't write to zclient sock");
close(zclient->sock);
zclient->sock = -1;
return -1;
}
if (ret == 0) {
- zlog_ferr(LIB_ERR_ZAPI_SOCKET,
+ flog_err(LIB_ERR_ZAPI_SOCKET,
"Zclient sock connection closed");
close(zclient->sock);
zclient->sock = -1;
ret = writen(zclient->sock, s->data, stream_get_endp(s));
if (ret < 0) {
- zlog_ferr(LIB_ERR_ZAPI_SOCKET,
+ flog_err(LIB_ERR_ZAPI_SOCKET,
"%s: can't write to zclient->sock", __func__);
close(zclient->sock);
zclient->sock = -1;
return -1;
}
if (ret == 0) {
- zlog_ferr(LIB_ERR_ZAPI_SOCKET,
+ flog_err(LIB_ERR_ZAPI_SOCKET,
"%s: zclient->sock connection closed", __func__);
close(zclient->sock);
zclient->sock = -1;
stream_write(s, (uint8_t *)&pw->nexthop.ipv6, 16);
break;
default:
- zlog_ferr(LIB_ERR_ZAPI_ENCODE,
+ flog_err(LIB_ERR_ZAPI_ENCODE,
"%s: unknown af", __func__);
return -1;
}
command = stream_getw(zclient->ibuf);
if (marker != ZEBRA_HEADER_MARKER || version != ZSERV_VERSION) {
- zlog_ferr(LIB_ERR_ZAPI_MISSMATCH,
+ flog_err(LIB_ERR_ZAPI_MISSMATCH,
"%s: socket %d version mismatch, marker %d, version %d",
__func__, zclient->sock, marker, version);
return zclient_failed(zclient);
}
if (length < ZEBRA_HEADER_SIZE) {
- zlog_ferr(LIB_ERR_ZAPI_MISSMATCH,
+ flog_err(LIB_ERR_ZAPI_MISSMATCH,
"%s: socket %d message length %u is less than %d ",
__func__, zclient->sock, length, ZEBRA_HEADER_SIZE);
return zclient_failed(zclient);
union sockunion *))
{
if (query->callback != NULL) {
- zlog_ferr(NHRP_ERR_RESOLVER,
+ flog_err(NHRP_ERR_RESOLVER,
"Trying to resolve '%s', but previous query was not finished yet",
hostname);
return;
if (str2sockunion(buf,
&sactx->local.host)
< 0)
- zlog_ferr(NHRP_ERR_SWAN,
+ flog_err(NHRP_ERR_SWAN,
"VICI: bad strongSwan local-host: %s",
buf);
} else if (blob_equal(key, "local-id")
if (str2sockunion(buf,
&sactx->remote.host)
< 0)
- zlog_ferr(NHRP_ERR_SWAN,
+ flog_err(NHRP_ERR_SWAN,
"VICI: bad strongSwan remote-host: %s",
buf);
} else if (blob_equal(key, "remote-id")
case VICI_KEY_VALUE:
if (blob_equal(key, "errmsg")
&& blob2buf(val, buf, sizeof(buf)))
- zlog_ferr(NHRP_ERR_SWAN, "VICI: strongSwan: %s", buf);
+ flog_err(NHRP_ERR_SWAN, "VICI: strongSwan: %s", buf);
break;
default:
break;
break;
case VICI_EVENT_UNKNOWN:
case VICI_CMD_UNKNOWN:
- zlog_ferr(NHRP_ERR_SWAN,
+ flog_err(NHRP_ERR_SWAN,
"VICI: StrongSwan does not support mandatory events (unpatched?)");
break;
case VICI_EVENT_CONFIRM:
/* receive message */
len = ospf6_recvmsg(&src, &dst, &ifindex, iovector);
if (len > iobuflen) {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_DEVELOPMENT,
"Excess message read");
return 0;
}
/* send message */
len = ospf6_sendmsg(src, dst, &oi->interface->ifindex, iovector);
if (len != ntohs(oh->length))
- zlog_ferr(LIB_ERR_DEVELOPMENT, "Could not send entire message");
+ flog_err(LIB_ERR_DEVELOPMENT, "Could not send entire message");
}
static uint32_t ospf6_packet_max(struct ospf6_interface *oi)
int ospf6_serv_sock(void)
{
if (ospf6d_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"ospf6_serv_sock: could not raise privs");
ospf6_sock = socket(AF_INET6, SOCK_RAW, IPPROTO_OSPFIGP);
if (ospf6_sock < 0) {
zlog_warn("Network: can't create OSPF6 socket.");
if (ospf6d_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"ospf6_sock_init: could not lower privs");
return -1;
}
if (ospf6d_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"ospf6_sock_init: could not lower privs");
/* set socket options */
ret = setsockopt(ospf6_sock, IPPROTO_IPV6, option, &mreq6,
sizeof(mreq6));
if (ret < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"Network: setsockopt (%d) on ifindex %d failed: %s",
option, ifindex, safe_strerror(errno));
return ret;
if (link_error == 0 && num == table->count)
return;
- zlog_ferr(LIB_ERR_DEVELOPMENT, "PANIC !!");
- zlog_ferr(LIB_ERR_DEVELOPMENT, "Something has gone wrong with ospf6_route_table[%p]", table);
+ flog_err(LIB_ERR_DEVELOPMENT, "PANIC !!");
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_DEVELOPMENT,
"No nexthop ifindex at vertex %s", v->name);
return;
}
ret = zclient_route_send(ZEBRA_ROUTE_ADD, zclient, &api);
if (ret < 0)
- zlog_ferr(LIB_ERR_ZAPI_SOCKET,
+ flog_err(LIB_ERR_ZAPI_SOCKET,
"zclient_route_send() %s failed: %s",
(type == REM ? "delete" : "add"),
safe_strerror(errno));
ospf',
when quagga(ospfd) is restarted */
if (!ospf_get_instance(instance)) {
- zlog_ferr(OSPF_ERR_INIT_FAIL, "OSPF instance init failed: %s",
+ flog_err(OSPF_ERR_INIT_FAIL, "OSPF instance init failed: %s",
strerror(errno));
exit(1);
}
return -1;
}
if (ospfd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"ospf_sock_init: could not raise privs, %s",
safe_strerror(errno));
int save_errno = errno;
if (ospfd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"ospf_sock_init: could not lower privs, %s",
safe_strerror(save_errno));
ospf->fd = ospf_sock;
out:
if (ospfd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"ospf_sock_init: could not lower privs, %s",
safe_strerror(errno));
void ospf_packet_add(struct ospf_interface *oi, struct ospf_packet *op)
{
if (!oi->obuf) {
- zlog_ferr(
+ flog_err(
OSPF_ERR_PKT_PROCESS,
"ospf_packet_add(interface %s in state %d [%s], packet type %s, "
"destination %s) called with NULL obuf, ignoring "
struct ospf_packet *op)
{
if (!oi->obuf) {
- zlog_ferr(
+ flog_err(
OSPF_ERR_PKT_PROCESS,
"ospf_packet_add(interface %s in state %d [%s], packet type %s, "
"destination %s) called with NULL obuf, ignoring "
char buf2[INET_ADDRSTRLEN];
char buf3[INET_ADDRSTRLEN];
- zlog_ferr(OSPF_ERR_ROUTER_LSA_MISMATCH,
+ flog_err(OSPF_ERR_ROUTER_LSA_MISMATCH,
"Incoming Router-LSA from %s with "
"Adv-ID[%s] != LS-ID[%s]",
inet_ntop(AF_INET, &ospfh->router_id,
inet_ntop(AF_INET,
&lsa->data->adv_router,
buf3, INET_ADDRSTRLEN));
- zlog_ferr(
+ flog_err(
OSPF_ERR_DOMAIN_CORRUPT,
"OSPF domain compromised by attack or corruption. "
"Verify correct operation of -ALL- OSPF routers.");
case EXT_SUBTLV_PREFIX_SID:
psid = (struct ext_subtlv_prefix_sid *)sub_tlvh;
if (psid->algorithm != SR_ALGORITHM_SPF) {
- zlog_ferr(OSPF_ERR_SR_INVALID_ALGORITHM,
+ flog_err(OSPF_ERR_SR_INVALID_ALGORITHM,
"SR (%s): Unsupported Algorithm",
__func__);
XFREE(MTYPE_OSPF_SR_PARAMS, srp);
return;
if (OspfSR.neighbors == NULL) {
- zlog_ferr(OSPF_ERR_SR_INVALID_DB,
+ flog_err(OSPF_ERR_SR_INVALID_DB,
"SR (%s): Abort! no valid SR DataBase", __func__);
return;
}
/* Sanity check */
if (srn == NULL) {
- zlog_ferr(OSPF_ERR_SR_NODE_CREATE,
+ flog_err(OSPF_ERR_SR_NODE_CREATE,
"SR (%s): Abort! can't create SR node in hash table",
__func__);
return;
}
if ((srn->instance != 0) && (srn->instance != ntohl(lsah->id.s_addr))) {
- zlog_ferr(OSPF_ERR_SR_INVALID_LSA_ID,
+ flog_err(OSPF_ERR_SR_INVALID_LSA_ID,
"SR (%s): Abort! Wrong "
"LSA ID 4.0.0.%u for SR node %s/%u",
__func__, GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
/* Sanity check */
if (OspfSR.neighbors == NULL) {
- zlog_ferr(OSPF_ERR_SR_INVALID_DB,
+ flog_err(OSPF_ERR_SR_INVALID_DB,
"SR (%s): Abort! no valid SR Data Base", __func__);
return;
}
/* Sanity check */
if (srn == NULL) {
- zlog_ferr(OSPF_ERR_SR_NODE_CREATE,
+ flog_err(OSPF_ERR_SR_NODE_CREATE,
"SR (%s): Abort! no entry in SRDB for SR Node %s",
__func__, inet_ntoa(lsah->adv_router));
return;
}
if ((srn->instance != 0) && (srn->instance != ntohl(lsah->id.s_addr))) {
- zlog_ferr(
+ flog_err(
OSPF_ERR_SR_INVALID_LSA_ID,
"SR (%s): Abort! Wrong LSA ID 4.0.0.%u for SR node %s",
__func__, GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
/* Sanity check */
if (OspfSR.neighbors == NULL) {
- zlog_ferr(OSPF_ERR_SR_INVALID_DB,
+ flog_err(OSPF_ERR_SR_INVALID_DB,
"SR (%s): Abort! no valid SR DataBase", __func__);
return;
}
/* Sanity check */
if (srn == NULL) {
- zlog_ferr(OSPF_ERR_SR_NODE_CREATE,
+ flog_err(OSPF_ERR_SR_NODE_CREATE,
"SR (%s): Abort! can't create SR node in hash table",
__func__);
return;
/* Sanity check */
if (OspfSR.neighbors == NULL) {
- zlog_ferr(OSPF_ERR_SR_INVALID_DB,
+ flog_err(OSPF_ERR_SR_INVALID_DB,
"SR (%s): Abort! no valid SR DataBase", __func__);
return;
}
/* Sanity check */
if (OspfSR.neighbors == NULL) {
- zlog_ferr(OSPF_ERR_SR_INVALID_DB,
+ flog_err(OSPF_ERR_SR_INVALID_DB,
"SR (%s): Abort! no valid SR DataBase", __func__);
return;
}
/* Sanity check */
if (srn == NULL) {
- zlog_ferr(OSPF_ERR_SR_NODE_CREATE,
+ flog_err(OSPF_ERR_SR_NODE_CREATE,
"SR (%s): Abort! can't create SR node in hash table",
__func__);
return;
/* Sanity check */
if (OspfSR.neighbors == NULL) {
- zlog_ferr(OSPF_ERR_SR_INVALID_DB,
+ flog_err(OSPF_ERR_SR_INVALID_DB,
"SR (%s): Abort! no valid SR DataBase", __func__);
return;
}
if (old_vrf_id != ospf->vrf_id) {
if (ospfd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(
+ flog_err(
LIB_ERR_PRIVILEGES,
"ospf_vrf_link: could not raise privs");
ret = ospf_sock_init(ospf);
if (ospfd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(
+ flog_err(
LIB_ERR_PRIVILEGES,
"ospf_sock_init: could not lower privs");
}
if (!join) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"IGMP socket fd=%d could not join any group on interface address %s",
fd, inet_ntoa(ifaddr));
close(fd);
THREAD_OFF(igmp->t_igmp_read);
if (close(igmp->fd)) {
- zlog_ferr(
+ flog_err(
LIB_ERR_SOCKET,
"Failure closing IGMP socket %s fd=%d on interface %s: errno=%d: %s",
inet_ntoa(igmp->ifaddr), igmp->fd,
msg_size = IGMP_V3_SOURCES_OFFSET + (num_sources << 2);
if (msg_size > query_buf_size) {
- zlog_ferr(
+ flog_err(
LIB_ERR_DEVELOPMENT,
"%s %s: unable to send: msg_size=%zd larger than query_buf_size=%d",
__FILE__, __PRETTY_FUNCTION__, msg_size,
*/
if (pim->vrf_id != VRF_DEFAULT) {
if (pimd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(
+ flog_err(
LIB_ERR_PRIVILEGES,
"pim_mroute_socket_enable: could not raise privs, %s",
safe_strerror(errno));
}
if (pimd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(
+ flog_err(
LIB_ERR_PRIVILEGES,
"pim_mroute_socket_enable: could not lower privs, %s",
safe_strerror(errno));
int fd;
if (pimd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"pim_mroute_socket_enable: could not raise privs, %s",
safe_strerror(errno));
#endif
if (pimd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"pim_mroute_socket_enable: could not lower privs, %s",
safe_strerror(errno));
* the flow. Accounting for such cases requires lot of
* changes; perhaps
* address this in the next release? - XXX */
- zlog_ferr(
+ flog_err(
LIB_ERR_DEVELOPMENT,
"MSDP sa %s SPT teardown is causing the local entry to be removed",
sa->sg_str);
/* If getsockopt is fail, this is fatal error. */
if (ret < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"can't get sockopt for nonblocking connect");
pim_msdp_peer_reset_tcp_conn(mp, "connect-failed");
return;
if (prefix_len != 32) {
/* ignore SA update if the prefix length is not 32 */
- zlog_ferr(PIM_ERR_MSDP_PACKET,
+ flog_err(PIM_ERR_MSDP_PACKET,
"rxed sa update with invalid prefix length %d",
prefix_len);
return;
socklen_t optlen = sizeof(optval);
if (getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &optval, &optlen) < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "getsockopt of SO_SNDBUF failed %s\n",
+ flog_err(LIB_ERR_SOCKET, "getsockopt of SO_SNDBUF failed %s\n",
safe_strerror(errno));
return;
}
if (optval < size) {
if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size))
< 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"Couldn't increase send buffer: %s\n",
safe_strerror(errno));
}
/* re-register accept thread */
accept_sock = THREAD_FD(thread);
if (accept_sock < 0) {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_SOCKET, "pim_msdp_sock_accept failed (%s)",
+ flog_err(LIB_ERR_SOCKET, "pim_msdp_sock_accept failed (%s)",
safe_strerror(errno));
return -1;
}
if (!mp || !PIM_MSDP_PEER_IS_LISTENER(mp)) {
++pim->msdp.rejected_accepts;
if (PIM_DEBUG_MSDP_EVENTS) {
- zlog_ferr(PIM_ERR_MSDP_PACKET,
+ flog_err(PIM_ERR_MSDP_PACKET,
"msdp peer connection refused from %s",
sockunion2str(&su, buf, SU_ADDRSTRLEN));
}
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "socket: %s", safe_strerror(errno));
+ flog_err(LIB_ERR_SOCKET, "socket: %s", safe_strerror(errno));
return sock;
}
struct interface *ifp =
if_lookup_by_name(pim->vrf->name, pim->vrf_id);
if (!ifp) {
- zlog_ferr(LIB_ERR_INTERFACE,
+ flog_err(LIB_ERR_INTERFACE,
"%s: Unable to lookup vrf interface: %s",
__PRETTY_FUNCTION__, pim->vrf->name);
close(sock);
return -1;
}
if (pim_socket_bind(sock, ifp)) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s: Unable to bind to socket: %s",
__PRETTY_FUNCTION__, safe_strerror(errno));
close(sock);
}
if (pimd_privs.change(ZPRIVS_RAISE)) {
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"pim_msdp_socket: could not raise privs, %s",
safe_strerror(errno));
}
rc = bind(sock, (struct sockaddr *)&sin, socklen);
if (pimd_privs.change(ZPRIVS_LOWER)) {
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"pim_msdp_socket: could not lower privs, %s",
safe_strerror(errno));
}
if (rc < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "pim_msdp_socket bind to port %d: %s",
+ flog_err(LIB_ERR_SOCKET, "pim_msdp_socket bind to port %d: %s",
ntohs(sin.sin_port), safe_strerror(errno));
close(sock);
return rc;
rc = listen(sock, 3 /* backlog */);
if (rc < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "pim_msdp_socket listen: %s",
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_SOCKET, "pim_msdp_socket socket failure: %s",
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_INTERFACE,
+ flog_err(LIB_ERR_INTERFACE,
"%s: Unable to lookup vrf interface: %s",
__PRETTY_FUNCTION__, mp->pim->vrf->name);
return -1;
}
if (pim_socket_bind(mp->fd, ifp)) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"pim_msdp_socket connect bind failure: %s",
safe_strerror(errno));
close(mp->fd);
if (neigh->prefix_list == addr_list) {
if (addr_list) {
- zlog_ferr(
+ flog_err(
LIB_ERR_DEVELOPMENT,
"%s: internal error: trying to replace same prefix list=%p",
__PRETTY_FUNCTION__, (void *)addr_list);
delete_message);
if (!ifp->info) {
- zlog_ferr(PIM_ERR_CONFIG,
+ flog_err(PIM_ERR_CONFIG,
"%s: %s: but PIM not enabled on interface %s (!)",
__PRETTY_FUNCTION__, delete_message, ifp->name);
return;
rp_info = XCALLOC(MTYPE_PIM_RP, sizeof(*rp_info));
if (!str2prefix("224.0.0.0/4", &rp_info->group)) {
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_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) {
- zlog_ferr(
+ flog_err(
LIB_ERR_DEVELOPMENT,
"%s: BUG We should have found default group information\n",
__PRETTY_FUNCTION__);
rn = route_node_get(pim->rp_table, &rp_info->group);
if (rn) {
if (rn->info != rp_info)
- zlog_ferr(
+ flog_err(
LIB_ERR_DEVELOPMENT,
"Expected rn->info to be equal to rp_info");
int fd;
if (pimd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"pim_sockek_raw: could not raise privs, %s",
safe_strerror(errno));
fd = socket(AF_INET, SOCK_RAW, protocol);
if (pimd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"pim_socket_raw: could not lower privs, %s",
safe_strerror(errno));
const int on = 1;
if (pimd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not raise privs, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not raise privs, %s",
__PRETTY_FUNCTION__, safe_strerror(errno));
if (setsockopt(fd, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on)))
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s: Could not turn on IP_HDRINCL option: %s",
__PRETTY_FUNCTION__, safe_strerror(errno));
if (pimd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not lower privs, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not lower privs, %s",
__PRETTY_FUNCTION__, safe_strerror(errno));
}
#ifdef SO_BINDTODEVICE
if (pimd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not raise privs, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not raise privs, %s",
__PRETTY_FUNCTION__, safe_strerror(errno));
ret = setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, ifp->name,
strlen(ifp->name));
if (pimd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "%s: could not lower privs, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "%s: could not lower privs, %s",
__PRETTY_FUNCTION__, safe_strerror(errno));
#endif
fd, errno, safe_strerror(errno));
}
#else
- zlog_ferr(
+ flog_err(
LIB_ERR_DEVELOPMENT,
"%s %s: Missing IP_PKTINFO and IP_RECVDSTADDR: unable to get dst addr from recvmsg()",
__FILE__, __PRETTY_FUNCTION__);
sizeof(ifaddr_str)))
sprintf(ifaddr_str, "<ifaddr?>");
- zlog_ferr(
+ flog_err(
LIB_ERR_SOCKET,
"Failure socket joining fd=%d group %s on interface address %s: errno=%d: %s",
fd, group_str, ifaddr_str, errno, safe_strerror(errno));
if (first) {
if (!str2prefix(PIM_SSM_STANDARD_RANGE, &group_ssm))
- zlog_ferr(LIB_ERR_DEVELOPMENT,
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s: could not create socket: errno=%d: %s",
__PRETTY_FUNCTION__, errno, safe_strerror(errno));
return -1;
safe_strerror(errno));
}
#else
- zlog_ferr(
+ flog_err(
LIB_ERR_DEVELOPMENT,
"%s %s: missing IP_PKTINFO and IP_RECVDSTADDR: unable to get dst addr from recvmsg()",
__FILE__, __PRETTY_FUNCTION__);
result = gettimeofday(tv, 0);
if (result) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"%s: gettimeofday() failure: errno=%d: %s",
__PRETTY_FUNCTION__, errno, safe_strerror(errno));
}
struct timeval now_tv;
if (gettime_monotonic(&now_tv)) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_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)) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_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)) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_ZAPI_SOCKET, "%s: zclient_new() failure",
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_ZAPI_MISSMATCH,
+ flog_err(LIB_ERR_ZAPI_MISSMATCH,
"%s: zclient_read_header() failed",
__PRETTY_FUNCTION__);
zclient_lookup_failed(zlookup);
/* Check socket. */
if (zlookup->sock < 0) {
- zlog_ferr(LIB_ERR_ZAPI_SOCKET,
+ flog_err(LIB_ERR_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) {
- zlog_ferr(
+ flog_err(
LIB_ERR_SOCKET,
"%s: writen() failure: %d writing to zclient lookup socket",
__PRETTY_FUNCTION__, errno);
return -2;
}
if (ret == 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s: connection closed on zclient lookup socket",
__PRETTY_FUNCTION__);
zclient_lookup_failed(zlookup);
count = stream_get_endp(s);
ret = writen(zlookup->sock, s->data, count);
if (ret <= 0) {
- zlog_ferr(
+ flog_err(
LIB_ERR_SOCKET,
"%s: writen() failure: %d writing to zclient lookup socket",
__PRETTY_FUNCTION__, errno);
err = zclient_read_header(s, zlookup->sock, &length, &marker,
&version, &vrf_id, &command);
if (err < 0) {
- zlog_ferr(LIB_ERR_ZAPI_MISSMATCH,
+ flog_err(LIB_ERR_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;
- zlog_ferr(
+ flog_err(
LIB_ERR_ZAPI_MISSMATCH,
"%s: Received wrong %s(%s) information requested",
__PRETTY_FUNCTION__, pim_str_sg_dump(&more),
void pim_init()
{
if (!inet_aton(PIM_ALL_PIM_ROUTERS, &qpim_all_pim_routers_addr)) {
- zlog_ferr(
+ flog_err(
LIB_ERR_SOCKET,
"%s %s: could not solve %s to group address: errno=%d: %s",
__FILE__, __PRETTY_FUNCTION__, PIM_ALL_PIM_ROUTERS,
/* Join to multicast group. */
if (rip_multicast_join(ifp, rip->sock) < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"multicast join failed, interface %s not running",
ifp->name);
return 0;
/* Check packet length. */
if (len < (RIP_HEADER_SIZE + RIP_RTE_SIZE)) {
- zlog_ferr(RIP_ERR_PACKET,
+ flog_err(RIP_ERR_PACKET,
"rip_auth_md5_set(): packet length %ld is less than minimum length.",
len);
return;
/* Make datagram socket. */
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sock < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
+ flog_err(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
safe_strerror(errno));
exit(1);
}
#endif
if (ripd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"rip_create_socket: could not raise privs");
setsockopt_so_recvbuf(sock, RIP_UDP_RCV_BUF);
if ((ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr))) < 0)
{
int save_errno = errno;
if (ripd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"rip_create_socket: could not lower privs");
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s: Can't bind socket %d to %s port %d: %s",
__func__, sock, inet_ntoa(addr.sin_addr),
(int)ntohs(addr.sin_port), safe_strerror(save_errno));
}
if (ripd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"rip_create_socket: could not lower privs");
return sock;
* for this call as a workaround.
*/
if (ripngd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(
+ flog_err(
LIB_ERR_PRIVILEGES,
"ripng_multicast_join: could not raise privs");
save_errno = errno;
if (ripngd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(
+ flog_err(
LIB_ERR_PRIVILEGES,
"ripng_multicast_join: could not lower privs");
/* Join to multicast group. */
if (ripng_multicast_join(ifp) < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"multicast join failed, interface %s not running",
ifp->name);
return 0;
sock = socket(AF_INET6, SOCK_DGRAM, 0);
if (sock < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "Can't make ripng socket");
+ flog_err(LIB_ERR_SOCKET, "Can't make ripng socket");
return sock;
}
ripaddr.sin6_port = htons(RIPNG_PORT_DEFAULT);
if (ripngd_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"ripng_make_socket: could not raise privs");
ret = bind(sock, (struct sockaddr *)&ripaddr, sizeof(ripaddr));
if (ret < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "Can't bind ripng socket: %s.",
+ flog_err(LIB_ERR_SOCKET, "Can't bind ripng socket: %s.",
safe_strerror(errno));
if (ripngd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"ripng_make_socket: could not lower privs");
goto error;
}
if (ripngd_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"ripng_make_socket: could not lower privs");
return sock;
if (ret < 0) {
if (to)
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"RIPng send fail on %s to %s: %s", ifp->name,
inet6_ntoa(to->sin6_addr),
safe_strerror(errno));
else
- zlog_ferr(LIB_ERR_SOCKET, "RIPng send fail on %s: %s",
+ flog_err(LIB_ERR_SOCKET, "RIPng send fail on %s: %s",
ifp->name, safe_strerror(errno));
}
switch (child = fork()) {
case -1:
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_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);
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_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. */
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"Forked background command [pid %d]: %s", (int)child,
shell_cmd);
return child;
switch (child = waitpid(-1, &status, WNOHANG)) {
case -1:
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"waitpid failed: %s", safe_strerror(errno));
return;
case 0:
* completed. */
gettimeofday(&restart->time, NULL);
} else {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"waitpid returned status for an unknown child process %d",
(int)child);
name = "(unknown)";
zlog_debug("%s %s process %d exited normally", what,
name, (int)child);
} else
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"cannot interpret %s %s process %d wait status 0x%x",
what, name, (int)child, status);
phase_check();
dmn->t_wakeup = NULL;
if (try_connect(dmn) < 0) {
SET_WAKEUP_DOWN(dmn);
- zlog_ferr(WATCHFRR_ERR_CONNECTION,
+ flog_err(WATCHFRR_ERR_CONNECTION,
"%s state -> down : initial connection attempt failed",
dmn->name);
dmn->state = DAEMON_DOWN;
static void daemon_down(struct daemon *dmn, const char *why)
{
if (IS_UP(dmn) || (dmn->state == DAEMON_INIT))
- zlog_ferr(WATCHFRR_ERR_CONNECTION,
+ flog_err(WATCHFRR_ERR_CONNECTION,
"%s state -> down : %s", dmn->name, why);
else if (gs.loglevel > LOG_DEBUG)
zlog_debug("%s still down : %s", dmn->name, why);
of creating a socket. */
if (access(addr.sun_path, W_OK) < 0) {
if (errno != ENOENT)
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"%s(%s): set_nonblocking/cloexec(%d) failed",
__func__, addr.sun_path, sock);
close(sock);
static int phase_hanging(struct thread *t_hanging)
{
gs.t_phase_hanging = NULL;
- zlog_ferr(WATCHFRR_ERR_CONNECTION,
+ flog_err(WATCHFRR_ERR_CONNECTION,
"Phase [%s] hanging for %ld seconds, aborting phased restart",
phase_str[gs.phase], PHASE_TIMEOUT);
gs.phase = PHASE_NONE;
dmn->t_wakeup = NULL;
if (dmn->state != DAEMON_UNRESPONSIVE)
- zlog_ferr(WATCHFRR_ERR_CONNECTION,
+ flog_err(WATCHFRR_ERR_CONNECTION,
"%s: no longer unresponsive (now %s), "
"wakeup should have been cancelled!",
dmn->name, state_str[dmn->state]);
dmn->t_wakeup = NULL;
dmn->state = DAEMON_UNRESPONSIVE;
- zlog_ferr(WATCHFRR_ERR_CONNECTION,
+ flog_err(WATCHFRR_ERR_CONNECTION,
"%s state -> unresponsive : no response yet to ping "
"sent %ld seconds ago",
dmn->name, gs.timeout);
ret = getifaddrs(&ifap);
if (ret != 0) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL, "getifaddrs(): %s",
+ flog_err(LIB_ERR_SYSTEM_CALL, "getifaddrs(): %s",
safe_strerror(errno));
return -1;
}
for (ifapfree = ifap; ifap; ifap = ifap->ifa_next) {
if (ifap->ifa_addr == NULL) {
- zlog_ferr(
+ flog_err(
LIB_ERR_INTERFACE,
"%s: nonsensical ifaddr with NULL ifa_addr, ifname %s",
__func__,
ifp = if_lookup_by_name(ifap->ifa_name, VRF_DEFAULT);
if (ifp == NULL) {
- zlog_ferr(LIB_ERR_INTERFACE,
+ flog_err(LIB_ERR_INTERFACE,
"if_getaddrs(): Can't lookup interface %s\n",
ifap->ifa_name);
continue;
char *buf = NULL;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
sock = socket(af, SOCK_DGRAM, 0);
if (sock < 0) {
safe_strerror(errno));
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
return -1;
}
save_errno = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
if (ret < 0) {
zlog_warn("interface_list_ioctl: SIOCGLIFNUM failed %s",
lifconf.lifc_buf = buf;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
ret = ioctl(sock, SIOCGLIFCONF, &lifconf);
zlog_warn("SIOCGLIFCONF: %s", safe_strerror(errno));
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
goto end;
}
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
/* Allocate interface. */
lifreq = lifconf.lifc_req;
if (((oifp = if_lookup_by_index_per_ns(zns, ifi_index)) != NULL)
&& (oifp != ifp)) {
if (ifi_index == IFINDEX_INTERNAL)
- zlog_ferr(
+ flog_err(
LIB_ERR_INTERFACE,
"Netlink is setting interface %s ifindex to reserved internal value %u",
ifp->name, ifi_index);
"interface index %d was renamed from %s to %s",
ifi_index, oifp->name, ifp->name);
if (if_is_up(oifp))
- zlog_ferr(
+ flog_err(
LIB_ERR_INTERFACE,
"interface rename detected on up interface: index %d was renamed from %s to %s, results are uncertain!",
ifi_index, oifp->name, ifp->name);
vrf = vrf_get((vrf_id_t)ifi->ifi_index,
name); // It would create vrf
if (!vrf) {
- zlog_ferr(LIB_ERR_INTERFACE, "VRF %s id %u not created",
+ flog_err(LIB_ERR_INTERFACE, "VRF %s id %u not created",
name, ifi->ifi_index);
return;
}
/* Enable the created VRF. */
if (!vrf_enable(vrf)) {
- zlog_ferr(LIB_ERR_INTERFACE,
+ flog_err(LIB_ERR_INTERFACE,
"Failed to enable VRF %s id %u", name,
ifi->ifi_index);
return;
/* use ioctl to get IP address of an interface */
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
sd = vrf_socket(PF_INET, SOCK_DGRAM, IPPROTO_IP, interface->vrf_id,
NULL);
if (sd < 0) {
/* Get the current link state for the interface */
rc = vrf_ioctl(interface->vrf_id, sd, SIOCETHTOOL, (char *)&ifdata);
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
if (rc < 0) {
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug(
ifp = if_lookup_by_index_per_ns(zns, ifa->ifa_index);
if (ifp == NULL) {
- zlog_ferr(
+ flog_err(
LIB_ERR_INTERFACE,
"netlink_interface_addr can't find interface by index %d",
ifa->ifa_index);
struct zebra_if *zif;
if (if_is_up(ifp)) {
- zlog_ferr(
+ flog_err(
LIB_ERR_INTERFACE,
"interface %s vrf %u index %d is still up while being deleted.",
ifp->name, ifp->vrf_id, ifp->ifindex);
int err = 0;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0) {
int save_errno = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
- zlog_ferr(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
safe_strerror(save_errno));
exit(1);
}
if ((ret = ioctl(sock, request, buffer)) < 0)
err = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
close(sock);
if (ret < 0) {
int err = 0;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
sock = vrf_socket(AF_INET, SOCK_DGRAM, 0, vrf_id, NULL);
if (sock < 0) {
int save_errno = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
- zlog_ferr(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
safe_strerror(save_errno));
exit(1);
}
if (ret < 0)
err = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
close(sock);
if (ret < 0) {
int err = 0;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
sock = socket(AF_INET6, SOCK_DGRAM, 0);
if (sock < 0) {
int save_errno = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_SOCKET,
"Cannot create IPv6 datagram socket: %s",
safe_strerror(save_errno));
exit(1);
if ((ret = ioctl(sock, request, buffer)) < 0)
err = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
close(sock);
if (ret < 0) {
ret = vrf_if_ioctl(SIOCGIFFLAGS, (caddr_t)&ifreq, ifp->vrf_id);
if (ret < 0) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_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)
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"if_ioctl(SIOCGIFMEDIA) failed: %s",
safe_strerror(errno));
else if (ifmr.ifm_status & IFM_AVALID) /* Link state is valid */
int err;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0) {
int save_errno = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
- zlog_ferr(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_SOCKET, "Cannot create UDP socket: %s",
safe_strerror(save_errno));
exit(1);
}
err = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
close(sock);
int err;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
sock = socket(AF_INET6, SOCK_DGRAM, 0);
if (sock < 0) {
int save_errno = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_SOCKET,
"Cannot create IPv6 datagram socket: %s",
safe_strerror(save_errno));
exit(1);
err = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
close(sock);
FILE *fp;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
safe_strerror(errno));
fp = fopen(proc_ipv4_forwarding, "w");
if (fp == NULL) {
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"Can't lower privileges, %s",
safe_strerror(errno));
return -1;
fclose(fp);
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
safe_strerror(errno));
return ipforward();
FILE *fp;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
safe_strerror(errno));
fp = fopen(proc_ipv4_forwarding, "w");
if (fp == NULL) {
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"Can't lower privileges, %s",
safe_strerror(errno));
return -1;
fclose(fp);
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
safe_strerror(errno));
return ipforward();
FILE *fp;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
safe_strerror(errno));
fp = fopen(proc_ipv6_forwarding, "w");
if (fp == NULL) {
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"Can't lower privileges, %s",
safe_strerror(errno));
return -1;
fclose(fp);
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
safe_strerror(errno));
return ipforward_ipv6();
FILE *fp;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges, %s",
safe_strerror(errno));
fp = fopen(proc_ipv6_forwarding, "w");
if (fp == NULL) {
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"Can't lower privileges, %s",
safe_strerror(errno));
return -1;
fclose(fp);
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges, %s",
safe_strerror(errno));
return ipforward_ipv6();
else if (cmd == ND_GET)
snprintf(nd_buf, ND_BUFFER_SIZE, "%s", parameter);
else {
- zlog_ferr(LIB_ERR_SYSTEM_CALL,
+ flog_err(LIB_ERR_SYSTEM_CALL,
"internal error - inappropriate command given to "
"solaris_nd()%s:%d",
__FILE__, __LINE__);
strioctl.ic_dp = nd_buf;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"solaris_nd: Can't raise privileges");
if ((fd = open(device, O_RDWR)) < 0) {
zlog_warn("failed to open device %s - %s", device,
safe_strerror(errno));
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"solaris_nd: Can't lower privileges");
return -1;
}
if (ioctl(fd, I_STR, &strioctl) < 0) {
int save_errno = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"solaris_nd: Can't lower privileges");
close(fd);
zlog_warn("ioctl I_STR failed on device %s - %s", device,
}
close(fd);
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"solaris_nd: Can't lower privileges");
if (cmd == ND_GET) {
len = sizeof ipforwarding;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
if (sysctl(mib, MIB_SIZ, NULL, NULL, &ipforwarding, len) < 0) {
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
zlog_warn("Can't set ipforwarding on");
return -1;
}
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
return ipforwarding;
}
len = sizeof ipforwarding;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
if (sysctl(mib, MIB_SIZ, NULL, NULL, &ipforwarding, len) < 0) {
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
zlog_warn("Can't set ipforwarding on");
return -1;
}
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
return ipforwarding;
}
len = sizeof ip6forwarding;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
if (sysctl(mib_ipv6, MIB_SIZ, &ip6forwarding, &len, 0, 0) < 0) {
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
zlog_warn("can't get ip6forwarding value");
return -1;
}
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
return ip6forwarding;
}
len = sizeof ip6forwarding;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
if (sysctl(mib_ipv6, MIB_SIZ, NULL, NULL, &ip6forwarding, len) < 0) {
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
zlog_warn("can't get ip6forwarding value");
return -1;
}
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
return ip6forwarding;
}
len = sizeof ip6forwarding;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
if (sysctl(mib_ipv6, MIB_SIZ, NULL, NULL, &ip6forwarding, len) < 0) {
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
zlog_warn("can't get ip6forwarding value");
return -1;
}
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
return ip6forwarding;
}
int sock;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"irdp_sock_init: could not raise privs, %s",
safe_strerror(errno));
save_errno = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"irdp_sock_init: could not lower privs, %s",
safe_strerror(errno));
src = ip->ip_src;
if (len != iplen) {
- zlog_ferr(ZEBRA_ERR_IRDP_LEN_MISMATCH,
+ flog_err(ZEBRA_ERR_IRDP_LEN_MISMATCH,
"IRDP: RX length doesnt match IP length");
return;
}
if (iplen < ICMP_MINLEN) {
- zlog_ferr(ZEBRA_ERR_IRDP_LEN_MISMATCH,
+ flog_err(ZEBRA_ERR_IRDP_LEN_MISMATCH,
"IRDP: RX ICMP packet too short from %s\n",
inet_ntoa(src));
return;
+
len of IP-header) 14+20 */
if (iplen > IRDP_RX_BUF - 34) {
- zlog_ferr(ZEBRA_ERR_IRDP_LEN_MISMATCH,
+ flog_err(ZEBRA_ERR_IRDP_LEN_MISMATCH,
"IRDP: RX ICMP packet too long from %s\n",
inet_ntoa(src));
return;
ret = getsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF, &oldsize, &oldlen);
if (ret < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"Can't get %s receive buffer size: %s", nl->name,
safe_strerror(errno));
return -1;
/* Try force option (linux >= 2.6.14) and fall back to normal set */
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"routing_socket: Can't raise privileges");
ret = setsockopt(nl->sock, SOL_SOCKET, SO_RCVBUFFORCE, &nl_rcvbufsize,
sizeof(nl_rcvbufsize));
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"routing_socket: Can't lower privileges");
if (ret < 0)
ret = setsockopt(nl->sock, SOL_SOCKET, SO_RCVBUF,
&nl_rcvbufsize, sizeof(nl_rcvbufsize));
if (ret < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"Can't get %s receive buffer size: %s", nl->name,
safe_strerror(errno));
return -1;
int save_errno;
if (zserv_privs.change(ZPRIVS_RAISE)) {
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
return -1;
}
sock = ns_socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE, ns_id);
if (sock < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "Can't open %s socket: %s", nl->name,
+ flog_err(LIB_ERR_SOCKET, "Can't open %s socket: %s", nl->name,
safe_strerror(errno));
return -1;
}
ret = bind(sock, (struct sockaddr *)&snl, sizeof snl);
save_errno = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
if (ret < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"Can't bind %s socket to group 0x%x: %s", nl->name,
snl.nl_groups, safe_strerror(save_errno));
close(sock);
namelen = sizeof snl;
ret = getsockname(sock, (struct sockaddr *)&snl, (socklen_t *)&namelen);
if (ret < 0 || namelen != sizeof snl) {
- zlog_ferr(LIB_ERR_SOCKET, "Can't get %s socket name: %s",
+ flog_err(LIB_ERR_SOCKET, "Can't get %s socket name: %s",
nl->name, safe_strerror(errno));
close(sock);
return -1;
* this message type or not ask for
* it to be sent up to us
*/
- zlog_ferr(ZEBRA_ERR_UNKNOWN_NLMSG,
+ flog_err(ZEBRA_ERR_UNKNOWN_NLMSG,
"Unknown netlink nlmsg_type %s(%d) vrf %u\n",
nl_msg_type_to_str(h->nlmsg_type), h->nlmsg_type,
ns_id);
continue;
if (errno == EWOULDBLOCK || errno == EAGAIN)
break;
- zlog_ferr(ZEBRA_ERR_RECVMSG_OVERRUN,
+ flog_err(ZEBRA_ERR_RECVMSG_OVERRUN,
"%s recvmsg overrun: %s", nl->name,
safe_strerror(errno));
/*
}
if (status == 0) {
- zlog_ferr(LIB_ERR_SOCKET, "%s EOF", nl->name);
+ flog_err(LIB_ERR_SOCKET, "%s EOF", nl->name);
return -1;
}
if (msg.msg_namelen != sizeof snl) {
- zlog_ferr(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
+ flog_err(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
"%s sender address length error: length %d",
nl->name, msg.msg_namelen);
return -1;
if (h->nlmsg_len
< NLMSG_LENGTH(sizeof(struct nlmsgerr))) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_NETLINK_LENGTH_ERROR,
"%s error: message truncated",
nl->name);
err->msg.nlmsg_seq,
err->msg.nlmsg_pid);
} else
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_UNEXPECTED_MESSAGE,
"%s error: %s, type=%s(%u), seq=%u, pid=%u",
nl->name,
/* After error care. */
if (msg.msg_flags & MSG_TRUNC) {
- zlog_ferr(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
+ flog_err(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
"%s error: message truncated", nl->name);
continue;
}
if (status) {
- zlog_ferr(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
+ flog_err(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
"%s error: data remnant size %d", nl->name,
status);
return -1;
/* Send message to netlink interface. */
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
status = sendmsg(nl->sock, &msg, 0);
save_errno = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND) {
zlog_debug("%s: >> netlink message dump [sent]", __func__);
}
if (status < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "netlink_talk sendmsg() error: %s",
+ flog_err(LIB_ERR_SOCKET, "netlink_talk sendmsg() error: %s",
safe_strerror(save_errno));
return -1;
}
/* Check netlink socket. */
if (nl->sock < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "%s socket isn't active.", nl->name);
+ flog_err(LIB_ERR_SOCKET, "%s socket isn't active.", nl->name);
return -1;
}
/* Raise capabilities and send message, then lower capabilities. */
if (zserv_privs.change(ZPRIVS_RAISE)) {
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
return -1;
}
save_errno = errno;
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
if (ret < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "%s sendto failed: %s", nl->name,
+ flog_err(LIB_ERR_SOCKET, "%s sendto failed: %s", nl->name,
safe_strerror(save_errno));
return -1;
}
/* Register kernel socket. */
if (fcntl(zns->netlink.sock, F_SETFL, O_NONBLOCK) < 0)
- zlog_ferr(LIB_ERR_SOCKET, "Can't set %s socket flags: %s",
+ flog_err(LIB_ERR_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)
/* paranoia: sanity check structure */
if (ifm->ifm_msglen < sizeof(struct if_msghdr)) {
- zlog_ferr(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
+ flog_err(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
"ifm_read: ifm->ifm_msglen %d too short\n",
ifm->ifm_msglen);
return -1;
static void routing_socket(struct zebra_ns *zns)
{
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"routing_socket: Can't raise privileges");
routing_sock =
if (routing_sock < 0) {
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"routing_socket: Can't lower privileges");
zlog_warn("Can't init kernel routing socket");
return;
zlog_warn ("Can't set O_NONBLOCK to routing socket");*/
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"routing_socket: Can't lower privileges");
/* kernel_read needs rewrite. */
ret = zclient_read_header(src, zclient->sock, &size, &marker, &version,
&vrf_id, &resp_cmd);
if (ret < 0 && errno != EAGAIN) {
- zlog_ferr(ZEBRA_ERR_LM_RESPONSE,
+ flog_err(ZEBRA_ERR_LM_RESPONSE,
"Error reading Label Manager response: %s",
strerror(errno));
return -1;
/* lookup the client to relay the msg to */
zserv = zserv_find_client(proto, instance);
if (!zserv) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_LM_NO_SUCH_CLIENT,
"Error relaying LM response: can't find client %s, instance %u",
proto_str, instance);
/* send response back */
ret = writen(zserv->sock, dst->data, stream_get_endp(dst));
if (ret <= 0) {
- zlog_ferr(ZEBRA_ERR_LM_RELAY_FAILED,
+ flog_err(ZEBRA_ERR_LM_RELAY_FAILED,
"Error relaying LM response to %s instance %u: %s",
proto_str, instance, strerror(errno));
return -1;
unsigned short instance;
if (zclient->sock < 0) {
- zlog_ferr(ZEBRA_ERR_LM_NO_SOCKET,
+ flog_err(ZEBRA_ERR_LM_NO_SOCKET,
"Unable to relay LM request: no socket");
reply_error(cmd, zserv, vrf_id);
return -1;
/* check & set client instance if unset */
if (zserv->instance && zserv->instance != instance) {
- zlog_ferr(ZEBRA_ERR_LM_BAD_INSTANCE,
+ flog_err(ZEBRA_ERR_LM_BAD_INSTANCE,
"Client instance(%u) != msg instance(%u)",
zserv->instance, instance);
return -1;
/* Send request to external label manager */
ret = writen(zclient->sock, dst->data, stream_get_endp(dst));
if (ret <= 0) {
- zlog_ferr(ZEBRA_ERR_LM_RELAY_FAILED,
+ flog_err(ZEBRA_ERR_LM_RELAY_FAILED,
"Error relaying LM request from %s instance %u: %s",
proto_str, instance, strerror(errno));
reply_error(cmd, zserv, vrf_id);
return 0;
if (zclient_socket_connect(zclient) < 0) {
- zlog_ferr(ZEBRA_ERR_LM_CLIENT_CONNECTION_FAILED,
+ flog_err(ZEBRA_ERR_LM_CLIENT_CONNECTION_FAILED,
"Error connecting synchronous zclient!");
thread_add_timer(zebrad.master, lm_zclient_connect, zclient,
CONNECTION_DELAY, &zclient->t_connect);
->end
+ 1;
if (lmc->start > MPLS_LABEL_UNRESERVED_MAX - size + 1) {
- zlog_ferr(ZEBRA_ERR_LM_EXHAUSTED_LABELS,
+ flog_err(ZEBRA_ERR_LM_EXHAUSTED_LABELS,
"Reached max labels. Start: %u, size: %u", lmc->start,
size);
XFREE(MTYPE_LM_CHUNK, lmc);
if (lmc->end != end)
continue;
if (lmc->proto != proto || lmc->instance != instance) {
- zlog_ferr(ZEBRA_ERR_LM_DAEMON_MISMATCH,
+ flog_err(ZEBRA_ERR_LM_DAEMON_MISMATCH,
"%s: Daemon mismatch!!", __func__);
continue;
}
break;
}
if (ret != 0)
- zlog_ferr(ZEBRA_ERR_LM_UNRELEASED_CHUNK,
+ flog_err(ZEBRA_ERR_LM_UNRELEASED_CHUNK,
"%s: Label chunk not released!!", __func__);
return ret;
multipath_num = atoi(optarg);
if (multipath_num > MULTIPATH_NUM
|| multipath_num <= 0) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_BAD_MULTIPATH_NUM,
"Multipath Number specified must be less than %d and greater than 0",
MULTIPATH_NUM);
*/
case ZEBRA_ERR_RTEXIST:
if (cmd != RTM_ADD)
- zlog_ferr(
+ flog_err(
LIB_ERR_SYSTEM_CALL,
"%s: rtm_write() returned %d for command %d",
__func__, error, cmd);
case ZEBRA_ERR_RTNOEXIST:
case ZEBRA_ERR_RTUNREACH:
default:
- zlog_ferr(
+ flog_err(
LIB_ERR_SYSTEM_CALL,
"%s: %s: rtm_write() unexpectedly returned %d for command %s",
__func__,
}
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
if (old)
route |= kernel_rtm(RTM_DELETE, p, old);
route |= kernel_rtm(RTM_ADD, p, new);
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
if (new) {
kernel_route_rib_pass_fail(
ret = sendmsg(sock, &msg, 0);
if (ret < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"%s(%u): Tx RA failed, socket %u error %d (%s)",
ifp->name, ifp->ifindex, sock, errno,
safe_strerror(errno));
struct icmp6_filter filter;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"rtadv_make_socket: could not raise privs, %s",
safe_strerror(errno));
sock = ns_socket(AF_INET6, SOCK_RAW, IPPROTO_ICMPV6, ns_id);
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES,
+ flog_err(LIB_ERR_PRIVILEGES,
"rtadv_make_socket: could not lower privs, %s",
safe_strerror(errno));
enum dp_req_result kernel_add_pbr_rule(struct zebra_pbr_rule *rule)
{
- zlog_ferr(LIB_ERR_UNAVAILABLE, "%s not Implemented for this platform",
+ flog_err(LIB_ERR_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)
{
- zlog_ferr(LIB_ERR_UNAVAILABLE, "%s not Implemented for this platform",
+ flog_err(LIB_ERR_UNAVAILABLE, "%s not Implemented for this platform",
__PRETTY_FUNCTION__);
return DP_REQUEST_FAILURE;
}
#endif /* SUNOS_5 */
tmc->start = start;
if (RT_TABLE_ID_UNRESERVED_MAX - size + 1 < start) {
- zlog_ferr(ZEBRA_ERR_TM_EXHAUSTED_IDS,
+ flog_err(ZEBRA_ERR_TM_EXHAUSTED_IDS,
"Reached max table id. Start/Size %u/%u", start,
size);
XFREE(MTYPE_TM_CHUNK, tmc);
if (tmc->end != end)
continue;
if (tmc->proto != proto || tmc->instance != instance) {
- zlog_ferr(ZEBRA_ERR_TM_DAEMON_MISMATCH,
+ flog_err(ZEBRA_ERR_TM_DAEMON_MISMATCH,
"%s: Daemon mismatch!!", __func__);
continue;
}
break;
}
if (ret != 0)
- zlog_ferr(ZEBRA_ERR_TM_UNRELEASED_CHUNK,
+ flog_err(ZEBRA_ERR_TM_UNRELEASED_CHUNK,
"%s: Table chunk not released!!", __func__);
return ret;
STREAM_GET(&p.u.prefix6, s, IPV6_MAX_BYTELEN);
l += IPV6_MAX_BYTELEN;
} else {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_UNKNOWN_FAMILY,
"rnh_register: Received unknown family type %d\n",
p.family);
STREAM_GET(&p.u.prefix6, s, IPV6_MAX_BYTELEN);
l += IPV6_MAX_BYTELEN;
} else {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_UNKNOWN_FAMILY,
"rnh_register: Received unknown family type %d\n",
p.family);
* registration
*/
if (hdr->length < ZEBRA_MIN_FEC_LENGTH) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_IRDP_LEN_MISMATCH,
"fec_register: Received a fec register of hdr->length %d, it is of insufficient size to properly decode",
hdr->length);
memset(&p, 0, sizeof(p));
STREAM_GETW(s, p.family);
if (p.family != AF_INET && p.family != AF_INET6) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_UNKNOWN_FAMILY,
"fec_register: Received unknown family type %d\n",
p.family);
* fec unregistration
*/
if (hdr->length < ZEBRA_MIN_FEC_LENGTH) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_IRDP_LEN_MISMATCH,
"fec_unregister: Received a fec unregister of hdr->length %d, it is of insufficient size to properly decode",
hdr->length);
memset(&p, 0, sizeof(p));
STREAM_GETW(s, p.family);
if (p.family != AF_INET && p.family != AF_INET6) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_UNKNOWN_FAMILY,
"fec_unregister: Received unknown family type %d\n",
p.family);
/* accept only dynamic routing protocols */
if ((proto >= ZEBRA_ROUTE_MAX) || (proto <= ZEBRA_ROUTE_STATIC)) {
- zlog_ferr(ZEBRA_ERR_TM_WRONG_PROTO,
+ flog_err(ZEBRA_ERR_TM_WRONG_PROTO,
"client %d has wrong protocol %s", client->sock,
zebra_route_string(proto));
zsend_table_manager_connect_response(client, vrf_id, 1);
/* accept only dynamic routing protocols */
if ((proto >= ZEBRA_ROUTE_MAX) || (proto <= ZEBRA_ROUTE_STATIC)) {
- zlog_ferr(ZEBRA_ERR_TM_WRONG_PROTO,
+ flog_err(ZEBRA_ERR_TM_WRONG_PROTO,
"client %d has wrong protocol %s", client->sock,
zebra_route_string(proto));
zsend_label_manager_connect_response(client, vrf_id, 1);
uint8_t proto, unsigned int instance)
{
if (proto != client->proto) {
- zlog_ferr(ZEBRA_ERR_PROTO_OR_INSTANCE_MISMATCH,
+ flog_err(ZEBRA_ERR_PROTO_OR_INSTANCE_MISMATCH,
"%s: msg vs client proto mismatch, client=%u msg=%u",
op, client->proto, proto);
/* TODO: fail when BGP sets proto and instance */
}
if (instance != client->instance) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_PROTO_OR_INSTANCE_MISMATCH,
"%s: msg vs client instance mismatch, client=%u msg=%u",
op, client->instance, instance);
lmc = assign_label_chunk(client->proto, client->instance, keep, size);
if (!lmc)
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_LM_CANNOT_ASSIGN_CHUNK,
"Unable to assign Label Chunk of size %u to %s instance %u",
size, zebra_route_string(client->proto),
else {
/* Sanity: don't allow 'unidentified' requests */
if (!client->proto) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_LM_ALIENS,
"Got label request from an unidentified client");
return;
tmc = assign_table_chunk(client->proto, client->instance, size);
if (!tmc)
- zlog_ferr(ZEBRA_ERR_TM_CANNOT_ASSIGN_CHUNK,
+ flog_err(ZEBRA_ERR_TM_CANNOT_ASSIGN_CHUNK,
"%s: Unable to assign Table Chunk of size %u",
__func__, size);
else
else {
/* Sanity: don't allow 'unidentified' requests */
if (!client->proto) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_TM_ALIENS,
"Got table request from an unidentified client");
return;
if (!strcmp("netlink", format)) {
if (!have_netlink) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_NETLINK_NOT_AVAILABLE,
"FPM netlink message format is not available");
return;
if (!strcmp("protobuf", format)) {
if (!have_protobuf) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_PROTOBUF_NOT_AVAILABLE,
"FPM protobuf message format is not available");
return;
UNSET_FLAG(lsp->flags, LSP_FLAG_CHANGED);
switch (kernel_add_lsp(lsp)) {
case DP_REQUEST_QUEUED:
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_DP_INVALID_RC,
"No current DataPlane interfaces can return this, please fix");
break;
switch (kernel_del_lsp(lsp)) {
case DP_REQUEST_QUEUED:
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_DP_INVALID_RC,
"No current DataPlane interfaces can return this, please fix");
break;
switch (kernel_upd_lsp(lsp)) {
case DP_REQUEST_QUEUED:
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_DP_INVALID_RC,
"No current DataPlane interfaces can return this, please fix");
break;
return 0;
if (zebrad.lsp_process_q == NULL) {
- zlog_ferr(ZEBRA_ERR_WQ_NONEXISTENT,
+ flog_err(ZEBRA_ERR_WQ_NONEXISTENT,
"%s: work_queue does not exist!", __func__);
return -1;
}
{
zebra->lsp_process_q = work_queue_new(zebra->master, "LSP processing");
if (!zebra->lsp_process_q) {
- zlog_ferr(ZEBRA_ERR_WQ_NONEXISTENT,
+ flog_err(ZEBRA_ERR_WQ_NONEXISTENT,
"%s: could not initialise work queue!", __func__);
return -1;
}
fec = fec_add(table, p, MPLS_INVALID_LABEL, 0, label_index);
if (!fec) {
prefix2str(p, buf, BUFSIZ);
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_FEC_ADD_FAILED,
"Failed to add FEC %s upon register, client %s",
buf, zebra_route_string(client->proto));
fec = fec_find(table, p);
if (!fec) {
prefix2str(p, buf, BUFSIZ);
- zlog_ferr(ZEBRA_ERR_FEC_RM_FAILED,
+ flog_err(ZEBRA_ERR_FEC_RM_FAILED,
"Failed to find FEC %s upon unregister, client %s",
buf, zebra_route_string(client->proto));
return -1;
MPLS_INVALID_LABEL_INDEX);
if (!fec) {
prefix2str(p, buf, BUFSIZ);
- zlog_ferr(ZEBRA_ERR_FEC_ADD_FAILED,
+ flog_err(ZEBRA_ERR_FEC_ADD_FAILED,
"Failed to add FEC %s upon config", buf);
return -1;
}
fec = fec_find(table, p);
if (!fec) {
prefix2str(p, buf, BUFSIZ);
- zlog_ferr(ZEBRA_ERR_FEC_RM_FAILED,
+ flog_err(ZEBRA_ERR_FEC_RM_FAILED,
"Failed to find FEC %s upon delete", buf);
return -1;
}
}
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
ret = writev(kr_state.fd, iov, iovcnt);
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
if (ret == -1)
- zlog_ferr(LIB_ERR_SOCKET, "%s: %s", __func__,
+ flog_err(LIB_ERR_SOCKET, "%s: %s", __func__,
safe_strerror(errno));
return ret;
}
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
ret = writev(kr_state.fd, iov, iovcnt);
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
if (ret == -1)
- zlog_ferr(LIB_ERR_SOCKET, "%s: %s", __func__,
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL, "ioctl SIOCSETMPWCFG: %s",
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_SYSTEM_CALL, "ioctl SIOCSETMPWCFG: %s",
+ flog_err(LIB_ERR_SYSTEM_CALL, "ioctl SIOCSETMPWCFG: %s",
safe_strerror(errno));
return -1;
}
ret = sendto(sock, (const void *)nlh, (size_t)nlh->nlmsg_len, 0,
(struct sockaddr *)&snl, (socklen_t)sizeof(snl));
if (ret < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "netlink( %u) sendmsg() error: %s",
+ flog_err(LIB_ERR_SOCKET, "netlink( %u) sendmsg() error: %s",
sock, safe_strerror(errno));
return -1;
}
};
ret = recvmsg(sock, &msg, 0);
if (ret < 0) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"netlink recvmsg: error %d (errno %u)", ret, errno);
return -1;
}
if (msg.msg_flags & MSG_TRUNC) {
- zlog_ferr(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
+ flog_err(ZEBRA_ERR_NETLINK_LENGTH_ERROR,
"netlink recvmsg : error message truncated");
return -1;
}
/* nlh already points to buf */
if (nlh->nlmsg_seq != seq) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_NETLINK_BAD_SEQUENCE,
"netlink recvmsg: bad sequence number %x (expected %x)",
seq, nlh->nlmsg_seq);
/* netlink socket */
sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock < 0) {
- zlog_ferr(LIB_ERR_SOCKET, "netlink( %u) socket() error: %s",
+ flog_err(LIB_ERR_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) {
- zlog_ferr(LIB_ERR_SOCKET,
+ flog_err(LIB_ERR_SOCKET,
"netlink( %u) socket() bind error: %s", sock,
safe_strerror(errno));
close(sock);
if (ret <= 0) {
if (errno != EEXIST && ret != 0) {
- zlog_ferr(
+ flog_err(
LIB_ERR_SOCKET,
"netlink( %u) recvfrom() error 2 when reading: %s",
fd, safe_strerror(errno));
return;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
ns_id = zebra_ns_id_get(netnspath);
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
if (ns_id == NS_UNKNOWN)
return;
ns_id_external = ns_map_nsid_with_external(ns_id, true);
return;
}
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
ret = vrf_netns_handler_create(NULL, vrf, netnspath,
ns_id_external, ns_id);
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
if (ret != CMD_SUCCESS) {
zlog_warn("NS notify : failed to create NS %s", netnspath);
ns_map_nsid_with_external(ns_id, false);
if (--zns_info->retries == 0)
stop_retry = 1;
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
err = ns_switch_to_netns(netnspath);
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
if (err < 0)
return zebra_ns_continue_read(zns_info, stop_retry);
/* go back to default ns */
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
err = ns_switchback_to_initial();
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
if (err < 0)
return zebra_ns_continue_read(zns_info, stop_retry);
dzns = zebra_ns_alloc();
if (zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
ns_id = zebra_ns_id_get_default();
if (zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
ns_id_external = ns_map_nsid_with_external(ns_id, true);
ns_init_management(ns_id_external, ns_id);
dest_str, src_str);
if (str2prefix(dest_str, &dest_prefix) == 0) {
- zlog_ferr(ZEBRA_ERR_PREFIX_PARSE_ERROR,
+ flog_err(ZEBRA_ERR_PREFIX_PARSE_ERROR,
"%s: Peer addr %s not found", __func__, dest_str);
return -1;
}
memset(&src_prefix, 0, sizeof(struct prefix));
if (strcmp(ZEBRA_PTM_INVALID_SRC_IP, src_str)) {
if (str2prefix(src_str, &src_prefix) == 0) {
- zlog_ferr(ZEBRA_ERR_PREFIX_PARSE_ERROR,
+ flog_err(ZEBRA_ERR_PREFIX_PARSE_ERROR,
"%s: Local addr %s not found", __func__,
src_str);
return -1;
hook_call(rib_update, rn, "installing in kernel");
switch (kernel_route_rib(rn, p, src_p, old, re)) {
case DP_REQUEST_QUEUED:
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_DP_INVALID_RC,
"No current known DataPlane interfaces can return this, please fix");
break;
case DP_REQUEST_FAILURE:
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_DP_INSTALL_FAIL,
"No current known Rib Install Failure cases, please fix");
break;
hook_call(rib_update, rn, "uninstalling from kernel");
switch (kernel_route_rib(rn, p, src_p, re, NULL)) {
case DP_REQUEST_QUEUED:
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_DP_INVALID_RC,
"No current known DataPlane interfaces can return this, please fix");
break;
case DP_REQUEST_FAILURE:
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_DP_INSTALL_FAIL,
"No current known RIB Install Failure cases, please fix");
break;
}
if (zebrad.ribq == NULL) {
- zlog_ferr(ZEBRA_ERR_WQ_NONEXISTENT,
+ flog_err(ZEBRA_ERR_WQ_NONEXISTENT,
"%s: work_queue does not exist!", __func__);
return;
}
if (!(zebra->ribq =
work_queue_new(zebra->master, "route_node processing"))) {
- zlog_ferr(ZEBRA_ERR_WQ_NONEXISTENT,
+ flog_err(ZEBRA_ERR_WQ_NONEXISTENT,
"%s: could not initialise work queue!", __func__);
return;
}
zebra->ribq->spec.hold = ZEBRA_RIB_PROCESS_HOLD_TIME;
if (!(zebra->mq = meta_queue_new())) {
- zlog_ferr(ZEBRA_ERR_WQ_NONEXISTENT,
+ flog_err(ZEBRA_ERR_WQ_NONEXISTENT,
"%s: could not initialise meta queue!", __func__);
return;
}
/* Lookup table. */
table = zebra_vrf_table(AFI_IP, SAFI_UNICAST, vrf_id);
if (!table) {
- zlog_ferr(ZEBRA_ERR_TABLE_LOOKUP_FAILED,
+ flog_err(ZEBRA_ERR_TABLE_LOOKUP_FAILED,
"%s:%u zebra_vrf_table() returned NULL", __func__,
vrf_id);
return;
rib_dest_t *dest;
if (NULL == (table = zebra_vrf_table(AFI_IP, SAFI_UNICAST, vrf_id))) {
- zlog_ferr(ZEBRA_ERR_TABLE_LOOKUP_FAILED,
+ flog_err(ZEBRA_ERR_TABLE_LOOKUP_FAILED,
"%s:%u zebra_vrf_table() returned NULL", __func__,
vrf_id);
return;
stream_put(s, &rn->p.u.prefix6, IPV6_MAX_BYTELEN);
break;
default:
- zlog_ferr(ZEBRA_ERR_RNH_UNKNOWN_FAMILY,
+ flog_err(ZEBRA_ERR_RNH_UNKNOWN_FAMILY,
"%s: Unknown family (%d) notification attempted\n",
__FUNCTION__, rn->p.family);
break;
if (!mac) {
mac = zvni_mac_add(zvni, macaddr);
if (!mac) {
- zlog_ferr(ZEBRA_ERR_MAC_ADD_FAILED,
+ flog_err(ZEBRA_ERR_MAC_ADD_FAILED,
"Failed to add MAC %s intf %s(%u) VID %u",
prefix_mac2str(macaddr, buf, sizeof(buf)),
ifp->name, ifp->ifindex, vxl->access_vlan);
if (!n) {
n = zvni_neigh_add(zvni, ip, macaddr);
if (!n) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_MAC_ADD_FAILED,
"Failed to add neighbor %s MAC %s intf %s(%u) -> VNI %u",
ipaddr2str(ip, buf2, sizeof(buf2)),
/* New neighbor - create */
n = zvni_neigh_add(zvni, ip, macaddr);
if (!n) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_MAC_ADD_FAILED,
"Failed to add neighbor %s MAC %s intf %s(%u) -> VNI %u",
ipaddr2str(ip, buf2, sizeof(buf2)),
/* Delete the hash entry. */
if (zvni_del(zvni)) {
- zlog_ferr(ZEBRA_ERR_VNI_DEL_FAILED,
+ flog_err(ZEBRA_ERR_VNI_DEL_FAILED,
"Failed to del VNI hash %p, VNI %u", zvni,
zvni->vni);
return -1;
zvtep = zvni_vtep_find(zvni, &vtep_ip);
if (!zvtep) {
if (zvni_vtep_add(zvni, &vtep_ip) == NULL) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_VTEP_ADD_FAILED,
"Failed to add remote VTEP, VNI %u zvni %p",
vni, zvni);
if (!mac) {
mac = zvni_mac_add(zvni, macaddr);
if (!mac) {
- zlog_ferr(ZEBRA_ERR_MAC_ADD_FAILED,
+ flog_err(ZEBRA_ERR_MAC_ADD_FAILED,
"Failed to add MAC %s intf %s(%u) VID %u",
prefix_mac2str(macaddr, buf, sizeof(buf)),
ifp->name, ifp->ifindex, vid);
/* Locate VNI hash entry - expected to exist. */
zvni = zvni_lookup(vni);
if (!zvni) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_VTEP_ADD_FAILED,
"Failed to locate VNI hash upon remote VTEP ADD, VNI %u",
vni);
ifp = zvni->vxlan_if;
if (!ifp) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_VTEP_ADD_FAILED,
"VNI %u hash %p doesn't have intf upon remote VTEP ADD",
zvni->vni, zvni);
continue;
if (zvni_vtep_add(zvni, &vtep_ip) == NULL) {
- zlog_ferr(ZEBRA_ERR_VTEP_ADD_FAILED,
+ flog_err(ZEBRA_ERR_VTEP_ADD_FAILED,
"Failed to add remote VTEP, VNI %u zvni %p",
vni, zvni);
continue;
/* Delete the hash entry. */
if (zvni_del(zvni)) {
- zlog_ferr(ZEBRA_ERR_VNI_DEL_FAILED,
+ flog_err(ZEBRA_ERR_VNI_DEL_FAILED,
"Failed to del VNI hash %p, IF %s(%u) VNI %u",
zvni, ifp->name, ifp->ifindex, zvni->vni);
return -1;
if (!zvni) {
zvni = zvni_add(vni);
if (!zvni) {
- zlog_ferr(
+ flog_err(
ZEBRA_ERR_VNI_ADD_FAILED,
"Failed to add VNI hash, IF %s(%u) VNI %u",
ifp->name, ifp->ifindex, vni);
zserv_privs.change(ZPRIVS_LOWER);
if (sa.ss_family != AF_UNIX && zserv_privs.change(ZPRIVS_RAISE))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't raise privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't raise privileges");
ret = bind(zebrad.sock, (struct sockaddr *)&sa, sa_len);
if (ret < 0) {
return;
}
if (sa.ss_family != AF_UNIX && zserv_privs.change(ZPRIVS_LOWER))
- zlog_ferr(LIB_ERR_PRIVILEGES, "Can't lower privileges");
+ flog_err(LIB_ERR_PRIVILEGES, "Can't lower privileges");
ret = listen(zebrad.sock, 5);
if (ret < 0) {
projects / mirror / frr.git / commitdiff