void
send_packet(struct interface *ifp,
struct stream *s, u_int32_t dst, struct prefix *p, u_int32_t ttl)
{
static struct sockaddr_in sockdst = { AF_INET };
struct ip *ip;
struct icmphdr *icmp;
struct msghdr *msg;
struct cmsghdr *cmsg;
struct iovec iovector;
char msgbuf[256];
char buf[256];
struct in_pktinfo *pktinfo;
u_long src;
int on;
if (!(ifp->flags & IFF_UP))
return;
if (p)
src = ntohl(p->u.prefix4.s_addr);
else
src = 0; /* Is filled in */
ip = (struct ip *)buf;
ip->ip_hl = sizeof(struct ip) >> 2;
ip->ip_v = IPVERSION;
ip->ip_tos = 0xC0;
ip->ip_off = 0L;
ip->ip_p = 1; /* IP_ICMP */
ip->ip_ttl = ttl;
ip->ip_src.s_addr = src;
ip->ip_dst.s_addr = dst;
icmp = (struct icmphdr *)(buf + sizeof(struct ip));
/* Merge IP header with icmp packet */
assert(stream_get_endp(s) < (sizeof(buf) - sizeof(struct ip)));
stream_get(icmp, s, stream_get_endp(s));
/* icmp->checksum is already calculated */
ip->ip_len = sizeof(struct ip) + stream_get_endp(s);
on = 1;
if (setsockopt(irdp_sock, IPPROTO_IP, IP_HDRINCL,
(char *)&on, sizeof(on)) < 0)
zlog_warn("sendto %s", safe_strerror(errno));
if (dst == INADDR_BROADCAST) {
on = 1;
if (setsockopt(irdp_sock, SOL_SOCKET, SO_BROADCAST,
(char *)&on, sizeof(on)) < 0)
zlog_warn("sendto %s", safe_strerror(errno));
}
if (dst != INADDR_BROADCAST) {
on = 0;
if (setsockopt(irdp_sock, IPPROTO_IP, IP_MULTICAST_LOOP,
(char *)&on, sizeof(on)) < 0)
zlog_warn("sendto %s", safe_strerror(errno));
}
memset(&sockdst, 0, sizeof(sockdst));
sockdst.sin_family = AF_INET;
sockdst.sin_addr.s_addr = dst;
cmsg = (struct cmsghdr *)(msgbuf + sizeof(struct msghdr));
cmsg->cmsg_len = sizeof(struct cmsghdr) + sizeof(struct in_pktinfo);
cmsg->cmsg_level = SOL_IP;
cmsg->cmsg_type = IP_PKTINFO;
pktinfo = (struct in_pktinfo *)CMSG_DATA(cmsg);
pktinfo->ipi_ifindex = ifp->ifindex;
pktinfo->ipi_spec_dst.s_addr = src;
pktinfo->ipi_addr.s_addr = src;
iovector.iov_base = (void *)buf;
iovector.iov_len = ip->ip_len;
msg = (struct msghdr *)msgbuf;
msg->msg_name = &sockdst;
msg->msg_namelen = sizeof(sockdst);
msg->msg_iov = &iovector;
msg->msg_iovlen = 1;
msg->msg_control = cmsg;
msg->msg_controllen = cmsg->cmsg_len;
sockopt_iphdrincl_swab_htosys(ip);
if (sendmsg(irdp_sock, msg, 0) < 0) {
zlog_warn("sendto %s", safe_strerror(errno));
}
/* printf("TX on %s idx %d\n", ifp->name, ifp->ifindex); */
}
int
shim_sisis_read(struct thread * thread)
{
struct sisis_listener *listener;
int sisis_sock;
uint16_t length, checksum;
int already;
u_int ifindex;
struct shim_interface * si;
struct in6_addr src;
char src_buf[INET6_ADDRSTRLEN];
struct in6_addr dst;
char dst_buf[INET6_ADDRSTRLEN];
zlog_notice("Reading packet from SISIS connection!");
/* first of all get listener pointer. */
listener = THREAD_ARG (thread);
sisis_sock = THREAD_FD (thread);
stream_reset(listener->ibuf);
if ((already = stream_get_endp(listener->ibuf)) < SVZ_OUT_HEADER_SIZE)
{
ssize_t nbytes;
if (((nbytes = stream_read_try (listener->ibuf, sisis_sock, SVZ_OUT_HEADER_SIZE-already)) == 0) || (nbytes == -1))
{
return -1;
}
if(nbytes != (SVZ_OUT_HEADER_SIZE - already))
{
listener->read_thread = thread_add_read (master, shim_sisis_read, listener, sisis_sock);
return 0;
}
already = SVZ_OUT_HEADER_SIZE;
}
stream_set_getp(listener->ibuf, 0);
length = stream_getw(listener->ibuf);
checksum = stream_getw(listener->ibuf);
if(length > STREAM_SIZE(listener->ibuf))
{
struct stream * ns;
zlog_warn("message size exceeds buffer size");
ns = stream_new(length);
stream_copy(ns, listener->ibuf);
stream_free(listener->ibuf);
listener->ibuf = ns;
}
if(already < length)
{
ssize_t nbytes;
if(((nbytes = stream_read_try(listener->ibuf, sisis_sock, length-already)) == 0) || nbytes == -1)
{
return -1;
}
if(nbytes != (length-already))
{
listener->read_thread = thread_add_read (master, shim_sisis_read, listener, sisis_sock);
return 0;
}
}
unsigned int num_of_addrs = number_of_sisis_addrs_for_process_type(SISIS_PTYPE_RIBCOMP_OSPF6);
unsigned int num_of_listeners = number_of_listeners();
zlog_notice("Number of addr: %d", num_of_addrs);
zlog_notice("Number of listeners: %d", num_of_listeners);
pthread_mutex_lock(&bmap_mutex);
struct bmap * bmap = bmap_set(checksum);
// if we added initially
// set timer at which to recycle bmap
// if there are no more processes sending data
if(bmap->count == 0)
{
uint16_t * chcksum_ptr = malloc(sizeof(uint16_t));
*chcksum_ptr = checksum;
listener->bmap_thread = thread_add_timer_msec (master, svz_sisis_clean_bmap, chcksum_ptr, 100);
}
bmap->count++;
zlog_notice("# of streams %d for checksum %d with length %d", bmap->count, checksum, length);
float received_ratio = (float)bmap->count/(float)num_of_addrs;
stream_putw(listener->chksum_stream, checksum);
if((received_ratio > 1.0/2.0) && !bmap->sent)
{
if(are_checksums_same())
{
zlog_notice("Checksums are all the same");
if(primary_listener == NULL)
primary_listener = listener;
reset_checksum_streams();
svz_send(listener->ibuf);
bmap->sent = 1;
}
else
{
zlog_notice("Checksums are not all the same");
stream_fifo_push(listener->dif, listener->ibuf);
listener->dif_size++;
}
}
else if(!bmap->sent)
{
zlog_notice("Not enough processes have sent their data; buffering...");
}
else
{
zlog_notice("Data has already been sent...");
}
if((bmap->count == num_of_addrs) && (bmap->sent))
{
zlog_notice("Bmap no longer needed, freeing...");
bmap->count = 0;
bmap->sent = 0;
clear_checksum_streams(checksum);
bmap_unset(checksum);
}
pthread_mutex_unlock(&bmap_mutex);
if (sisis_sock < 0)
/* Connection was closed during packet processing. */
return -1;
/* Register read thread. */
// stream_reset(listener->ibuf);
/* prepare for next packet. */
listener->read_thread = thread_add_read (master, shim_sisis_read, listener, sisis_sock);
return 0;
}
void
ospf_zebra_add (struct prefix_ipv4 *p, struct ospf_route *or)
{
u_char message;
u_char distance;
u_char flags;
int psize;
struct stream *s;
struct ospf_path *path;
struct listnode *node;
if (zclient->redist[ZEBRA_ROUTE_OSPF])
{
message = 0;
flags = 0;
/* OSPF pass nexthop and metric */
SET_FLAG (message, ZAPI_MESSAGE_NEXTHOP);
SET_FLAG (message, ZAPI_MESSAGE_METRIC);
/* Distance value. */
distance = ospf_distance_apply (p, or);
if (distance)
SET_FLAG (message, ZAPI_MESSAGE_DISTANCE);
/* Make packet. */
s = zclient->obuf;
stream_reset (s);
/* Put command, type, flags, message. */
zclient_create_header (s, ZEBRA_IPV4_ROUTE_ADD);
stream_putc (s, ZEBRA_ROUTE_OSPF);
stream_putc (s, flags);
stream_putc (s, message);
stream_putw (s, SAFI_UNICAST);
/* Put prefix information. */
psize = PSIZE (p->prefixlen);
stream_putc (s, p->prefixlen);
stream_write (s, (u_char *) & p->prefix, psize);
/* Nexthop count. */
stream_putc (s, or->paths->count);
/* Nexthop, ifindex, distance and metric information. */
for (ALL_LIST_ELEMENTS_RO (or->paths, node, path))
{
if (path->nexthop.s_addr != INADDR_ANY &&
path->ifindex != 0)
{
stream_putc (s, ZEBRA_NEXTHOP_IPV4_IFINDEX);
stream_put_in_addr (s, &path->nexthop);
stream_putl (s, path->ifindex);
}
else if (path->nexthop.s_addr != INADDR_ANY)
{
stream_putc (s, ZEBRA_NEXTHOP_IPV4);
stream_put_in_addr (s, &path->nexthop);
}
else
{
stream_putc (s, ZEBRA_NEXTHOP_IFINDEX);
if (path->ifindex)
stream_putl (s, path->ifindex);
else
stream_putl (s, 0);
}
if (IS_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
{
char buf[2][INET_ADDRSTRLEN];
zlog_debug("Zebra: Route add %s/%d nexthop %s",
inet_ntop(AF_INET, &p->prefix,
buf[0], sizeof(buf[0])),
p->prefixlen,
inet_ntop(AF_INET, &path->nexthop,
buf[1], sizeof(buf[1])));
}
}
if (CHECK_FLAG (message, ZAPI_MESSAGE_DISTANCE))
stream_putc (s, distance);
if (CHECK_FLAG (message, ZAPI_MESSAGE_METRIC))
{
if (or->path_type == OSPF_PATH_TYPE1_EXTERNAL)
stream_putl (s, or->cost + or->u.ext.type2_cost);
else if (or->path_type == OSPF_PATH_TYPE2_EXTERNAL)
stream_putl (s, or->u.ext.type2_cost);
else
stream_putl (s, or->cost);
}
stream_putw_at (s, 0, stream_get_endp (s));
zclient_send_message(zclient);
}
static int
zsend_ipv6_nexthop_lookup (struct zserv *client, struct in6_addr *addr)
{
struct stream *s;
struct rib *rib;
unsigned long nump;
u_char num;
struct nexthop *nexthop;
/* Lookup nexthop. */
rib = rib_match_ipv6 (addr);
/* Get output stream. */
s = client->obuf;
stream_reset (s);
/* Fill in result. */
zserv_create_header (s, ZEBRA_IPV6_NEXTHOP_LOOKUP);
stream_put (s, &addr, 16);
if (rib)
{
stream_putl (s, rib->metric);
num = 0;
nump = stream_get_endp(s);
stream_putc (s, 0);
for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB))
{
stream_putc (s, nexthop->type);
switch (nexthop->type)
{
case ZEBRA_NEXTHOP_IPV6:
stream_put (s, &nexthop->gate.ipv6, 16);
break;
case ZEBRA_NEXTHOP_IPV6_IFINDEX:
case ZEBRA_NEXTHOP_IPV6_IFNAME:
stream_put (s, &nexthop->gate.ipv6, 16);
stream_putl (s, nexthop->ifindex);
break;
case ZEBRA_NEXTHOP_IFINDEX:
case ZEBRA_NEXTHOP_IFNAME:
stream_putl (s, nexthop->ifindex);
break;
default:
/* do nothing */
break;
}
num++;
}
stream_putc_at (s, nump, num);
}
else
{
stream_putl (s, 0);
stream_putc (s, 0);
}
stream_putw_at (s, 0, stream_get_endp (s));
return zebra_server_send_message(client);
}
/*
* The zebra server sends the clients a ZEBRA_IPV4_ROUTE_ADD or a
* ZEBRA_IPV6_ROUTE_ADD via zsend_route_multipath in the following
* situations:
* - when the client starts up, and requests default information
* by sending a ZEBRA_REDISTRIBUTE_DEFAULT_ADD to the zebra server, in the
* - case of rip, ripngd, ospfd and ospf6d, when the client sends a
* ZEBRA_REDISTRIBUTE_ADD as a result of the "redistribute" vty cmd,
* - when the zebra server redistributes routes after it updates its rib
*
* The zebra server sends clients a ZEBRA_IPV4_ROUTE_DELETE or a
* ZEBRA_IPV6_ROUTE_DELETE via zsend_route_multipath when:
* - a "ip route" or "ipv6 route" vty command is issued, a prefix is
* - deleted from zebra's rib, and this info
* has to be redistributed to the clients
*
* XXX The ZEBRA_IPV*_ROUTE_ADD message is also sent by the client to the
* zebra server when the client wants to tell the zebra server to add a
* route to the kernel (zapi_ipv4_add etc. ). Since it's essentially the
* same message being sent back and forth, this function and
* zapi_ipv{4,6}_{add, delete} should be re-written to avoid code
* duplication.
*/
int
zsend_route_multipath (int cmd, struct zserv *client, struct prefix *p,
struct rib *rib)
{
int psize;
struct stream *s;
struct nexthop *nexthop;
unsigned long nhnummark = 0, messmark = 0;
int nhnum = 0;
u_char zapi_flags = 0;
s = client->obuf;
stream_reset (s);
zserv_create_header (s, cmd);
/* Put type and nexthop. */
stream_putc (s, rib->type);
stream_putc (s, rib->flags);
/* marker for message flags field */
messmark = stream_get_endp (s);
stream_putc (s, 0);
/* Prefix. */
psize = PSIZE (p->prefixlen);
stream_putc (s, p->prefixlen);
stream_write (s, (u_char *) & p->u.prefix, psize);
/*
* XXX The message format sent by zebra below does not match the format
* of the corresponding message expected by the zebra server
* itself (e.g., see zread_ipv4_add). The nexthop_num is not set correctly,
* (is there a bug on the client side if more than one segment is sent?)
* nexthop ZEBRA_NEXTHOP_IPV4 is never set, ZEBRA_NEXTHOP_IFINDEX
* is hard-coded.
*/
/* Nexthop */
for (nexthop = rib->nexthop; nexthop; nexthop = nexthop->next)
{
if (CHECK_FLAG (nexthop->flags, NEXTHOP_FLAG_FIB))
{
SET_FLAG (zapi_flags, ZAPI_MESSAGE_NEXTHOP);
SET_FLAG (zapi_flags, ZAPI_MESSAGE_IFINDEX);
if (nhnummark == 0)
{
nhnummark = stream_get_endp (s);
stream_putc (s, 1); /* placeholder */
}
nhnum++;
switch(nexthop->type)
{
case NEXTHOP_TYPE_IPV4:
case NEXTHOP_TYPE_IPV4_IFINDEX:
stream_put_in_addr (s, &nexthop->gate.ipv4);
break;
#ifdef HAVE_IPV6
case NEXTHOP_TYPE_IPV6:
case NEXTHOP_TYPE_IPV6_IFINDEX:
case NEXTHOP_TYPE_IPV6_IFNAME:
stream_write (s, (u_char *) &nexthop->gate.ipv6, 16);
break;
#endif
default:
if (cmd == ZEBRA_IPV4_ROUTE_ADD
|| cmd == ZEBRA_IPV4_ROUTE_DELETE)
{
struct in_addr empty;
memset (&empty, 0, sizeof (struct in_addr));
stream_write (s, (u_char *) &empty, IPV4_MAX_BYTELEN);
}
else
{
struct in6_addr empty;
memset (&empty, 0, sizeof (struct in6_addr));
stream_write (s, (u_char *) &empty, IPV6_MAX_BYTELEN);
}
}
/* Interface index. */
stream_putc (s, 1);
stream_putl (s, nexthop->ifindex);
break;
}
}
/* Metric */
if (cmd == ZEBRA_IPV4_ROUTE_ADD || cmd == ZEBRA_IPV6_ROUTE_ADD)
{
SET_FLAG (zapi_flags, ZAPI_MESSAGE_DISTANCE);
stream_putc (s, rib->distance);
SET_FLAG (zapi_flags, ZAPI_MESSAGE_METRIC);
stream_putl (s, rib->metric);
}
/* write real message flags value */
stream_putc_at (s, messmark, zapi_flags);
/* Write next-hop number */
if (nhnummark)
stream_putc_at (s, nhnummark, nhnum);
/* Write packet size. */
stream_putw_at (s, 0, stream_get_endp (s));
return zebra_server_send_message(client);
}
/* Handler of zebra service request. */
static int
zebra_client_read (struct thread *thread)
{
int sock;
struct zserv *client;
size_t already;
uint16_t length, command;
uint8_t marker, version;
/* Get thread data. Reset reading thread because I'm running. */
sock = THREAD_FD (thread);
client = THREAD_ARG (thread);
client->t_read = NULL;
if (client->t_suicide)
{
zebra_client_close(client);
return -1;
}
/* Read length and command (if we don't have it already). */
if ((already = stream_get_endp(client->ibuf)) < ZEBRA_HEADER_SIZE)
{
ssize_t nbyte;
if (((nbyte = stream_read_try (client->ibuf, sock,
ZEBRA_HEADER_SIZE-already)) == 0) ||
(nbyte == -1))
{
if (IS_ZEBRA_DEBUG_EVENT)
zlog_debug ("connection closed socket [%d]", sock);
zebra_client_close (client);
return -1;
}
if (nbyte != (ssize_t)(ZEBRA_HEADER_SIZE-already))
{
/* Try again later. */
zebra_event (ZEBRA_READ, sock, client);
return 0;
}
already = ZEBRA_HEADER_SIZE;
}
/* Reset to read from the beginning of the incoming packet. */
stream_set_getp(client->ibuf, 0);
/* Fetch header values */
length = stream_getw (client->ibuf);
marker = stream_getc (client->ibuf);
version = stream_getc (client->ibuf);
command = stream_getw (client->ibuf);
if (marker != ZEBRA_HEADER_MARKER || version != ZSERV_VERSION)
{
zlog_err("%s: socket %d version mismatch, marker %d, version %d",
__func__, sock, marker, version);
zebra_client_close (client);
return -1;
}
if (length < ZEBRA_HEADER_SIZE)
{
zlog_warn("%s: socket %d message length %u is less than header size %d",
__func__, sock, length, ZEBRA_HEADER_SIZE);
zebra_client_close (client);
return -1;
}
if (length > STREAM_SIZE(client->ibuf))
{
zlog_warn("%s: socket %d message length %u exceeds buffer size %lu",
__func__, sock, length, (u_long)STREAM_SIZE(client->ibuf));
zebra_client_close (client);
return -1;
}
/* Read rest of data. */
if (already < length)
{
ssize_t nbyte;
if (((nbyte = stream_read_try (client->ibuf, sock,
length-already)) == 0) ||
(nbyte == -1))
{
if (IS_ZEBRA_DEBUG_EVENT)
zlog_debug ("connection closed [%d] when reading zebra data", sock);
zebra_client_close (client);
return -1;
}
if (nbyte != (ssize_t)(length-already))
{
/* Try again later. */
zebra_event (ZEBRA_READ, sock, client);
return 0;
}
}
length -= ZEBRA_HEADER_SIZE;
/* Debug packet information. */
if (IS_ZEBRA_DEBUG_EVENT)
zlog_debug ("zebra message comes from socket [%d]", sock);
if (IS_ZEBRA_DEBUG_PACKET && IS_ZEBRA_DEBUG_RECV)
zlog_debug ("zebra message received [%s] %d",
zserv_command_string (command), length);
switch (command)
{
case ZEBRA_ROUTER_ID_ADD:
zread_router_id_add (client, length);
break;
case ZEBRA_ROUTER_ID_DELETE:
zread_router_id_delete (client, length);
break;
case ZEBRA_INTERFACE_ADD:
zread_interface_add (client, length);
break;
case ZEBRA_INTERFACE_DELETE:
zread_interface_delete (client, length);
break;
case ZEBRA_IPV4_ROUTE_ADD:
zread_ipv4_add (client, length);
break;
case ZEBRA_IPV4_ROUTE_DELETE:
zread_ipv4_delete (client, length);
break;
#ifdef HAVE_IPV6
case ZEBRA_IPV6_ROUTE_ADD:
zread_ipv6_add (client, length);
break;
case ZEBRA_IPV6_ROUTE_DELETE:
zread_ipv6_delete (client, length);
break;
#endif /* HAVE_IPV6 */
case ZEBRA_REDISTRIBUTE_ADD:
zebra_redistribute_add (command, client, length);
break;
case ZEBRA_REDISTRIBUTE_DELETE:
zebra_redistribute_delete (command, client, length);
break;
case ZEBRA_REDISTRIBUTE_DEFAULT_ADD:
zebra_redistribute_default_add (command, client, length);
break;
case ZEBRA_REDISTRIBUTE_DEFAULT_DELETE:
zebra_redistribute_default_delete (command, client, length);
break;
case ZEBRA_IPV4_NEXTHOP_LOOKUP:
zread_ipv4_nexthop_lookup (client, length);
break;
#ifdef HAVE_IPV6
case ZEBRA_IPV6_NEXTHOP_LOOKUP:
zread_ipv6_nexthop_lookup (client, length);
break;
#endif /* HAVE_IPV6 */
case ZEBRA_IPV4_IMPORT_LOOKUP:
zread_ipv4_import_lookup (client, length);
break;
case ZEBRA_HELLO:
zread_hello (client);
break;
default:
zlog_info ("Zebra received unknown command %d", command);
break;
}
if (client->t_suicide)
{
/* No need to wait for thread callback, just kill immediately. */
zebra_client_close(client);
return -1;
}
stream_reset (client->ibuf);
zebra_event (ZEBRA_READ, sock, client);
return 0;
}
/* Fill in capability open option to the packet. */
void
bgp_open_capability (struct stream *s, struct peer *peer)
{
u_char len;
unsigned long cp;
afi_t afi;
safi_t safi;
as_t local_as;
/* Remember current pointer for Opt Parm Len. */
cp = stream_get_endp (s);
/* Opt Parm Len. */
stream_putc (s, 0);
/* Do not send capability. */
if (! CHECK_FLAG (peer->sflags, PEER_STATUS_CAPABILITY_OPEN)
|| CHECK_FLAG (peer->flags, PEER_FLAG_DONT_CAPABILITY))
return;
/* IPv4 unicast. */
if (peer->afc[AFI_IP][SAFI_UNICAST])
{
peer->afc_adv[AFI_IP][SAFI_UNICAST] = 1;
stream_putc (s, BGP_OPEN_OPT_CAP);
stream_putc (s, CAPABILITY_CODE_MP_LEN + 2);
stream_putc (s, CAPABILITY_CODE_MP);
stream_putc (s, CAPABILITY_CODE_MP_LEN);
stream_putw (s, AFI_IP);
stream_putc (s, 0);
stream_putc (s, SAFI_UNICAST);
}
/* IPv4 multicast. */
if (peer->afc[AFI_IP][SAFI_MULTICAST])
{
peer->afc_adv[AFI_IP][SAFI_MULTICAST] = 1;
stream_putc (s, BGP_OPEN_OPT_CAP);
stream_putc (s, CAPABILITY_CODE_MP_LEN + 2);
stream_putc (s, CAPABILITY_CODE_MP);
stream_putc (s, CAPABILITY_CODE_MP_LEN);
stream_putw (s, AFI_IP);
stream_putc (s, 0);
stream_putc (s, SAFI_MULTICAST);
}
/* IPv4 VPN */
if (peer->afc[AFI_IP][SAFI_MPLS_VPN])
{
peer->afc_adv[AFI_IP][SAFI_MPLS_VPN] = 1;
stream_putc (s, BGP_OPEN_OPT_CAP);
stream_putc (s, CAPABILITY_CODE_MP_LEN + 2);
stream_putc (s, CAPABILITY_CODE_MP);
stream_putc (s, CAPABILITY_CODE_MP_LEN);
stream_putw (s, AFI_IP);
stream_putc (s, 0);
stream_putc (s, SAFI_MPLS_LABELED_VPN);
}
#ifdef HAVE_IPV6
/* IPv6 unicast. */
if (peer->afc[AFI_IP6][SAFI_UNICAST])
{
peer->afc_adv[AFI_IP6][SAFI_UNICAST] = 1;
stream_putc (s, BGP_OPEN_OPT_CAP);
stream_putc (s, CAPABILITY_CODE_MP_LEN + 2);
stream_putc (s, CAPABILITY_CODE_MP);
stream_putc (s, CAPABILITY_CODE_MP_LEN);
stream_putw (s, AFI_IP6);
stream_putc (s, 0);
stream_putc (s, SAFI_UNICAST);
}
/* IPv6 multicast. */
if (peer->afc[AFI_IP6][SAFI_MULTICAST])
{
peer->afc_adv[AFI_IP6][SAFI_MULTICAST] = 1;
stream_putc (s, BGP_OPEN_OPT_CAP);
stream_putc (s, CAPABILITY_CODE_MP_LEN + 2);
stream_putc (s, CAPABILITY_CODE_MP);
stream_putc (s, CAPABILITY_CODE_MP_LEN);
stream_putw (s, AFI_IP6);
stream_putc (s, 0);
stream_putc (s, SAFI_MULTICAST);
}
#endif /* HAVE_IPV6 */
/* Route refresh. */
SET_FLAG (peer->cap, PEER_CAP_REFRESH_ADV);
stream_putc (s, BGP_OPEN_OPT_CAP);
stream_putc (s, CAPABILITY_CODE_REFRESH_LEN + 2);
stream_putc (s, CAPABILITY_CODE_REFRESH_OLD);
stream_putc (s, CAPABILITY_CODE_REFRESH_LEN);
stream_putc (s, BGP_OPEN_OPT_CAP);
stream_putc (s, CAPABILITY_CODE_REFRESH_LEN + 2);
stream_putc (s, CAPABILITY_CODE_REFRESH);
stream_putc (s, CAPABILITY_CODE_REFRESH_LEN);
/* AS4 */
SET_FLAG (peer->cap, PEER_CAP_AS4_ADV);
stream_putc (s, BGP_OPEN_OPT_CAP);
stream_putc (s, CAPABILITY_CODE_AS4_LEN + 2);
stream_putc (s, CAPABILITY_CODE_AS4);
stream_putc (s, CAPABILITY_CODE_AS4_LEN);
if ( peer->change_local_as )
local_as = peer->change_local_as;
else
local_as = peer->local_as;
stream_putl (s, local_as );
/* ORF capability. */
for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_SM)
|| CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_RM))
{
bgp_open_capability_orf (s, peer, afi, safi, CAPABILITY_CODE_ORF_OLD);
bgp_open_capability_orf (s, peer, afi, safi, CAPABILITY_CODE_ORF);
}
/* Dynamic capability. */
if (CHECK_FLAG (peer->flags, PEER_FLAG_DYNAMIC_CAPABILITY))
{
SET_FLAG (peer->cap, PEER_CAP_DYNAMIC_ADV);
stream_putc (s, BGP_OPEN_OPT_CAP);
stream_putc (s, CAPABILITY_CODE_DYNAMIC_LEN + 2);
stream_putc (s, CAPABILITY_CODE_DYNAMIC);
stream_putc (s, CAPABILITY_CODE_DYNAMIC_LEN);
}
/* Graceful restart capability */
if (bgp_flag_check (peer->bgp, BGP_FLAG_GRACEFUL_RESTART))
{
SET_FLAG (peer->cap, PEER_CAP_RESTART_ADV);
stream_putc (s, BGP_OPEN_OPT_CAP);
stream_putc (s, CAPABILITY_CODE_RESTART_LEN + 2);
stream_putc (s, CAPABILITY_CODE_RESTART);
stream_putc (s, CAPABILITY_CODE_RESTART_LEN);
stream_putw (s, peer->bgp->restart_time);
}
/* Total Opt Parm Len. */
len = stream_get_endp (s) - cp - 1;
stream_putc_at (s, cp, len);
}
static void
bgp_open_capability_orf (struct stream *s, struct peer *peer,
afi_t afi, safi_t safi, u_char code)
{
u_char cap_len;
u_char orf_len;
unsigned long capp;
unsigned long orfp;
unsigned long numberp;
int number_of_orfs = 0;
if (safi == SAFI_MPLS_VPN)
safi = SAFI_MPLS_LABELED_VPN;
stream_putc (s, BGP_OPEN_OPT_CAP);
capp = stream_get_endp (s); /* Set Capability Len Pointer */
stream_putc (s, 0); /* Capability Length */
stream_putc (s, code); /* Capability Code */
orfp = stream_get_endp (s); /* Set ORF Len Pointer */
stream_putc (s, 0); /* ORF Length */
stream_putw (s, afi);
stream_putc (s, 0);
stream_putc (s, safi);
numberp = stream_get_endp (s); /* Set Number Pointer */
stream_putc (s, 0); /* Number of ORFs */
/* Address Prefix ORF */
if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_SM)
|| CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_RM))
{
stream_putc (s, (code == CAPABILITY_CODE_ORF ?
ORF_TYPE_PREFIX : ORF_TYPE_PREFIX_OLD));
if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_SM)
&& CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_RM))
{
SET_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV);
SET_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_ADV);
stream_putc (s, ORF_MODE_BOTH);
}
else if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_SM))
{
SET_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV);
stream_putc (s, ORF_MODE_SEND);
}
else
{
SET_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_ADV);
stream_putc (s, ORF_MODE_RECEIVE);
}
number_of_orfs++;
}
/* Total Number of ORFs. */
stream_putc_at (s, numberp, number_of_orfs);
/* Total ORF Len. */
orf_len = stream_get_endp (s) - orfp - 1;
stream_putc_at (s, orfp, orf_len);
/* Total Capability Len. */
cap_len = stream_get_endp (s) - capp - 1;
stream_putc_at (s, capp, cap_len);
}
