/*
* Add a vertex to TENT sorted by cost and by vertextype on tie break situation
*/
static struct isis_vertex *
isis_spf_add2tent (struct isis_spftree *spftree, enum vertextype vtype,
void *id, uint32_t cost, int depth, int family,
struct isis_adjacency *adj, struct isis_vertex *parent)
{
struct isis_vertex *vertex, *v;
struct listnode *node;
struct isis_adjacency *parent_adj;
#ifdef EXTREME_DEBUG
u_char buff[BUFSIZ];
#endif
assert (isis_find_vertex (spftree->paths, id, vtype) == NULL);
assert (isis_find_vertex (spftree->tents, id, vtype) == NULL);
vertex = isis_vertex_new (id, vtype);
vertex->d_N = cost;
vertex->depth = depth;
if (parent) {
listnode_add (vertex->parents, parent);
if (listnode_lookup (parent->children, vertex) == NULL)
listnode_add (parent->children, vertex);
}
if (parent && parent->Adj_N && listcount(parent->Adj_N) > 0) {
for (ALL_LIST_ELEMENTS_RO (parent->Adj_N, node, parent_adj))
listnode_add (vertex->Adj_N, parent_adj);
} else if (adj) {
struct connected *
connected_add_by_prefix (struct interface *ifp, struct prefix *p,
struct prefix *destination)
{
struct connected *ifc;
/* Allocate new connected address. */
ifc = connected_new ();
ifc->ifp = ifp;
/* Fetch interface address */
ifc->address = prefix_new();
memcpy (ifc->address, p, sizeof(struct prefix));
/* Fetch dest address */
if (destination)
{
ifc->destination = prefix_new();
memcpy (ifc->destination, destination, sizeof(struct prefix));
}
/* Add connected address to the interface. */
listnode_add (ifp->connected, ifc);
return ifc;
}
/*
* Add this IS to the root of SPT
*/
static struct isis_vertex *
isis_spf_add_root (struct isis_spftree *spftree, int level, u_char *sysid)
{
struct isis_vertex *vertex;
struct isis_lsp *lsp;
#ifdef EXTREME_DEBUG
u_char buff[BUFSIZ];
#endif /* EXTREME_DEBUG */
lsp = isis_root_system_lsp (spftree->area, level, sysid);
if (lsp == NULL)
zlog_warn ("ISIS-Spf: could not find own l%d LSP!", level);
if (!spftree->area->oldmetric)
vertex = isis_vertex_new (sysid, VTYPE_NONPSEUDO_TE_IS);
else
vertex = isis_vertex_new (sysid, VTYPE_NONPSEUDO_IS);
listnode_add (spftree->paths, vertex);
#ifdef EXTREME_DEBUG
zlog_debug ("ISIS-Spf: added this IS %s %s depth %d dist %d to PATHS",
vtype2string (vertex->type), vid2string (vertex, buff),
vertex->depth, vertex->d_N);
#endif /* EXTREME_DEBUG */
return vertex;
}
void
isis_adj_build_up_list (struct list *adjdb, struct list *list)
{
struct isis_adjacency *adj;
struct listnode *node;
if (!list)
{
Log(LOG_WARNING, "WARN (default/core/ISIS ): isis_adj_build_up_list(): NULL list\n");
return;
}
for (ALL_LIST_ELEMENTS_RO (adjdb, node, adj))
{
if (!adj)
{
Log(LOG_WARNING, "WARN (default/core/ISIS ): isis_adj_build_up_list(): NULL adj\n");
return;
}
if (adj->adj_state == ISIS_ADJ_UP)
listnode_add (list, adj);
}
return;
}
struct igmp_sock *pim_igmp_sock_add(struct list *igmp_sock_list,
struct in_addr ifaddr,
struct interface *ifp)
{
struct pim_interface *pim_ifp;
struct igmp_sock *igmp;
int fd;
pim_ifp = ifp->info;
fd = igmp_sock_open(ifaddr, ifp->ifindex, pim_ifp->options);
if (fd < 0) {
zlog_warn("Could not open IGMP socket for %s on %s",
inet_ntoa(ifaddr), ifp->name);
return 0;
}
igmp = igmp_sock_new(fd, ifaddr, ifp);
if (!igmp) {
zlog_err("%s %s: igmp_sock_new() failure",
__FILE__, __PRETTY_FUNCTION__);
close(fd);
return 0;
}
listnode_add(igmp_sock_list, igmp);
#ifdef IGMP_SOCK_DUMP
igmp_sock_dump(igmp_sock_array);
#endif
return igmp;
}
void
isis_dynhn_insert (u_char * id, struct hostname *hostname, int level)
{
struct isis_dynhn *dyn;
dyn = dynhn_find_by_id (id);
if (dyn)
{
memcpy (&dyn->name, hostname, hostname->namelen + 1);
memcpy (dyn->id, id, ISIS_SYS_ID_LEN);
dyn->refresh = time (NULL);
return;
}
dyn = XCALLOC (MTYPE_ISIS_DYNHN, sizeof (struct isis_dynhn));
if (!dyn)
{
zlog_warn ("isis_dynhn_insert(): out of memory!");
return;
}
/* we also copy the length */
memcpy (&dyn->name, hostname, hostname->namelen + 1);
memcpy (dyn->id, id, ISIS_SYS_ID_LEN);
dyn->refresh = time (NULL);
dyn->level = level;
listnode_add (dyn_cache, dyn);
return;
}
/*
* Add this IS to the root of SPT
*/
static void
isis_spf_add_self (struct isis_spftree *spftree, struct isis_area *area,
int level)
{
struct isis_vertex *vertex;
struct isis_lsp *lsp;
u_char lspid[ISIS_SYS_ID_LEN + 2];
memcpy (lspid, isis->sysid, ISIS_SYS_ID_LEN);
LSP_PSEUDO_ID (lspid) = 0;
LSP_FRAGMENT (lspid) = 0;
lsp = lsp_search (lspid, area->lspdb[level - 1]);
if (lsp == NULL)
Log(LOG_WARNING, "WARN ( default/core/ISIS ): ISIS-Spf: could not find own l%d LSP!\n", level);
if (!area->oldmetric)
vertex = isis_vertex_new (isis->sysid, VTYPE_NONPSEUDO_TE_IS);
else
vertex = isis_vertex_new (isis->sysid, VTYPE_NONPSEUDO_IS);
vertex->lsp = lsp;
listnode_add (spftree->paths, vertex);
return;
}
int eigrp_fsm_event_keep_state(struct eigrp_fsm_action_message *msg) {
struct eigrp_prefix_entry *prefix = msg->prefix;
struct eigrp_neighbor_entry *entry = msg->entry;
if (prefix->state == EIGRP_FSM_STATE_PASSIVE) {
if (!eigrp_metrics_is_same(&prefix->reported_metric,
&((struct eigrp_neighbor_entry *) prefix->entries->head->data)->total_metric)) {
prefix->rdistance =
prefix->fdistance =
prefix->distance =
((struct eigrp_neighbor_entry *) prefix->entries->head->data)->distance;
prefix->reported_metric =
((struct eigrp_neighbor_entry *) prefix->entries->head->data)->total_metric;
if (msg->packet_type == EIGRP_OPC_QUERY)
eigrp_send_reply(msg->adv_router, msg->entry);
prefix->req_action |= EIGRP_FSM_NEED_UPDATE;
listnode_add((eigrp_lookup())->topology_changes_internalIPV4,prefix);
}
eigrp_topology_update_node_flags(prefix);
eigrp_update_routing_table(prefix);
}
if (msg->packet_type == EIGRP_OPC_QUERY)
eigrp_send_reply(msg->adv_router, prefix);
return 1;
}
static struct isis_nexthop *
isis_nexthop_create (struct in_addr *ip, unsigned int ifindex)
{
struct listnode *node;
struct isis_nexthop *nexthop;
for (ALL_LIST_ELEMENTS_RO (isis->nexthops, node, nexthop))
{
if (nexthop->ifindex != ifindex)
continue;
if (ip && memcmp (&nexthop->ip, ip, sizeof (struct in_addr)) != 0)
continue;
nexthop->lock++;
return nexthop;
}
nexthop = XCALLOC (MTYPE_ISIS_NEXTHOP, sizeof (struct isis_nexthop));
if (!nexthop)
{
zlog_err ("ISIS-Rte: isis_nexthop_create: out of memory!");
}
nexthop->ifindex = ifindex;
memcpy (&nexthop->ip, ip, sizeof (struct in_addr));
listnode_add (isis->nexthops, nexthop);
nexthop->lock++;
return nexthop;
}
s32 ldp_accept(struct thread * t)
{
s32 fd ;
union sockunion su ;
struct ldp_peer * peer ;
s32 sock = THREAD_FD(t);
struct ldp * ldp = THREAD_ARG(t);
ldp->t_accept = NULL ;
THREAD_READ_ON(master, ldp->t_accept, ldp_accept, ldp, sock);
fd = sockunion_accept(sock, &su);
if( fd <= 0 )
return -1 ;
peer = ldp_peer_new();
if( NULL == peer )
{
close(fd);
return -1 ;
}
peer->state = ACCEPT_PEER ;
peer->fd = fd ;
peer->ldp = ldp;
peer->transport = su.sin.sin_addr.s_addr;
peer->input = stream_new(LDP_MAX_PDU_LEN);
listnode_add(ldp->accepts, peer);
LDP_FSM_EVENT(peer, ConnectSuccess);
return 0 ;
}
static struct isis_vertex *
isis_spf_add_local (struct isis_spftree *spftree, enum vertextype vtype,
void *id, struct isis_adjacency *adj, u_int32_t cost,
int family)
{
struct isis_vertex *vertex;
vertex = isis_find_vertex (spftree->tents, id, vtype);
if (vertex)
{
/* C.2.5 c) */
if (vertex->d_N == cost)
{
if (adj)
listnode_add (vertex->Adj_N, adj);
/* d) */
if (listcount (vertex->Adj_N) > ISIS_MAX_PATH_SPLITS)
remove_excess_adjs (vertex->Adj_N);
}
/* f) */
else if (vertex->d_N > cost)
{
listnode_delete (spftree->tents, vertex);
goto add2tent;
}
/* e) do nothing */
return vertex;
}
add2tent:
return isis_spf_add2tent (spftree, vtype, id, adj, cost, 1, family);
}
static int
add_tcp_cache(struct list* cache_list, const char* host, const char* port)
{
struct tr_tcp_config* tcp_config_p;
struct tr_socket* tr_socket_p;
cache* cache_p;
if ((tr_socket_p = XMALLOC(MTYPE_BGP_RPKI_CACHE, sizeof(struct tr_socket))) == NULL )
{
return ERROR;
}
if ((tcp_config_p = XMALLOC(MTYPE_BGP_RPKI_CACHE, sizeof(struct tr_tcp_config)))
== NULL )
{
return ERROR;
}
tcp_config_p->host = XSTRDUP(MTYPE_BGP_RPKI_CACHE, host);
tcp_config_p->port = XSTRDUP(MTYPE_BGP_RPKI_CACHE, port);
tr_tcp_init(tcp_config_p, tr_socket_p);
if ((cache_p = create_cache(tr_socket_p)) == NULL )
{
return ERROR;
}
cache_p->tr_config.tcp_config = tcp_config_p;
cache_p->type = TCP;
listnode_add(cache_list, cache_p);
return SUCCESS;
}
struct isis_adjacency *
isis_new_adj (u_char * id, u_char * snpa, int level,
struct isis_circuit *circuit)
{
struct isis_adjacency *adj;
int i;
adj = adj_alloc (id); /* P2P kludge */
if (adj == NULL)
{
zlog_err ("Out of memory!");
return NULL;
}
memcpy (adj->snpa, snpa, 6);
adj->circuit = circuit;
adj->level = level;
adj->flaps = 0;
adj->last_flap = time (NULL);
if (circuit->circ_type == CIRCUIT_T_BROADCAST)
{
listnode_add (circuit->u.bc.adjdb[level - 1], adj);
adj->dischanges[level - 1] = 0;
for (i = 0; i < DIS_RECORDS; i++) /* clear N DIS state change records */
{
adj->dis_record[(i * ISIS_LEVELS) + level - 1].dis
= ISIS_UNKNOWN_DIS;
adj->dis_record[(i * ISIS_LEVELS) + level - 1].last_dis_change
= time (NULL);
}
}
return adj;
}
void
isis_adj_build_up_list (struct list *adjdb, struct list *list)
{
struct isis_adjacency *adj;
struct listnode *node;
if (!list)
{
zlog_warn ("isis_adj_build_up_list(): NULL list");
return;
}
for (node = listhead (adjdb); node; nextnode (node))
{
adj = getdata (node);
if (!adj)
{
zlog_warn ("isis_adj_build_up_list(): NULL adj");
return;
}
if (adj->adj_state == ISIS_ADJ_UP)
listnode_add (list, adj);
}
return;
}
static void
connected_announce (struct interface *ifp, struct connected *ifc)
{
if (!ifc)
return;
listnode_add (ifp->connected, ifc);
/* Update interface address information to protocol daemon. */
if (! CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
{
if (ifc->address->family == AF_INET)
if_subnet_add (ifp, ifc);
SET_FLAG (ifc->conf, ZEBRA_IFC_REAL);
zebra_interface_address_add_update (ifp, ifc);
if (if_is_operative(ifp))
{
if (ifc->address->family == AF_INET)
connected_up_ipv4 (ifp, ifc);
#ifdef HAVE_IPV6
else
connected_up_ipv6 (ifp, ifc);
#endif
}
}
}
void ospf_vl_add(struct ospf *ospf, struct ospf_vl_data *vl_data)
{
listnode_add(ospf->vlinks, vl_data);
#ifdef HAVE_SNMP
ospf_snmp_vl_add(vl_data);
#endif /* HAVE_SNMP */
}
static struct pim_upstream *pim_upstream_new(struct in_addr source_addr,
struct in_addr group_addr)
{
struct pim_upstream *up;
up = XMALLOC(MTYPE_PIM_UPSTREAM, sizeof(*up));
if (!up) {
zlog_err("%s: PIM XMALLOC(%zu) failure",
__PRETTY_FUNCTION__, sizeof(*up));
return 0;
}
up->source_addr = source_addr;
up->group_addr = group_addr;
up->flags = 0;
up->ref_count = 1;
up->t_join_timer = 0;
up->join_state = 0;
up->state_transition = pim_time_monotonic_sec();
up->channel_oil = 0;
up->rpf.source_nexthop.interface = 0;
up->rpf.source_nexthop.mrib_nexthop_addr.s_addr = PIM_NET_INADDR_ANY;
up->rpf.source_nexthop.mrib_metric_preference = qpim_infinite_assert_metric.metric_preference;
up->rpf.source_nexthop.mrib_route_metric = qpim_infinite_assert_metric.route_metric;
up->rpf.rpf_addr.s_addr = PIM_NET_INADDR_ANY;
pim_rpf_update(up, 0);
listnode_add(qpim_upstream_list, up);
return up;
}
void ppp_remark_add_multilink_interface(struct multilink_if_info* info)
{
struct multilink_if_info* p;
p = ppp_remark_lookup_multilink_interface(info->multi_num);
if(p != NULL) {
if(p->multi_ip != info->multi_ip) {/* 修改了组IP，接口IP需要跟着变 */
mcp_pppd_update_allinterface_addto_group(p->multi_ip, info->multi_ip);
p->multi_ip = info->multi_ip;
mcp_pppd_disable_allinterface_addto_group(p);
}
p->multi_num = info->multi_num;
return;
}
p = ppp_multi_info_malloc();
p->multi_ip = info->multi_ip;
p->multi_num = info->multi_num;
p->interface_bit = info->interface_bit;
listnode_add(multilink_if_list, p);
return;
}
/* Tie an interface address to its derived subnet list of addresses. */
int
if_subnet_add (struct interface *ifp, struct connected *ifc)
{
struct route_node *rn;
struct zebra_if *zebra_if;
struct prefix cp;
struct list *addr_list;
assert (ifp && ifp->info && ifc);
zebra_if = ifp->info;
/* Get address derived subnet node and associated address list, while marking
address secondary attribute appropriately. */
cp = *ifc->address;
apply_mask (&cp);
rn = route_node_get (zebra_if->ipv4_subnets, &cp);
if ((addr_list = rn->info))
SET_FLAG (ifc->flags, ZEBRA_IFA_SECONDARY);
else
{
UNSET_FLAG (ifc->flags, ZEBRA_IFA_SECONDARY);
rn->info = addr_list = list_new ();
route_lock_node (rn);
}
/* Tie address at the tail of address list. */
listnode_add (addr_list, ifc);
/* Return list element count. */
return (addr_list->count);
}
struct ospf_neighbor *
ospf_elect_bdr (struct ospf_interface *oi, struct list *el_list)
{
struct list *bdr_list, *no_dr_list;
struct listnode *node;
struct ospf_neighbor *nbr, *bdr = NULL;
bdr_list = list_new ();
no_dr_list = list_new ();
/* Add neighbors to the list. */
for (node = listhead (el_list); node; nextnode (node))
{
nbr = getdata (node);
/* neighbor declared to be DR. */
if (NBR_IS_DR (nbr))
continue;
/* neighbor declared to be BDR. */
if (NBR_IS_BDR (nbr))
listnode_add (bdr_list, nbr);
listnode_add (no_dr_list, nbr);
}
/* Elect Backup Designated Router. */
if (listcount (bdr_list) > 0)
bdr = ospf_dr_election_sub (bdr_list);
else
bdr = ospf_dr_election_sub (no_dr_list);
/* Set BDR to interface. */
if (bdr)
{
BDR (oi) = bdr->address.u.prefix4;
bdr->bd_router = bdr->address.u.prefix4;
}
else
BDR (oi).s_addr = 0;
list_delete (bdr_list);
list_delete (no_dr_list);
return bdr;
}
static void
process_N (struct isis_spftree *spftree, enum vertextype vtype, void *id,
u_int16_t dist, u_int16_t depth, struct isis_adjacency *adj,
int family)
{
struct isis_vertex *vertex;
#ifdef EXTREME_DEBUG
u_char buff[255];
#endif
/* C.2.6 b) */
if (dist > MAX_PATH_METRIC)
return;
/* c) */
vertex = isis_find_vertex (spftree->paths, id, vtype);
if (vertex)
{
#ifdef EXTREME_DEBUG
zlog_debug ("ISIS-Spf: process_N %s %s dist %d already found from PATH",
vtype2string (vtype), vid2string (vertex, buff), dist);
#endif /* EXTREME_DEBUG */
assert (dist >= vertex->d_N);
return;
}
vertex = isis_find_vertex (spftree->tents, id, vtype);
/* d) */
if (vertex)
{
/* 1) */
#ifdef EXTREME_DEBUG
zlog_debug ("ISIS-Spf: process_N %s %s dist %d",
vtype2string (vtype), vid2string (vertex, buff), dist);
#endif /* EXTREME_DEBUG */
if (vertex->d_N == dist)
{
if (adj)
listnode_add (vertex->Adj_N, adj);
/* 2) */
if (listcount (vertex->Adj_N) > ISIS_MAX_PATH_SPLITS)
remove_excess_adjs (vertex->Adj_N);
/* 3) */
return;
}
else if (vertex->d_N < dist)
{
return;
/* 4) */
}
else
{
listnode_delete (spftree->tents, vertex);
}
}
isis_spf_add2tent (spftree, vtype, id, adj, dist, depth, family);
return;
}
extern void deleteText(struct list *_this,s32 delete_p,s32 length)
{
RwRecord * dec = OWJsRewriterRecord(delete_p,NULL,length,0);
if( !_this->cmp || !_this->tail || !_this->tail->data || _this->cmp(dec,_this->tail->data) > 0 )
listnode_add(_this,dec);
else
listnode_add_sort(_this,(void*)dec);
DEBUG("%d,%d",delete_p,length);
}
int
kernel_bfd_add_peer (struct bfd_peer *peer, char appid)
{
struct bfd_peer *tmp_peer;
char *tmp_appid = NULL;
struct listnode *node;
/* lookup same peer */
tmp_peer = bfd_peer_lookup (&peer->su, peer->ifindex, peer->type);
if (!tmp_peer)
{
tmp_peer = XCALLOC (MTYPE_BFD_PEER, sizeof (struct bfd_peer));
memcpy (&tmp_peer->su, &peer->su, sizeof (union sockunion));
tmp_peer->ifindex = peer->ifindex;
tmp_peer->type = peer->type;
tmp_peer->appid_lst = list_new ();
tmp_appid = malloc (sizeof (char));
*tmp_appid = appid;
listnode_add (tmp_peer->appid_lst, tmp_appid);
listnode_add (bfd_peer_list, tmp_peer);
}
else
{
for (node = listhead (tmp_peer->appid_lst); node; nextnode (node))
{
tmp_appid = getdata (node);
if (*tmp_appid == appid)
break;
tmp_appid = NULL;
}
if (tmp_appid)
{
zlog_warn ("duplicate registration.");
return 0;
}
tmp_appid = malloc (sizeof (char));
*tmp_appid = appid;
listnode_add (tmp_peer->appid_lst, tmp_appid);
}
bfd_ioctl_peer (BFD_NEWPEER, peer);
return 0;
}
struct ospf_interface *
ospf_if_new (struct ospf *ospf, struct interface_FOO *ifp, struct prefix *p)
{
struct ospf_interface *oi;
if ((oi = ospf_if_table_lookup (ifp, p)) == NULL)
{
oi = XCALLOC (MTYPE_OSPF_IF, sizeof (struct ospf_interface));
memset (oi, 0, sizeof (struct ospf_interface));
}
else
return oi;
/* Set zebra interface pointer. */
oi->ifp = ifp;
oi->address = p;
ospf_add_to_if (ifp, oi);
listnode_add (ospf->oiflist, oi);
/* Clear self-originated network-LSA. */
oi->network_lsa_self = NULL;
/* Initialize neighbor list. */
oi->nbrs = route_table_init ();
/* Initialize static neighbor list. */
oi->nbr_nbma = list_new ();
/* Initialize Link State Acknowledgment list. */
oi->ls_ack = list_new ();
oi->ls_ack_direct.ls_ack = list_new ();
/* Set default values. */
ospf_if_reset_variables (oi);
/* Add pseudo neighbor. */
oi->nbr_self = ospf_nbr_new (oi);
oi->nbr_self->state = NSM_TwoWay;
oi->nbr_self->priority = OSPF_IF_PARAM (oi, priority);
oi->nbr_self->options = OSPF_OPTION_E;
oi->ls_upd_queue = route_table_init ();
oi->t_ls_upd_event = NULL;
oi->t_ls_ack_direct = NULL;
oi->crypt_seqnum = time (NULL);
#ifdef HAVE_OPAQUE_LSA
ospf_opaque_type9_lsa_init (oi);
#endif /* HAVE_OPAQUE_LSA */
oi->ospf = ospf;
return oi;
}
void
flags_free_index (struct flags *flags, int index)
{
if (flags->free_idcs == NULL)
{
flags->free_idcs = list_new ();
}
listnode_add (flags->free_idcs, (void *) index);
return;
}
extern void insertText(struct list *_this,
s32 insert_p,s32 pre_item,u8* str)
{
RwRecord * inc = OWJsRewriterRecord(insert_p,str,strlen((const char*)str),pre_item);
inc->insert = (u8*)calloc(1,inc->length+1);
memcpy(inc->insert,str,inc->length);
if( !_this->cmp || !_this->tail || !_this->tail->data || _this->cmp(inc,_this->tail->data) > 0 )
listnode_add(_this,inc);
else
listnode_add_sort(_this,(void*)inc);
DEBUG("%d,%d,%s",insert_p,pre_item,str);
}
static int
bgp_listener (int sock, struct sockaddr *sa, socklen_t salen)
{
struct bgp_listener *listener;
int ret, en;
sockopt_reuseaddr (sock);
sockopt_reuseport (sock);
#ifdef IPTOS_PREC_INTERNETCONTROL
if (sa->sa_family == AF_INET)
setsockopt_ipv4_tos (sock, IPTOS_PREC_INTERNETCONTROL);
#endif
#ifdef IPV6_V6ONLY
/* Want only IPV6 on ipv6 socket (not mapped addresses) */
if (sa->sa_family == AF_INET6) {
int on = 1;
setsockopt (sock, IPPROTO_IPV6, IPV6_V6ONLY,
(void *) &on, sizeof (on));
}
#endif
if (bgpd_privs.change (ZPRIVS_RAISE) )
zlog_err ("bgp_socket: could not raise privs");
ret = bind (sock, sa, salen);
en = errno;
if (bgpd_privs.change (ZPRIVS_LOWER) )
zlog_err ("bgp_bind_address: could not lower privs");
if (ret < 0)
{
zlog_err ("bind: %s", safe_strerror (en));
return ret;
}
ret = listen (sock, 3);
if (ret < 0)
{
zlog_err ("listen: %s", safe_strerror (errno));
return ret;
}
listener = XMALLOC (MTYPE_BGP_LISTENER, sizeof(*listener));
listener->fd = sock;
memcpy(&listener->su, sa, salen);
listener->thread = thread_add_read (master, bgp_accept, listener, sock);
listnode_add (bm->listen_sockets, listener);
return 0;
}
struct pim_neighbor *pim_neighbor_add(struct interface *ifp,
struct in_addr source_addr,
pim_hello_options hello_options,
uint16_t holdtime,
uint16_t propagation_delay,
uint16_t override_interval,
uint32_t dr_priority,
uint32_t generation_id,
struct list *addr_list)
{
struct pim_interface *pim_ifp;
struct pim_neighbor *neigh;
neigh = pim_neighbor_new(ifp, source_addr,
hello_options,
holdtime,
propagation_delay,
override_interval,
dr_priority,
generation_id,
addr_list);
if (!neigh) {
return 0;
}
pim_ifp = ifp->info;
zassert(pim_ifp);
listnode_add(pim_ifp->pim_neighbor_list, neigh);
/*
RFC 4601: 4.3.2. DR Election
A router's idea of the current DR on an interface can change when a
PIM Hello message is received, when a neighbor times out, or when a
router's own DR Priority changes.
*/
pim_if_dr_election(neigh->interface); // new neighbor -- should not trigger dr election...
/*
RFC 4601: 4.3.1. Sending Hello Messages
To allow new or rebooting routers to learn of PIM neighbors quickly,
when a Hello message is received from a new neighbor, or a Hello
message with a new GenID is received from an existing neighbor, a
new Hello message should be sent on this interface after a
randomized delay between 0 and Triggered_Hello_Delay.
*/
pim_hello_restart_triggered(neigh->interface);
return neigh;
}
static int bgp_listener(int sock, struct sockaddr *sa, socklen_t salen,
struct bgp *bgp)
{
struct bgp_listener *listener;
int ret, en;
sockopt_reuseaddr(sock);
sockopt_reuseport(sock);
frr_elevate_privs(&bgpd_privs) {
#ifdef IPTOS_PREC_INTERNETCONTROL
if (sa->sa_family == AF_INET)
setsockopt_ipv4_tos(sock, IPTOS_PREC_INTERNETCONTROL);
else if (sa->sa_family == AF_INET6)
setsockopt_ipv6_tclass(sock,
IPTOS_PREC_INTERNETCONTROL);
#endif
sockopt_v6only(sa->sa_family, sock);
ret = bind(sock, sa, salen);
en = errno;
}
if (ret < 0) {
flog_err_sys(EC_LIB_SOCKET, "bind: %s", safe_strerror(en));
return ret;
}
ret = listen(sock, SOMAXCONN);
if (ret < 0) {
flog_err_sys(EC_LIB_SOCKET, "listen: %s", safe_strerror(errno));
return ret;
}
listener = XCALLOC(MTYPE_BGP_LISTENER, sizeof(*listener));
listener->fd = sock;
/* this socket needs a change of ns. record bgp back pointer */
if (bgp->vrf_id != VRF_DEFAULT && vrf_is_backend_netns())
listener->bgp = bgp;
memcpy(&listener->su, sa, salen);
listener->thread = NULL;
thread_add_read(bm->master, bgp_accept, listener, sock,
&listener->thread);
listnode_add(bm->listen_sockets, listener);
return 0;
}
void bgp_table_range_lookup(const struct bgp_table *table, struct prefix *p,
uint8_t maxlen, struct list *matches)
{
struct bgp_node *node = bgp_node_from_rnode(table->route_table->top);
struct bgp_node *matched = NULL;
while (node && node->p.prefixlen <= p->prefixlen
&& prefix_match(&node->p, p)) {
if (node->info && node->p.prefixlen == p->prefixlen) {
matched = node;
break;
}
node = bgp_node_from_rnode(node->link[prefix_bit(
&p->u.prefix, node->p.prefixlen)]);
}
if (node == NULL)
return;
if ((matched == NULL && node->p.prefixlen > maxlen) || !node->parent)
return;
else if (matched == NULL)
matched = node = bgp_node_from_rnode(node->parent);
if (matched->info) {
bgp_lock_node(matched);
listnode_add(matches, matched);
}
while ((node = bgp_route_next_until_maxlen(node, matched, maxlen))) {
if (prefix_match(p, &node->p)) {
if (node->info) {
bgp_lock_node(node);
listnode_add(matches, node);
}
}
}
}
