/* Router-id update message from zebra. */
static int ldp_router_id_update_zebra(int command, struct zclient *zclient,
zebra_size_t length) {
struct ldp *ldp = ldp_get();
zebra_router_id_update_read(zclient->ibuf,&router_id);
zlog_info("router-id change %s",
inet_ntoa(router_id.u.prefix4));
if (ldp && ldp->lsr_id_is_static != MPLS_BOOL_TRUE)
ldp_router_id_update(ldp, &router_id);
return 0;
}
int mplsd_write(struct thread *thread) {
struct ldp *ldp = ldp_get();
int retval;
mpls_socket_handle socket;
MPLS_ASSERT(thread);
socket = THREAD_ARG(thread);
socket->write = thread_add_write(master,mplsd_write,socket,socket->fd);
if (socket->type != MPLS_SOCKET_TCP_CONNECT) {
assert(0);
}
retval = ldp_event(ldp->h, socket, socket->extra,
LDP_EVENT_TCP_CONNECT);
return 0;
}
int mplsd_read(struct thread *thread) {
int retval;
struct ldp *ldp = ldp_get();
mpls_socket_handle socket;
MPLS_ASSERT(thread);
socket = THREAD_ARG(thread);
socket->read = thread_add_read(master,mplsd_read,socket,socket->fd);
if (!ldp) {
return 0;
}
switch (socket->type) {
case MPLS_SOCKET_TCP_DATA:
{
retval = ldp_event(ldp->h, socket, socket->extra,
LDP_EVENT_TCP_DATA);
break;
}
case MPLS_SOCKET_TCP_LISTEN:
{
retval = ldp_event(ldp->h, socket, socket->extra,
LDP_EVENT_TCP_LISTEN);
break;
}
case MPLS_SOCKET_UDP_DATA:
{
retval = ldp_event(ldp->h, socket, socket->extra,
LDP_EVENT_UDP_DATA);
break;
}
default:
{
assert(0);
}
}
return 0;
}
static int ldp_zebra_read_ipv4(int cmd, struct zclient *client,
zebra_size_t length) {
struct prefix_ipv4 prefix;
struct zapi_ipv4 api;
int i = 0;
int j;
struct mpls_nexthop nexthop[8];
struct ldp *ldp = ldp_get();
struct mpls_fec fec;
struct stream *s;
struct in_addr tmp;
memset(&api,0,sizeof(api));
memset(nexthop,0,sizeof(nexthop));
s = client->ibuf;
zapi_ipv4_read (s, length, &api, &prefix);
zlog_info("route %s/%d", inet_ntoa(prefix.prefix), prefix.prefixlen);
if (CHECK_FLAG (api.message, ZAPI_MESSAGE_NEXTHOP))
{
for (i = 0; i < api.nexthop_num; i++)
{
if (api.type == ZEBRA_ROUTE_CONNECT)
{
nexthop[i].attached = MPLS_BOOL_TRUE;
zlog_info("\tattached");
}
nexthop[i].ip.type = MPLS_FAMILY_IPV4;
if (CHECK_FLAG (api.message, ZAPI_MESSAGE_DISTANCE))
nexthop[i].distance = api.message;
if (CHECK_FLAG (api.message, ZAPI_MESSAGE_METRIC))
nexthop[i].metric = api.metric;
if (CHECK_FLAG (api.nexthop[i].type, ZEBRA_NEXTHOP_IPV4))
{
nexthop[i].ip.u.ipv4 = ntohl(api.nexthop[i].gw.ipv4.s_addr);
nexthop[i].type |= MPLS_NH_IP;
tmp.s_addr = htonl(nexthop[i].ip.u.ipv4);
zlog_info("\tnexthop %s", inet_ntoa(tmp));
}
if (CHECK_FLAG (api.nexthop[i].type, ZEBRA_NEXTHOP_IFINDEX))
{
nexthop[i].if_handle =
if_lookup_by_index(api.nexthop[i].intf.index);
if (nexthop[i].if_handle)
{
nexthop[i].type |= MPLS_NH_IF;
zlog_info("\tifindex %d", nexthop[i].if_handle->ifindex);
}
}
}
}
zebra_prefix2mpls_fec((struct prefix*)&prefix, &fec);
for (j = 0; j < i; j++) {
if (cmd == ZEBRA_IPV4_ROUTE_ADD) {
zlog_info("\tadd");
if ((ldp_cfg_fec_get(ldp->h, &fec, 0) != MPLS_SUCCESS) ||
(fec.is_route == MPLS_BOOL_FALSE)) {
if (ldp_cfg_fec_set(ldp->h, &fec, LDP_CFG_ADD) != MPLS_SUCCESS) {
MPLS_ASSERT(0);
}
}
if (ldp_cfg_fec_nexthop_get(ldp->h, &fec, &nexthop[j],
LDP_FEC_CFG_BY_INDEX) != MPLS_SUCCESS) {
if (ldp_cfg_fec_nexthop_set(ldp->h, &fec, &nexthop[j],
LDP_CFG_ADD|LDP_FEC_CFG_BY_INDEX) != MPLS_SUCCESS) {
MPLS_ASSERT(0);
}
} else {
/*
* already exists ... looks like we can get the same route sent
* to us twice ... multiple protocols?
MPLS_ASSERT(0);
*/
}
} else {
zlog_info("\tdelete");
if ((ldp_cfg_fec_get(ldp->h, &fec, 0) == MPLS_SUCCESS) &&
(fec.is_route == MPLS_BOOL_TRUE)) {
if (ldp_cfg_fec_nexthop_get(ldp->h, &fec, &nexthop[j],
LDP_FEC_CFG_BY_INDEX) == MPLS_SUCCESS) {
if (ldp_cfg_fec_nexthop_set(ldp->h, &fec, &nexthop[j],
LDP_FEC_CFG_BY_INDEX|LDP_CFG_DEL|
LDP_FEC_NEXTHOP_CFG_BY_INDEX) != MPLS_SUCCESS) {
MPLS_ASSERT(0);
}
} else {
MPLS_ASSERT(0);
}
if (ldp_cfg_fec_set(ldp->h, &fec, LDP_CFG_DEL|LDP_FEC_CFG_BY_INDEX) !=
MPLS_SUCCESS) {
MPLS_ASSERT(0);
}
} else {
MPLS_ASSERT(0);
}
}
}
return 0;
}
static int ldp_interface_address_delete(int command, struct zclient *zclient,
zebra_size_t length) {
struct ldp *ldp = ldp_get();
struct connected *c;
struct interface *ifp;
struct prefix *p;
struct ldp_addr addr;
struct ldp_if iff;
struct ldp_interface *li;
c = zebra_interface_address_read(command, zclient->ibuf);
if (c == NULL || c->address->family != AF_INET) {
return 0;
}
ifp = c->ifp;
p = c->address;
zlog_info("address delete %s from interface %s",
inet_ntoa(p->u.prefix4), ifp->name);
if (ldp) {
prefix2mpls_inet_addr(p, &addr.address);
iff.handle = ifp;
ldp_cfg_if_addr_set(ldp->h, &iff, &addr, LDP_CFG_DEL);
li = ifp->info;
if (ldp->trans_addr == LDP_TRANS_ADDR_STATIC_INTERFACE &&
!strncmp(ldp->trans_addr_ifname,ifp->name,IFNAMSIZ + 1)) {
ldp_global g;
zlog_info("updating global transport address");
g.transport_address.u.ipv4 = ntohl(if_ipv4_src_address (ifp));
g.transport_address.type =
(g.transport_address.u.ipv4)?MPLS_FAMILY_IPV4:MPLS_FAMILY_NONE;
ldp_admin_state_start(ldp);
ldp_cfg_global_set(ldp->h,&g, LDP_GLOBAL_CFG_TRANS_ADDR);
ldp_admin_state_finish(ldp);
}
if (ldp->trans_addr == LDP_TRANS_ADDR_INTERFACE) {
zlog_info("updating entity transport address");
li->entity.transport_address.u.ipv4 =
ntohl(if_ipv4_src_address (ifp));
li->entity.transport_address.type =
li->entity.transport_address.u.ipv4 ?
MPLS_FAMILY_IPV4 : MPLS_FAMILY_NONE;
if (li->entity.index) {
ldp_interface_admin_state_start(li);
ldp_cfg_entity_set(ldp->h, &li->entity,
LDP_ENTITY_CFG_TRANS_ADDR);
ldp_interface_admin_state_finish(li);
}
}
}
connected_free(c);
return 0;
}
mpls_fib_handle mpls_fib_open(const mpls_instance_handle handle,
const mpls_cfg_handle cfg)
{
struct ldp *ldp = ldp_get();
return ldp;
}
