proxmox-mirrors/mirror_frr
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_frr synced 2025-08-03 08:56:13 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

eigrpd: Cleanup tab/spacing of the *.c files

Browse Source 
Signed-off-by: Donald Sharp <sharpd@cumulusnetworks.com>
This commit is contained in:
Donald Sharp 2017-04-08 14:44:58 -04:00
parent 962251aeff
commit f9e5c9ca06
20 changed files with 3357 additions and 3501 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

294
eigrpd/eigrp_dump.c
View File

@ -70,175 +70,30 @@ config_write_debug (struct vty *vty)
int write = 0;
int i;
const char *type_str[] = {"update", "request", "query", "reply", "hello", "", "probe", "ack", "",
"SIA query", "SIA reply", "stub", "all"};
const char *type_str[] = {"update", "request", "query", "reply",
"hello", "", "probe", "ack", "",
"SIA query", "SIA reply", "stub", "all"};
const char *detail_str[] = {"", " send", " recv", "", " detail",
" send detail", " recv detail", " detail"};
" send detail", " recv detail", " detail"};
/* debug eigrp event. */
// if (IS_CONF_DEBUG_EIGRP (event, EVENT) == EIGRP_DEBUG_EVENT)
// {
// vty_out (vty, "debug eigrp event%s", VTY_NEWLINE);
// write = 1;
// }
/* debug eigrp packet all detail. */
// r = EIGRP_DEBUG_SEND_RECV|EIGRP_DEBUG_DETAIL;
// for (i = 0; i < 11; i++)
// r &= conf_debug_eigrp_packet[i] & (EIGRP_DEBUG_SEND_RECV|EIGRP_DEBUG_DETAIL);
// if (r == (EIGRP_DEBUG_SEND_RECV|EIGRP_DEBUG_DETAIL))
// {
// vty_out (vty, "debug eigrp packet all detail%s", VTY_NEWLINE);
//// return 1;
// }
//
// /* debug eigrp packet all. */
// r = EIGRP_DEBUG_SEND_RECV;
// for (i = 0; i < 11; i++)
// r &= conf_debug_eigrp_packet[i] & EIGRP_DEBUG_SEND_RECV;
// if (r == EIGRP_DEBUG_SEND_RECV)
// {
// vty_out (vty, "debug eigrp packet all%s", VTY_NEWLINE);
// for (i = 0; i < 11; i++)
// if (conf_debug_eigrp_packet[i] & EIGRP_DEBUG_DETAIL)
// vty_out (vty, "debug eigrp packet %s detail%s",
// type_str[i],
// VTY_NEWLINE);
//// return 1;
// }
/* debug eigrp packet */
for (i = 0; i < 10; i++)
{
if (conf_debug_eigrp_packet[i] == 0 && term_debug_eigrp_packet[i] == 0 )
continue;
if (conf_debug_eigrp_packet[i] == 0 && term_debug_eigrp_packet[i] == 0 )
continue;
vty_out (vty, "debug eigrp packet %s%s%s",
type_str[i], detail_str[conf_debug_eigrp_packet[i]],
VTY_NEWLINE);
write = 1;
vty_out (vty, "debug eigrp packet %s%s%s",
type_str[i], detail_str[conf_debug_eigrp_packet[i]],
VTY_NEWLINE);
write = 1;
}
// int write = 0;
// int i, r;
//
// const char *type_str[] = {"hello", "dd", "ls-request", "ls-update", "ls-ack"};
// const char *detail_str[] = {"", " send", " recv", "", " detail",
// " send detail", " recv detail", " detail"};
//
// /* debug ospf ism (status|events|timers). */
// if (IS_CONF_DEBUG_OSPF (ism, ISM) == OSPF_DEBUG_ISM)
// vty_out (vty, "debug ospf ism%s", VTY_NEWLINE);
// else
// {
// if (IS_CONF_DEBUG_OSPF (ism, ISM_STATUS))
// vty_out (vty, "debug ospf ism status%s", VTY_NEWLINE);
// if (IS_CONF_DEBUG_OSPF (ism, ISM_EVENTS))
// vty_out (vty, "debug ospf ism event%s", VTY_NEWLINE);
// if (IS_CONF_DEBUG_OSPF (ism, ISM_TIMERS))
// vty_out (vty, "debug ospf ism timer%s", VTY_NEWLINE);
// }
//
// /* debug ospf nsm (status|events|timers). */
// if (IS_CONF_DEBUG_OSPF (nsm, NSM) == OSPF_DEBUG_NSM)
// vty_out (vty, "debug ospf nsm%s", VTY_NEWLINE);
// else
// {
// if (IS_CONF_DEBUG_OSPF (nsm, NSM_STATUS))
// vty_out (vty, "debug ospf nsm status%s", VTY_NEWLINE);
// if (IS_CONF_DEBUG_OSPF (nsm, NSM_EVENTS))
// vty_out (vty, "debug ospf nsm event%s", VTY_NEWLINE);
// if (IS_CONF_DEBUG_OSPF (nsm, NSM_TIMERS))
// vty_out (vty, "debug ospf nsm timer%s", VTY_NEWLINE);
// }
//
// /* debug ospf lsa (generate|flooding|install|refresh). */
// if (IS_CONF_DEBUG_OSPF (lsa, LSA) == OSPF_DEBUG_LSA)
// vty_out (vty, "debug ospf lsa%s", VTY_NEWLINE);
// else
// {
// if (IS_CONF_DEBUG_OSPF (lsa, LSA_GENERATE))
// vty_out (vty, "debug ospf lsa generate%s", VTY_NEWLINE);
// if (IS_CONF_DEBUG_OSPF (lsa, LSA_FLOODING))
// vty_out (vty, "debug ospf lsa flooding%s", VTY_NEWLINE);
// if (IS_CONF_DEBUG_OSPF (lsa, LSA_INSTALL))
// vty_out (vty, "debug ospf lsa install%s", VTY_NEWLINE);
// if (IS_CONF_DEBUG_OSPF (lsa, LSA_REFRESH))
// vty_out (vty, "debug ospf lsa refresh%s", VTY_NEWLINE);
//
// write = 1;
// }
//
// /* debug ospf zebra (interface|redistribute). */
// if (IS_CONF_DEBUG_OSPF (zebra, ZEBRA) == OSPF_DEBUG_ZEBRA)
// vty_out (vty, "debug ospf zebra%s", VTY_NEWLINE);
// else
// {
// if (IS_CONF_DEBUG_OSPF (zebra, ZEBRA_INTERFACE))
// vty_out (vty, "debug ospf zebra interface%s", VTY_NEWLINE);
// if (IS_CONF_DEBUG_OSPF (zebra, ZEBRA_REDISTRIBUTE))
// vty_out (vty, "debug ospf zebra redistribute%s", VTY_NEWLINE);
//
// write = 1;
// }
//
// /* debug ospf event. */
// if (IS_CONF_DEBUG_OSPF (event, EVENT) == OSPF_DEBUG_EVENT)
// {
// vty_out (vty, "debug ospf event%s", VTY_NEWLINE);
// write = 1;
// }
//
// /* debug ospf nssa. */
// if (IS_CONF_DEBUG_OSPF (nssa, NSSA) == OSPF_DEBUG_NSSA)
// {
// vty_out (vty, "debug ospf nssa%s", VTY_NEWLINE);
// write = 1;
// }
//
// /* debug ospf packet all detail. */
// r = OSPF_DEBUG_SEND_RECV|OSPF_DEBUG_DETAIL;
// for (i = 0; i < 5; i++)
// r &= conf_debug_ospf_packet[i] & (OSPF_DEBUG_SEND_RECV|OSPF_DEBUG_DETAIL);
// if (r == (OSPF_DEBUG_SEND_RECV|OSPF_DEBUG_DETAIL))
// {
// vty_out (vty, "debug ospf packet all detail%s", VTY_NEWLINE);
// return 1;
// }
//
// /* debug ospf packet all. */
// r = OSPF_DEBUG_SEND_RECV;
// for (i = 0; i < 5; i++)
// r &= conf_debug_ospf_packet[i] & OSPF_DEBUG_SEND_RECV;
// if (r == OSPF_DEBUG_SEND_RECV)
// {
// vty_out (vty, "debug ospf packet all%s", VTY_NEWLINE);
// for (i = 0; i < 5; i++)
// if (conf_debug_ospf_packet[i] & OSPF_DEBUG_DETAIL)
// vty_out (vty, "debug ospf packet %s detail%s",
// type_str[i],
// VTY_NEWLINE);
// return 1;
// }
//
// /* debug ospf packet (hello|dd|ls-request|ls-update|ls-ack)
// (send|recv) (detail). */
// for (i = 0; i < 5; i++)
// {
// if (conf_debug_ospf_packet[i] == 0)
// continue;
//
// vty_out (vty, "debug ospf packet %s%s%s",
// type_str[i], detail_str[conf_debug_ospf_packet[i]],
// VTY_NEWLINE);
// write = 1;
// }
return write;
}
static int
eigrp_neighbor_packet_queue_sum (struct eigrp_interface *ei)
{
@ -282,14 +137,14 @@ void
eigrp_header_dump (struct eigrp_header *eigrph)
{
/* EIGRP Header dump. */
zlog_debug ("eigrp_version %u", eigrph->version);
zlog_debug ("eigrp_opcode %u", eigrph->opcode);
zlog_debug ("eigrp_checksum 0x%x", ntohs(eigrph->checksum));
zlog_debug ("eigrp_flags 0x%x", ntohl(eigrph->flags));
zlog_debug ("eigrp_sequence %u", ntohl(eigrph->sequence));
zlog_debug ("eigrp_ack %u", ntohl(eigrph->ack));
zlog_debug ("eigrp_vrid %u" , ntohs(eigrph->vrid));
zlog_debug ("eigrp_AS %u", ntohs(eigrph->ASNumber));
zlog_debug ("eigrp_version %u", eigrph->version);
zlog_debug ("eigrp_opcode %u", eigrph->opcode);
zlog_debug ("eigrp_checksum 0x%x", ntohs(eigrph->checksum));
zlog_debug ("eigrp_flags 0x%x", ntohl(eigrph->flags));
zlog_debug ("eigrp_sequence %u", ntohl(eigrph->sequence));
zlog_debug ("eigrp_ack %u", ntohl(eigrph->ack));
zlog_debug ("eigrp_vrid %u", ntohs(eigrph->vrid));
zlog_debug ("eigrp_AS %u", ntohs(eigrph->ASNumber));
}
const char *
@ -368,28 +223,37 @@ show_ip_eigrp_interface_header (struct vty *vty, struct eigrp *eigrp)
void
show_ip_eigrp_interface_sub (struct vty *vty, struct eigrp *eigrp,
struct eigrp_interface *ei)
struct eigrp_interface *ei)
{
vty_out (vty, "%-11s ", eigrp_if_name_string (ei));
vty_out (vty, "%-11u",IF_DEF_PARAMS (ei->ifp)->bandwidth);
vty_out (vty, "%-11u",IF_DEF_PARAMS (ei->ifp)->delay);
vty_out (vty, "%-11u", IF_DEF_PARAMS (ei->ifp)->bandwidth);
vty_out (vty, "%-11u", IF_DEF_PARAMS (ei->ifp)->delay);
vty_out (vty, "%-7u", ei->nbrs->count);
vty_out (vty, "%u %c %-10u",0,'/',eigrp_neighbor_packet_queue_sum (ei));
vty_out (vty, "%-7u %-14u %-12u %-8u",0,0,0,0);
vty_out (vty, "%-8u %-8u %s",IF_DEF_PARAMS (ei->ifp)->v_hello,IF_DEF_PARAMS (ei->ifp)->v_wait,VTY_NEWLINE);
vty_out (vty, "%u %c %-10u",0,'/', eigrp_neighbor_packet_queue_sum (ei));
vty_out (vty, "%-7u %-14u %-12u %-8u", 0, 0, 0, 0);
vty_out (vty, "%-8u %-8u %s",
IF_DEF_PARAMS (ei->ifp)->v_hello,
IF_DEF_PARAMS (ei->ifp)->v_wait,VTY_NEWLINE);
}
void
show_ip_eigrp_interface_detail (struct vty *vty, struct eigrp *eigrp,
struct eigrp_interface *ei)
struct eigrp_interface *ei)
{
vty_out (vty, "%-2s %s %d %-3s %s","","Hello interval is ",0," sec",VTY_NEWLINE);
vty_out (vty, "%-2s %s %s %s","","Next xmit serial","<none>",VTY_NEWLINE);
vty_out (vty, "%-2s %s %d %s %d %s %d %s %d %s","","Un/reliable mcasts: ",0,"/",0,"Un/reliable ucasts: ",0,"/",0,VTY_NEWLINE);
vty_out (vty, "%-2s %s %d %s %d %s %d %s","","Mcast exceptions: ",0," CR packets: ",0," ACKs supressed: ",0,VTY_NEWLINE);
vty_out (vty, "%-2s %s %d %s %d %s","","Retransmissions sent: ",0,"Out-of-sequence rcvd: ",0,VTY_NEWLINE);
vty_out (vty, "%-2s %s %s %s %s","","Authentication mode is ","not","set",VTY_NEWLINE);
vty_out (vty, "%-2s %s %s","","Use multicast",VTY_NEWLINE);
vty_out (vty, "%-2s %s %d %-3s %s","","Hello interval is ", 0, " sec", VTY_NEWLINE);
vty_out (vty, "%-2s %s %s %s","", "Next xmit serial","<none>", VTY_NEWLINE);
vty_out (vty, "%-2s %s %d %s %d %s %d %s %d %s",
"", "Un/reliable mcasts: ", 0, "/", 0, "Un/reliable ucasts: ",
0, "/", 0, VTY_NEWLINE);
vty_out (vty, "%-2s %s %d %s %d %s %d %s",
"", "Mcast exceptions: ", 0, " CR packets: ",
0, " ACKs supressed: ", 0, VTY_NEWLINE);
vty_out (vty, "%-2s %s %d %s %d %s",
"", "Retransmissions sent: ", 0, "Out-of-sequence rcvd: ",
0 ,VTY_NEWLINE);
vty_out (vty, "%-2s %s %s %s %s",
"", "Authentication mode is ", "not","set", VTY_NEWLINE);
vty_out (vty, "%-2s %s %s", "", "Use multicast", VTY_NEWLINE);
}
void
@ -405,23 +269,24 @@ show_ip_eigrp_neighbor_header (struct vty *vty, struct eigrp *eigrp)
void
show_ip_eigrp_neighbor_sub (struct vty *vty, struct eigrp_neighbor *nbr,
int detail)
int detail)
{
vty_out (vty, "%-3u %-17s %-21s",0,eigrp_neigh_ip_string (nbr),eigrp_if_name_string (nbr->ei));
vty_out (vty,"%-7lu",thread_timer_remain_second (nbr->t_holddown));
vty_out (vty,"%-8u %-6u %-5u",0,0,EIGRP_PACKET_RETRANS_TIME);
vty_out (vty,"%-7lu",nbr->retrans_queue->count);
vty_out (vty,"%u%s",nbr->recv_sequence_number,VTY_NEWLINE);
vty_out (vty, "%-3u %-17s %-21s", 0,
eigrp_neigh_ip_string (nbr), eigrp_if_name_string (nbr->ei));
vty_out (vty,"%-7lu", thread_timer_remain_second (nbr->t_holddown));
vty_out (vty,"%-8u %-6u %-5u", 0, 0, EIGRP_PACKET_RETRANS_TIME);
vty_out (vty,"%-7lu", nbr->retrans_queue->count);
vty_out (vty,"%u%s", nbr->recv_sequence_number, VTY_NEWLINE);
if (detail)
{
vty_out(vty," Version %u.%u/%u.%u",
nbr->os_rel_major, nbr->os_rel_minor,
nbr->tlv_rel_major, nbr->tlv_rel_minor);
nbr->os_rel_major, nbr->os_rel_minor,
nbr->tlv_rel_major, nbr->tlv_rel_minor);
vty_out(vty,", Retrans: %lu, Retries: %lu",
nbr->retrans_queue->count, 0UL);
nbr->retrans_queue->count, 0UL);
vty_out(vty,", %s%s", eigrp_nbr_state_str(nbr), VTY_NEWLINE);
}
}
@ -449,17 +314,20 @@ show_ip_eigrp_prefix_entry (struct vty *vty, struct eigrp_prefix_entry *tn)
vty_out (vty, "%s/%u, ",inet_ntoa (tn->destination_ipv4->prefix),tn->destination_ipv4->prefixlen);
vty_out (vty, "%u successors, ",eigrp_topology_get_successor(tn)->count);
vty_out (vty, "FD is %u, serno: %lu %s",tn->fdistance, tn->serno, VTY_NEWLINE);
}
void
show_ip_eigrp_neighbor_entry (struct vty *vty, struct eigrp *eigrp, struct eigrp_neighbor_entry *te)
{
if (te->adv_router == eigrp->neighbor_self)
vty_out (vty, "%-7s%s, %s%s"," ","via Connected",eigrp_if_name_string (te->ei), VTY_NEWLINE);
vty_out (vty, "%-7s%s, %s%s", " ", "via Connected",
eigrp_if_name_string (te->ei), VTY_NEWLINE);
else
{
vty_out (vty, "%-7s%s%s (%u/%u), %s%s"," ","via ",inet_ntoa (te->adv_router->src),te->distance, te->reported_distance, eigrp_if_name_string (te->ei), VTY_NEWLINE);
vty_out (vty, "%-7s%s%s (%u/%u), %s%s",
" ", "via ", inet_ntoa (te->adv_router->src),
te->distance, te->reported_distance,
eigrp_if_name_string (te->ei), VTY_NEWLINE);
}
}
@ -481,39 +349,39 @@ DEFUN (show_debugging_eigrp,
/* Show debug status for EIGRP Packets. */
for (i = 0; i < 11 ; i++)
{
{
if (i == 8)
continue;
if (IS_DEBUG_EIGRP_PACKET (i, SEND) && IS_DEBUG_EIGRP_PACKET (i, RECV))
{
vty_out (vty, " EIGRP packet %s%s debugging is on%s",
LOOKUP (eigrp_packet_type_str, i + 1),
IS_DEBUG_EIGRP_PACKET (i, PACKET_DETAIL) ? " detail" : "",
VTY_NEWLINE);
}
else
{
if (IS_DEBUG_EIGRP_PACKET (i, SEND))
vty_out (vty, " EIGRP packet %s send%s debugging is on%s",
LOOKUP (eigrp_packet_type_str, i + 1),
IS_DEBUG_EIGRP_PACKET (i, PACKET_DETAIL) ? " detail" : "",
VTY_NEWLINE);
if (IS_DEBUG_EIGRP_PACKET (i, RECV))
vty_out (vty, " EIGRP packet %s receive%s debugging is on%s",
LOOKUP (eigrp_packet_type_str, i + 1),
IS_DEBUG_EIGRP_PACKET (i, PACKET_DETAIL) ? " detail" : "",
VTY_NEWLINE);
}
}
if (IS_DEBUG_EIGRP_PACKET (i, SEND) && IS_DEBUG_EIGRP_PACKET (i, RECV))
{
vty_out (vty, " EIGRP packet %s%s debugging is on%s",
LOOKUP (eigrp_packet_type_str, i + 1),
IS_DEBUG_EIGRP_PACKET (i, PACKET_DETAIL) ? " detail" : "",
VTY_NEWLINE);
}
else
{
if (IS_DEBUG_EIGRP_PACKET (i, SEND))
vty_out (vty, " EIGRP packet %s send%s debugging is on%s",
LOOKUP (eigrp_packet_type_str, i + 1),
IS_DEBUG_EIGRP_PACKET (i, PACKET_DETAIL) ? " detail" : "",
VTY_NEWLINE);
if (IS_DEBUG_EIGRP_PACKET (i, RECV))
vty_out (vty, " EIGRP packet %s receive%s debugging is on%s",
LOOKUP (eigrp_packet_type_str, i + 1),
IS_DEBUG_EIGRP_PACKET (i, PACKET_DETAIL) ? " detail" : "",
VTY_NEWLINE);
}
}
return CMD_SUCCESS;
}
/*
[no] debug eigrp packet (hello|dd|ls-request|ls-update|ls-ack|all)
[send|recv [detail]]
[no] debug eigrp packet (hello|dd|ls-request|ls-update|ls-ack|all)
[send|recv [detail]]
*/
DEFUN (debug_eigrp_transmit,

317
eigrpd/eigrp_filter.c
View File

@ -79,111 +79,111 @@ eigrp_distribute_update (struct distribute *dist)
/* Check if distribute-list was set for process or interface */
if (! dist->ifname)
{
/* access list IN for whole process */
if (dist->list[DISTRIBUTE_V4_IN])
{
alist = access_list_lookup (AFI_IP, dist->list[DISTRIBUTE_V4_IN]);
zlog_info("<DEBUG DISTRIBUTE ACL IN FOUND: %s",alist->name);
if (alist)
e->list[EIGRP_FILTER_IN] = alist;
else
e->list[EIGRP_FILTER_IN] = NULL;
}
else
{
e->list[EIGRP_FILTER_IN] = NULL;
}
/* access list IN for whole process */
if (dist->list[DISTRIBUTE_V4_IN])
{
alist = access_list_lookup (AFI_IP, dist->list[DISTRIBUTE_V4_IN]);
zlog_info("<DEBUG DISTRIBUTE ACL IN FOUND: %s",alist->name);
if (alist)
e->list[EIGRP_FILTER_IN] = alist;
else
e->list[EIGRP_FILTER_IN] = NULL;
}
else
{
e->list[EIGRP_FILTER_IN] = NULL;
}
/* access list OUT for whole process */
if (dist->list[DISTRIBUTE_V4_OUT])
{
zlog_info("<DEBUG DISTRIBUTE ACL OUT FOUND: %s",dist->list[DISTRIBUTE_V4_OUT]);
alist = access_list_lookup (AFI_IP, dist->list[DISTRIBUTE_V4_OUT]);
if (alist)
e->list[EIGRP_FILTER_OUT] = alist;
else
e->list[EIGRP_FILTER_OUT] = NULL;
}
else
{
e->list[EIGRP_FILTER_OUT] = NULL;
}
/* access list OUT for whole process */
if (dist->list[DISTRIBUTE_V4_OUT])
{
zlog_info("<DEBUG DISTRIBUTE ACL OUT FOUND: %s",dist->list[DISTRIBUTE_V4_OUT]);
alist = access_list_lookup (AFI_IP, dist->list[DISTRIBUTE_V4_OUT]);
if (alist)
e->list[EIGRP_FILTER_OUT] = alist;
else
e->list[EIGRP_FILTER_OUT] = NULL;
}
else
{
e->list[EIGRP_FILTER_OUT] = NULL;
}
/* PREFIX_LIST IN for process */
if (dist->prefix[DISTRIBUTE_V4_IN])
{
zlog_info("<DEBUG DISTRIBUTE PREFIX IN FOUND: %s",dist->prefix[DISTRIBUTE_V4_IN]);
plist = prefix_list_lookup (AFI_IP, dist->prefix[DISTRIBUTE_V4_IN]);
if (plist)
{
e->prefix[EIGRP_FILTER_IN] = plist;
}
else
e->prefix[EIGRP_FILTER_IN] = NULL;
} else
e->prefix[EIGRP_FILTER_IN] = NULL;
/* PREFIX_LIST IN for process */
if (dist->prefix[DISTRIBUTE_V4_IN])
{
zlog_info("<DEBUG DISTRIBUTE PREFIX IN FOUND: %s",dist->prefix[DISTRIBUTE_V4_IN]);
plist = prefix_list_lookup (AFI_IP, dist->prefix[DISTRIBUTE_V4_IN]);
if (plist)
{
e->prefix[EIGRP_FILTER_IN] = plist;
}
else
e->prefix[EIGRP_FILTER_IN] = NULL;
} else
e->prefix[EIGRP_FILTER_IN] = NULL;
/* PREFIX_LIST OUT for process */
if (dist->prefix[DISTRIBUTE_V4_OUT])
{
zlog_info("<DEBUG DISTRIBUTE PREFIX OUT FOUND: %s",dist->prefix[DISTRIBUTE_V4_OUT]);
plist = prefix_list_lookup (AFI_IP, dist->prefix[DISTRIBUTE_V4_OUT]);
if (plist)
{
e->prefix[EIGRP_FILTER_OUT] = plist;
/* PREFIX_LIST OUT for process */
if (dist->prefix[DISTRIBUTE_V4_OUT])
{
zlog_info("<DEBUG DISTRIBUTE PREFIX OUT FOUND: %s",dist->prefix[DISTRIBUTE_V4_OUT]);
plist = prefix_list_lookup (AFI_IP, dist->prefix[DISTRIBUTE_V4_OUT]);
if (plist)
{
e->prefix[EIGRP_FILTER_OUT] = plist;
}
else
e->prefix[EIGRP_FILTER_OUT] = NULL;
}
else
e->prefix[EIGRP_FILTER_OUT] = NULL;
}
else
e->prefix[EIGRP_FILTER_OUT] = NULL;
}
else
e->prefix[EIGRP_FILTER_OUT] = NULL;
//This is commented out, because the distribute.[ch] code
//changes looked poorly written from first glance
//commit was 133bdf2d
//TODO: DBS
//This is commented out, because the distribute.[ch] code
//changes looked poorly written from first glance
//commit was 133bdf2d
//TODO: DBS
#if 0
/* route-map IN for whole process */
if (dist->route[DISTRIBUTE_V4_IN])
{
routemap = route_map_lookup_by_name (dist->route[DISTRIBUTE_V4_IN]);
if (routemap)
e->routemap[EIGRP_FILTER_IN] = routemap;
else
e->routemap[EIGRP_FILTER_IN] = NULL;
}
else
{
e->routemap[EIGRP_FILTER_IN] = NULL;
}
/* route-map IN for whole process */
if (dist->route[DISTRIBUTE_V4_IN])
{
routemap = route_map_lookup_by_name (dist->route[DISTRIBUTE_V4_IN]);
if (routemap)
e->routemap[EIGRP_FILTER_IN] = routemap;
else
e->routemap[EIGRP_FILTER_IN] = NULL;
}
else
{
e->routemap[EIGRP_FILTER_IN] = NULL;
}
/* route-map OUT for whole process */
if (dist->route[DISTRIBUTE_V4_OUT])
{
routemap = route_map_lookup_by_name (dist->route[DISTRIBUTE_V4_OUT]);
if (routemap)
e->routemap[EIGRP_FILTER_OUT] = routemap;
else
e->routemap[EIGRP_FILTER_OUT] = NULL;
}
else
{
e->routemap[EIGRP_FILTER_OUT] = NULL;
}
/* route-map OUT for whole process */
if (dist->route[DISTRIBUTE_V4_OUT])
{
routemap = route_map_lookup_by_name (dist->route[DISTRIBUTE_V4_OUT]);
if (routemap)
e->routemap[EIGRP_FILTER_OUT] = routemap;
else
e->routemap[EIGRP_FILTER_OUT] = NULL;
}
else
{
e->routemap[EIGRP_FILTER_OUT] = NULL;
}
#endif
//TODO: check Graceful restart after 10sec
//TODO: check Graceful restart after 10sec
/* check if there is already GR scheduled */
if(e->t_distribute != NULL)
{
/* if is, cancel schedule */
thread_cancel(e->t_distribute);
}
/* schedule Graceful restart for whole process in 10sec */
e->t_distribute = thread_add_timer(master, eigrp_distribute_timer_process, e,(10));
/* check if there is already GR scheduled */
if(e->t_distribute != NULL)
{
/* if is, cancel schedule */
thread_cancel(e->t_distribute);
}
/* schedule Graceful restart for whole process in 10sec */
e->t_distribute = thread_add_timer(master, eigrp_distribute_timer_process, e,(10));
return;
return;
}
ifp = if_lookup_by_name (dist->ifname, VRF_DEFAULT);
@ -199,27 +199,27 @@ eigrp_distribute_update (struct distribute *dist)
/* Find proper interface */
for (ALL_LIST_ELEMENTS (e->eiflist, node, nnode, ei2))
{
if(strcmp(ei2->ifp->name,ifp->name) == 0){
ei = ei2;
break;
}
if(strcmp(ei2->ifp->name,ifp->name) == 0){
ei = ei2;
break;
}
}
if(ei == NULL)
{
zlog_info("Not Found eigrp interface %s",ifp->name);
}
{
zlog_info("Not Found eigrp interface %s",ifp->name);
}
/* Access-list for interface in */
if (dist->list[DISTRIBUTE_V4_IN])
{
zlog_info("<DEBUG ACL in");
zlog_info("<DEBUG ACL in");
alist = access_list_lookup (AFI_IP, dist->list[DISTRIBUTE_V4_IN]);
if (alist){
ei->list[EIGRP_FILTER_IN] = alist;
}
else
ei->list[EIGRP_FILTER_IN] = NULL;
ei->list[EIGRP_FILTER_IN] = NULL;
}
else
{
@ -231,25 +231,25 @@ eigrp_distribute_update (struct distribute *dist)
{
alist = access_list_lookup (AFI_IP, dist->list[DISTRIBUTE_V4_OUT]);
if (alist)
ei->list[EIGRP_FILTER_OUT] = alist;
ei->list[EIGRP_FILTER_OUT] = alist;
else
ei->list[EIGRP_FILTER_OUT] = NULL;
ei->list[EIGRP_FILTER_OUT] = NULL;
}
else
{
ei->list[EIGRP_FILTER_OUT] = NULL;
zlog_info("<DEBUG ACL out else");
}
{
ei->list[EIGRP_FILTER_OUT] = NULL;
zlog_info("<DEBUG ACL out else");
}
/* Prefix-list for interface in */
if (dist->prefix[DISTRIBUTE_V4_IN])
{
plist = prefix_list_lookup (AFI_IP, dist->prefix[DISTRIBUTE_V4_IN]);
if (plist)
ei->prefix[EIGRP_FILTER_IN] = plist;
ei->prefix[EIGRP_FILTER_IN] = plist;
else
ei->prefix[EIGRP_FILTER_IN] = NULL;
ei->prefix[EIGRP_FILTER_IN] = NULL;
}
else
ei->prefix[EIGRP_FILTER_IN] = NULL;
@ -259,9 +259,9 @@ eigrp_distribute_update (struct distribute *dist)
{
plist = prefix_list_lookup (AFI_IP, dist->prefix[DISTRIBUTE_V4_OUT]);
if (plist)
ei->prefix[EIGRP_FILTER_OUT] = plist;
ei->prefix[EIGRP_FILTER_OUT] = plist;
else
ei->prefix[EIGRP_FILTER_OUT] = NULL;
ei->prefix[EIGRP_FILTER_OUT] = NULL;
}
else
ei->prefix[EIGRP_FILTER_OUT] = NULL;
@ -269,44 +269,43 @@ eigrp_distribute_update (struct distribute *dist)
#if 0
/* route-map IN for whole process */
if (dist->route[DISTRIBUTE_V4_IN])
{
zlog_info("<DEBUG ACL ALL in");
routemap = route_map_lookup_by_name (dist->route[DISTRIBUTE_V4_IN]);
if (routemap)
ei->routemap[EIGRP_FILTER_IN] = routemap;
else
ei->routemap[EIGRP_FILTER_IN] = NULL;
}
{
zlog_info("<DEBUG ACL ALL in");
routemap = route_map_lookup_by_name (dist->route[DISTRIBUTE_V4_IN]);
if (routemap)
ei->routemap[EIGRP_FILTER_IN] = routemap;
else
ei->routemap[EIGRP_FILTER_IN] = NULL;
}
else
{
ei->routemap[EIGRP_FILTER_IN] = NULL;
}
{
ei->routemap[EIGRP_FILTER_IN] = NULL;
}
/* route-map OUT for whole process */
if (dist->route[DISTRIBUTE_V4_OUT])
{
routemap = route_map_lookup_by_name (dist->route[DISTRIBUTE_V4_OUT]);
if (routemap)
ei->routemap[EIGRP_FILTER_OUT] = routemap;
else
ei->routemap[EIGRP_FILTER_OUT] = NULL;
}
{
routemap = route_map_lookup_by_name (dist->route[DISTRIBUTE_V4_OUT]);
if (routemap)
ei->routemap[EIGRP_FILTER_OUT] = routemap;
else
ei->routemap[EIGRP_FILTER_OUT] = NULL;
}
else
{
ei->routemap[EIGRP_FILTER_OUT] = NULL;
}
{
ei->routemap[EIGRP_FILTER_OUT] = NULL;
}
#endif
//TODO: check Graceful restart after 10sec
/* check if there is already GR scheduled */
if(ei->t_distribute != NULL)
{
/* if is, cancel schedule */
thread_cancel(ei->t_distribute);
}
{
/* if is, cancel schedule */
thread_cancel(ei->t_distribute);
}
/* schedule Graceful restart for interface in 10sec */
e->t_distribute = thread_add_timer(master, eigrp_distribute_timer_interface, ei,(10));
e->t_distribute = thread_add_timer(master, eigrp_distribute_timer_interface, ei, 10);
}
/*
@ -341,15 +340,15 @@ eigrp_distribute_update_all (struct prefix_list *notused)
void
eigrp_distribute_update_all_wrapper(struct access_list *notused)
{
eigrp_distribute_update_all(NULL);
eigrp_distribute_update_all(NULL);
}
/*
* @fn eigrp_distribute_timer_process
*
* @param[in] thread current execution thread timer is associated with
* @param[in] thread current execution thread timer is associated with
*
* @return int always returns 0
* @return int always returns 0
*
* @par
* Called when 10sec waiting time expire and
@ -358,23 +357,23 @@ eigrp_distribute_update_all_wrapper(struct access_list *notused)
int
eigrp_distribute_timer_process (struct thread *thread)
{
struct eigrp *eigrp;
struct eigrp *eigrp;
eigrp = THREAD_ARG(thread);
eigrp->t_distribute = NULL;
eigrp = THREAD_ARG(thread);
eigrp->t_distribute = NULL;
/* execute GR for whole process */
eigrp_update_send_process_GR(eigrp, EIGRP_GR_FILTER, NULL);
/* execute GR for whole process */
eigrp_update_send_process_GR(eigrp, EIGRP_GR_FILTER, NULL);
return 0;
return 0;
}
/*
* @fn eigrp_distribute_timer_interface
*
* @param[in] thread current execution thread timer is associated with
* @param[in] thread current execution thread timer is associated with
*
* @return int always returns 0
* @return int always returns 0
*
* @par
* Called when 10sec waiting time expire and
@ -383,13 +382,13 @@ eigrp_distribute_timer_process (struct thread *thread)
int
eigrp_distribute_timer_interface (struct thread *thread)
{
struct eigrp_interface *ei;
struct eigrp_interface *ei;
ei = THREAD_ARG(thread);
ei->t_distribute = NULL;
ei = THREAD_ARG(thread);
ei->t_distribute = NULL;
/* execute GR for interface */
eigrp_update_send_interface_GR(ei, EIGRP_GR_FILTER, NULL);
/* execute GR for interface */
eigrp_update_send_interface_GR(ei, EIGRP_GR_FILTER, NULL);
return 0;
return 0;
}

740
eigrpd/eigrp_fsm.c
View File

@ -93,22 +93,14 @@
/*
* Prototypes
*/
int
eigrp_fsm_event_keep_state(struct eigrp_fsm_action_message *);
int
eigrp_fsm_event_nq_fcn(struct eigrp_fsm_action_message *);
int
eigrp_fsm_event_q_fcn(struct eigrp_fsm_action_message *);
int
eigrp_fsm_event_lr(struct eigrp_fsm_action_message *);
int
eigrp_fsm_event_dinc(struct eigrp_fsm_action_message *);
int
eigrp_fsm_event_lr_fcs(struct eigrp_fsm_action_message *);
int
eigrp_fsm_event_lr_fcn(struct eigrp_fsm_action_message *);
int
eigrp_fsm_event_qact(struct eigrp_fsm_action_message *);
int eigrp_fsm_event_keep_state(struct eigrp_fsm_action_message *);
int eigrp_fsm_event_nq_fcn(struct eigrp_fsm_action_message *);
int eigrp_fsm_event_q_fcn(struct eigrp_fsm_action_message *);
int eigrp_fsm_event_lr(struct eigrp_fsm_action_message *);
int eigrp_fsm_event_dinc(struct eigrp_fsm_action_message *);
int eigrp_fsm_event_lr_fcs(struct eigrp_fsm_action_message *);
int eigrp_fsm_event_lr_fcn(struct eigrp_fsm_action_message *);
int eigrp_fsm_event_qact(struct eigrp_fsm_action_message *);
//---------------------------------------------------------------------
@ -120,59 +112,58 @@ eigrp_fsm_event_qact(struct eigrp_fsm_action_message *);
* Functions are should be executed within separate thread.
*/
struct {
int
(*func)(struct eigrp_fsm_action_message *);
int
(*func)(struct eigrp_fsm_action_message *);
} NSM[EIGRP_FSM_STATE_MAX][EIGRP_FSM_EVENT_MAX] = { {
//PASSIVE STATE
{ eigrp_fsm_event_nq_fcn }, /* Event 0 */
{ eigrp_fsm_event_keep_state }, /* Event 1 */
{ eigrp_fsm_event_q_fcn }, /* Event 2 */
{ eigrp_fsm_event_keep_state }, /* Event 3 */
{ eigrp_fsm_event_keep_state }, /* Event 4 */
{ eigrp_fsm_event_keep_state }, /* Event 5 */
{ eigrp_fsm_event_keep_state }, /* Event 6 */
{ eigrp_fsm_event_keep_state }, /* Event 7 */
}, {
//Active 0 state
{ eigrp_fsm_event_keep_state }, /* Event 0 */
{ eigrp_fsm_event_keep_state }, /* Event 1 */
{ eigrp_fsm_event_keep_state }, /* Event 2 */
{ eigrp_fsm_event_lr_fcs }, /* Event 3 */
{ eigrp_fsm_event_keep_state }, /* Event 4 */
{ eigrp_fsm_event_qact }, /* Event 5 */
{ eigrp_fsm_event_lr_fcn }, /* Event 6 */
{ eigrp_fsm_event_keep_state }, /* Event 7 */
}, {
//Active 1 state
{ eigrp_fsm_event_keep_state }, /* Event 0 */
{ eigrp_fsm_event_lr }, /* Event 1 */
{ eigrp_fsm_event_keep_state }, /* Event 2 */
{ eigrp_fsm_event_keep_state }, /* Event 3 */
{ eigrp_fsm_event_dinc }, /* Event 4 */
{ eigrp_fsm_event_qact }, /* Event 5 */
{ eigrp_fsm_event_keep_state }, /* Event 6 */
{ eigrp_fsm_event_keep_state }, /* Event 7 */
}, {
//Active 2 state
{ eigrp_fsm_event_keep_state }, /* Event 0 */
{ eigrp_fsm_event_keep_state }, /* Event 1 */
{ eigrp_fsm_event_keep_state }, /* Event 2 */
{ eigrp_fsm_event_lr_fcs }, /* Event 3 */
{ eigrp_fsm_event_keep_state }, /* Event 4 */
{ eigrp_fsm_event_keep_state }, /* Event 5 */
{ eigrp_fsm_event_lr_fcn }, /* Event 6 */
{ eigrp_fsm_event_keep_state }, /* Event 7 */
}, {
//Active 3 state
{ eigrp_fsm_event_keep_state }, /* Event 0 */
{ eigrp_fsm_event_lr }, /* Event 1 */
{ eigrp_fsm_event_keep_state }, /* Event 2 */
{ eigrp_fsm_event_keep_state }, /* Event 3 */
{ eigrp_fsm_event_dinc }, /* Event 4 */
{ eigrp_fsm_event_keep_state }, /* Event 5 */
{ eigrp_fsm_event_keep_state }, /* Event 6 */
{ eigrp_fsm_event_keep_state }, /* Event 7 */
//PASSIVE STATE
{ eigrp_fsm_event_nq_fcn }, /* Event 0 */
{ eigrp_fsm_event_keep_state }, /* Event 1 */
{ eigrp_fsm_event_q_fcn }, /* Event 2 */
{ eigrp_fsm_event_keep_state }, /* Event 3 */
{ eigrp_fsm_event_keep_state }, /* Event 4 */
{ eigrp_fsm_event_keep_state }, /* Event 5 */
{ eigrp_fsm_event_keep_state }, /* Event 6 */
{ eigrp_fsm_event_keep_state }, /* Event 7 */
}, {
//Active 0 state
{ eigrp_fsm_event_keep_state }, /* Event 0 */
{ eigrp_fsm_event_keep_state }, /* Event 1 */
{ eigrp_fsm_event_keep_state }, /* Event 2 */
{ eigrp_fsm_event_lr_fcs }, /* Event 3 */
{ eigrp_fsm_event_keep_state }, /* Event 4 */
{ eigrp_fsm_event_qact }, /* Event 5 */
{ eigrp_fsm_event_lr_fcn }, /* Event 6 */
{ eigrp_fsm_event_keep_state }, /* Event 7 */
}, {
//Active 1 state
{ eigrp_fsm_event_keep_state }, /* Event 0 */
{ eigrp_fsm_event_lr }, /* Event 1 */
{ eigrp_fsm_event_keep_state }, /* Event 2 */
{ eigrp_fsm_event_keep_state }, /* Event 3 */
{ eigrp_fsm_event_dinc }, /* Event 4 */
{ eigrp_fsm_event_qact }, /* Event 5 */
{ eigrp_fsm_event_keep_state }, /* Event 6 */
{ eigrp_fsm_event_keep_state }, /* Event 7 */
}, {
//Active 2 state
{ eigrp_fsm_event_keep_state }, /* Event 0 */
{ eigrp_fsm_event_keep_state }, /* Event 1 */
{ eigrp_fsm_event_keep_state }, /* Event 2 */
{ eigrp_fsm_event_lr_fcs }, /* Event 3 */
{ eigrp_fsm_event_keep_state }, /* Event 4 */
{ eigrp_fsm_event_keep_state }, /* Event 5 */
{ eigrp_fsm_event_lr_fcn }, /* Event 6 */
{ eigrp_fsm_event_keep_state }, /* Event 7 */
}, {
//Active 3 state
{ eigrp_fsm_event_keep_state }, /* Event 0 */
{ eigrp_fsm_event_lr }, /* Event 1 */
{ eigrp_fsm_event_keep_state }, /* Event 2 */
{ eigrp_fsm_event_keep_state }, /* Event 3 */
{ eigrp_fsm_event_dinc }, /* Event 4 */
{ eigrp_fsm_event_keep_state }, /* Event 5 */
{ eigrp_fsm_event_keep_state }, /* Event 6 */
{ eigrp_fsm_event_keep_state }, /* Event 7 */
}, };
/*
@ -183,353 +174,416 @@ struct {
* Return number of occurred event (arrow in diagram).
*
*/
int eigrp_get_fsm_event(struct eigrp_fsm_action_message *msg) {
// Loading base information from message
//struct eigrp *eigrp = msg->eigrp;
struct eigrp_prefix_entry *prefix = msg->prefix;
struct eigrp_neighbor_entry *entry = msg->entry;
u_char actual_state = prefix->state;
int eigrp_get_fsm_event(struct eigrp_fsm_action_message *msg)
{
// Loading base information from message
//struct eigrp *eigrp = msg->eigrp;
struct eigrp_prefix_entry *prefix = msg->prefix;
struct eigrp_neighbor_entry *entry = msg->entry;
u_char actual_state = prefix->state;
if (entry == NULL) {
entry = eigrp_neighbor_entry_new();
entry->adv_router = msg->adv_router;
entry->ei = msg->adv_router->ei;
entry->prefix = prefix;
msg->entry = entry;
}
if (entry == NULL)
{
entry = eigrp_neighbor_entry_new();
entry->adv_router = msg->adv_router;
entry->ei = msg->adv_router->ei;
entry->prefix = prefix;
msg->entry = entry;
}
// Dividing by actual state of prefix's FSM
switch (actual_state) {
case EIGRP_FSM_STATE_PASSIVE: {
//Calculate resultant metrics and insert to correct position in entries list
eigrp_topology_update_distance(msg);
// Dividing by actual state of prefix's FSM
switch (actual_state)
{
case EIGRP_FSM_STATE_PASSIVE:
{
//Calculate resultant metrics and insert to correct position in entries list
eigrp_topology_update_distance(msg);
struct eigrp_neighbor_entry * head =
(struct eigrp_neighbor_entry *) entry->prefix->entries->head->data;
//zlog_info ("flag: %d rdist: %u dist: %u pfdist: %u pdist: %u", head->flags, head->reported_distance, head->distance, prefix->fdistance, prefix->distance);
if (head->reported_distance < prefix->fdistance)
{
return EIGRP_FSM_KEEP_STATE;
}
/*
* if best entry doesn't satisfy feasibility condition it means move to active state
* dependently if it was query from successor
*/
else
{
if (msg->packet_type == EIGRP_OPC_QUERY)
{
return EIGRP_FSM_EVENT_Q_FCN;
}
else
{
return EIGRP_FSM_EVENT_NQ_FCN;
}
}
struct eigrp_neighbor_entry * head =
(struct eigrp_neighbor_entry *) entry->prefix->entries->head->data;
//zlog_info ("flag: %d rdist: %u dist: %u pfdist: %u pdist: %u", head->flags, head->reported_distance, head->distance, prefix->fdistance, prefix->distance);
if (head->reported_distance < prefix->fdistance) {
return EIGRP_FSM_KEEP_STATE;
}
/*
* if best entry doesn't satisfy feasibility condition it means move to active state
* dependently if it was query from successor
*/
else {
if (msg->packet_type == EIGRP_OPC_QUERY) {
return EIGRP_FSM_EVENT_Q_FCN;
} else {
return EIGRP_FSM_EVENT_NQ_FCN;
}
}
break;
}
case EIGRP_FSM_STATE_ACTIVE_0:
{
eigrp_topology_update_distance(msg);
break;
}
case EIGRP_FSM_STATE_ACTIVE_0: {
eigrp_topology_update_distance(msg);
if (msg->packet_type == EIGRP_OPC_REPLY) {
listnode_delete(prefix->rij, entry->adv_router);
if (prefix->rij->count)
{
return EIGRP_FSM_KEEP_STATE;
}
else
{
zlog_info("All reply received\n");
if (((struct eigrp_neighbor_entry *) prefix->entries->head->data)->reported_distance
< prefix->fdistance)
{
return EIGRP_FSM_EVENT_LR_FCS;
}
if (msg->packet_type == EIGRP_OPC_REPLY) {
listnode_delete(prefix->rij, entry->adv_router);
if (prefix->rij->count) {
return EIGRP_FSM_KEEP_STATE;
} else {
zlog_info("All reply received\n");
if (((struct eigrp_neighbor_entry *) prefix->entries->head->data)->reported_distance
< prefix->fdistance) {
return EIGRP_FSM_EVENT_LR_FCS;
}
return EIGRP_FSM_EVENT_LR_FCN;
}
}
else if (msg->packet_type == EIGRP_OPC_QUERY
&& (entry->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG))
{
return EIGRP_FSM_EVENT_QACT;
}
return EIGRP_FSM_EVENT_LR_FCN;
}
} else if (msg->packet_type == EIGRP_OPC_QUERY
&& (entry->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG)) {
return EIGRP_FSM_EVENT_QACT;
}
return EIGRP_FSM_KEEP_STATE;
return EIGRP_FSM_KEEP_STATE;
break;
}
case EIGRP_FSM_STATE_ACTIVE_1:
{
int change = eigrp_topology_update_distance(msg);
break;
}
case EIGRP_FSM_STATE_ACTIVE_1: {
int change = eigrp_topology_update_distance(msg);
if (msg->packet_type == EIGRP_OPC_QUERY
&& (entry->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG))
{
return EIGRP_FSM_EVENT_QACT;
}
else if (msg->packet_type == EIGRP_OPC_REPLY)
{
listnode_delete(prefix->rij, entry->adv_router);
if (msg->packet_type == EIGRP_OPC_QUERY
&& (entry->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG)) {
return EIGRP_FSM_EVENT_QACT;
} else if (msg->packet_type == EIGRP_OPC_REPLY) {
listnode_delete(prefix->rij, entry->adv_router);
if (change == 1
&& (entry->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG))
{
return EIGRP_FSM_EVENT_DINC;
}
else if (prefix->rij->count)
{
return EIGRP_FSM_KEEP_STATE;
}
else
{
zlog_info("All reply received\n");
return EIGRP_FSM_EVENT_LR;
}
}
else if (msg->packet_type == EIGRP_OPC_UPDATE && change == 1
&& (entry->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG))
{
return EIGRP_FSM_EVENT_DINC;
}
return EIGRP_FSM_KEEP_STATE;
if (change == 1
&& (entry->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG)) {
return EIGRP_FSM_EVENT_DINC;
} else if (prefix->rij->count) {
return EIGRP_FSM_KEEP_STATE;
} else {
zlog_info("All reply received\n");
return EIGRP_FSM_EVENT_LR;
}
} else if (msg->packet_type == EIGRP_OPC_UPDATE && change == 1
&& (entry->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG)) {
return EIGRP_FSM_EVENT_DINC;
}
return EIGRP_FSM_KEEP_STATE;
break;
}
case EIGRP_FSM_STATE_ACTIVE_2:
{
eigrp_topology_update_distance(msg);
break;
}
case EIGRP_FSM_STATE_ACTIVE_2: {
if (msg->packet_type == EIGRP_OPC_REPLY)
{
listnode_delete(prefix->rij, entry->adv_router);
if (prefix->rij->count)
{
return EIGRP_FSM_KEEP_STATE;
}
else
{
zlog_info("All reply received\n");
if (((struct eigrp_neighbor_entry *) prefix->entries->head->data)->reported_distance
< prefix->fdistance)
{
return EIGRP_FSM_EVENT_LR_FCS;
}
eigrp_topology_update_distance(msg);
return EIGRP_FSM_EVENT_LR_FCN;
}
}
return EIGRP_FSM_KEEP_STATE;
if (msg->packet_type == EIGRP_OPC_REPLY) {
listnode_delete(prefix->rij, entry->adv_router);
if (prefix->rij->count) {
return EIGRP_FSM_KEEP_STATE;
} else {
zlog_info("All reply received\n");
if (((struct eigrp_neighbor_entry *) prefix->entries->head->data)->reported_distance
< prefix->fdistance) {
return EIGRP_FSM_EVENT_LR_FCS;
}
break;
}
case EIGRP_FSM_STATE_ACTIVE_3:
{
int change = eigrp_topology_update_distance(msg);
return EIGRP_FSM_EVENT_LR_FCN;
}
}
return EIGRP_FSM_KEEP_STATE;
if (msg->packet_type == EIGRP_OPC_REPLY)
{
listnode_delete(prefix->rij, entry->adv_router);
break;
}
case EIGRP_FSM_STATE_ACTIVE_3: {
if (change == 1
&& (entry->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG))
{
return EIGRP_FSM_EVENT_DINC;
}
else if (prefix->rij->count)
{
return EIGRP_FSM_KEEP_STATE;
}
else
{
zlog_info("All reply received\n");
return EIGRP_FSM_EVENT_LR;
}
}
else if (msg->packet_type == EIGRP_OPC_UPDATE && change == 1
&& (entry->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG))
{
return EIGRP_FSM_EVENT_DINC;
}
return EIGRP_FSM_KEEP_STATE;
int change = eigrp_topology_update_distance(msg);
break;
}
}
if (msg->packet_type == EIGRP_OPC_REPLY) {
listnode_delete(prefix->rij, entry->adv_router);
if (change == 1
&& (entry->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG)) {
return EIGRP_FSM_EVENT_DINC;
} else if (prefix->rij->count) {
return EIGRP_FSM_KEEP_STATE;
} else {
zlog_info("All reply received\n");
return EIGRP_FSM_EVENT_LR;
}
} else if (msg->packet_type == EIGRP_OPC_UPDATE && change == 1
&& (entry->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG)) {
return EIGRP_FSM_EVENT_DINC;
}
return EIGRP_FSM_KEEP_STATE;
break;
}
}
return EIGRP_FSM_KEEP_STATE;
return EIGRP_FSM_KEEP_STATE;
}
/*
* Function made to execute in separate thread.
* Load argument from thread and execute proper NSM function
*/
int eigrp_fsm_event(struct eigrp_fsm_action_message *msg, int event) {
int eigrp_fsm_event(struct eigrp_fsm_action_message *msg, int event)
{
zlog_info("EIGRP AS: %d State: %d Event: %d Network: %s\n", msg->eigrp->AS,
msg->prefix->state, event, eigrp_topology_ip_string(msg->prefix));
(*(NSM[msg->prefix->state][event].func))(msg);
zlog_info("EIGRP AS: %d State: %d Event: %d Network: %s\n", msg->eigrp->AS,
msg->prefix->state, event, eigrp_topology_ip_string(msg->prefix));
(*(NSM[msg->prefix->state][event].func))(msg);
return 1;
return 1;
}
/*
* Function of event 0.
*
*/
int eigrp_fsm_event_nq_fcn(struct eigrp_fsm_action_message *msg) {
struct eigrp *eigrp = msg->eigrp;
struct eigrp_prefix_entry *prefix = msg->prefix;
struct list *successors = eigrp_topology_get_successor(prefix);
int eigrp_fsm_event_nq_fcn(struct eigrp_fsm_action_message *msg)
{
struct eigrp *eigrp = msg->eigrp;
struct eigrp_prefix_entry *prefix = msg->prefix;
struct list *successors = eigrp_topology_get_successor(prefix);
assert(successors); // If this is NULL we have shit the bed, fun huh?
assert(successors); // If this is NULL we have shit the bed, fun huh?
prefix->state = EIGRP_FSM_STATE_ACTIVE_1;
prefix->rdistance = prefix->distance = prefix->fdistance =
((struct eigrp_neighbor_entry *) successors->head->data)->distance;
prefix->reported_metric =
((struct eigrp_neighbor_entry *) successors->head->data)->total_metric;
prefix->state = EIGRP_FSM_STATE_ACTIVE_1;
prefix->rdistance = prefix->distance = prefix->fdistance =
((struct eigrp_neighbor_entry *) successors->head->data)->distance;
prefix->reported_metric =
((struct eigrp_neighbor_entry *) successors->head->data)->total_metric;
if (eigrp_nbr_count_get()) {
prefix->req_action |= EIGRP_FSM_NEED_QUERY;
listnode_add(eigrp->topology_changes_internalIPV4,prefix);
} else {
eigrp_fsm_event_lr(msg); //in the case that there are no more neighbors left
}
if (eigrp_nbr_count_get())
{
prefix->req_action |= EIGRP_FSM_NEED_QUERY;
listnode_add(eigrp->topology_changes_internalIPV4,prefix);
}
else
{
eigrp_fsm_event_lr(msg); //in the case that there are no more neighbors left
}
list_delete(successors);
list_delete(successors);
return 1;
return 1;
}
int eigrp_fsm_event_q_fcn(struct eigrp_fsm_action_message *msg) {
struct eigrp *eigrp = msg->eigrp;
struct eigrp_prefix_entry *prefix = msg->prefix;
struct list *successors = eigrp_topology_get_successor(prefix);
int eigrp_fsm_event_q_fcn(struct eigrp_fsm_action_message *msg)
{
struct eigrp *eigrp = msg->eigrp;
struct eigrp_prefix_entry *prefix = msg->prefix;
struct list *successors = eigrp_topology_get_successor(prefix);
assert(successors); // If this is NULL somebody poked us in the eye.
assert(successors); // If this is NULL somebody poked us in the eye.
prefix->state = EIGRP_FSM_STATE_ACTIVE_3;
prefix->rdistance = prefix->distance = prefix->fdistance =
((struct eigrp_neighbor_entry *) successors->head->data)->distance;
prefix->reported_metric =
((struct eigrp_neighbor_entry *) successors->head->data)->total_metric;
if (eigrp_nbr_count_get()) {
prefix->req_action |= EIGRP_FSM_NEED_QUERY;
listnode_add(eigrp->topology_changes_internalIPV4,prefix);
} else {
eigrp_fsm_event_lr(msg); //in the case that there are no more neighbors left
}
prefix->state = EIGRP_FSM_STATE_ACTIVE_3;
prefix->rdistance = prefix->distance = prefix->fdistance =
((struct eigrp_neighbor_entry *) successors->head->data)->distance;
prefix->reported_metric =
((struct eigrp_neighbor_entry *) successors->head->data)->total_metric;
if (eigrp_nbr_count_get())
{
prefix->req_action |= EIGRP_FSM_NEED_QUERY;
listnode_add(eigrp->topology_changes_internalIPV4,prefix);
}
else
{
eigrp_fsm_event_lr(msg); //in the case that there are no more neighbors left
}
list_delete(successors);
list_delete(successors);
return 1;
return 1;
}
int eigrp_fsm_event_keep_state(struct eigrp_fsm_action_message *msg) {
int eigrp_fsm_event_keep_state(struct eigrp_fsm_action_message *msg)
{
struct eigrp_prefix_entry *prefix = msg->prefix;
struct eigrp_prefix_entry *prefix = msg->prefix;
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, prefix);
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 (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, prefix);
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);
if (msg->packet_type == EIGRP_OPC_QUERY)
eigrp_send_reply(msg->adv_router, prefix);
return 1;
return 1;
}
int eigrp_fsm_event_lr(struct eigrp_fsm_action_message *msg) {
struct eigrp *eigrp = msg->eigrp;
struct eigrp_prefix_entry *prefix = msg->prefix;
prefix->fdistance =
prefix->distance =
prefix->rdistance =
((struct eigrp_neighbor_entry *) (prefix->entries->head->data))->distance;
prefix->reported_metric =
((struct eigrp_neighbor_entry *) (prefix->entries->head->data))->total_metric;
int eigrp_fsm_event_lr(struct eigrp_fsm_action_message *msg)
{
struct eigrp *eigrp = msg->eigrp;
struct eigrp_prefix_entry *prefix = msg->prefix;
prefix->fdistance =
prefix->distance =
prefix->rdistance =
((struct eigrp_neighbor_entry *) (prefix->entries->head->data))->distance;
prefix->reported_metric =
((struct eigrp_neighbor_entry *) (prefix->entries->head->data))->total_metric;
if (prefix->state == EIGRP_FSM_STATE_ACTIVE_3) {
struct list *successors = eigrp_topology_get_successor(prefix);
if (prefix->state == EIGRP_FSM_STATE_ACTIVE_3)
{
struct list *successors = eigrp_topology_get_successor(prefix);
assert(successors); // It's like Napolean and Waterloo
assert(successors); // It's like Napolean and Waterloo
eigrp_send_reply(((struct eigrp_neighbor_entry *)successors->head->data)->adv_router, prefix);
list_delete(successors);
}
eigrp_send_reply(((struct eigrp_neighbor_entry *)successors->head->data)->adv_router, prefix);
list_delete(successors);
}
prefix->state = EIGRP_FSM_STATE_PASSIVE;
prefix->req_action |= EIGRP_FSM_NEED_UPDATE;
listnode_add(eigrp->topology_changes_internalIPV4,prefix);
eigrp_topology_update_node_flags(prefix);
eigrp_update_routing_table(prefix);
eigrp_update_topology_table_prefix(eigrp->topology_table, prefix);
prefix->state = EIGRP_FSM_STATE_PASSIVE;
prefix->req_action |= EIGRP_FSM_NEED_UPDATE;
listnode_add(eigrp->topology_changes_internalIPV4,prefix);
eigrp_topology_update_node_flags(prefix);
eigrp_update_routing_table(prefix);
eigrp_update_topology_table_prefix(eigrp->topology_table, prefix);
return 1;
return 1;
}
int eigrp_fsm_event_dinc(struct eigrp_fsm_action_message *msg) {
struct list *successors = eigrp_topology_get_successor(msg->prefix);
int eigrp_fsm_event_dinc(struct eigrp_fsm_action_message *msg)
{
struct list *successors = eigrp_topology_get_successor(msg->prefix);
assert(successors); // Trump and his big hands
assert(successors); // Trump and his big hands
msg->prefix->state =
msg->prefix->state == EIGRP_FSM_STATE_ACTIVE_1 ?
EIGRP_FSM_STATE_ACTIVE_0 : EIGRP_FSM_STATE_ACTIVE_2;
msg->prefix->distance = ((struct eigrp_neighbor_entry *)successors->head->data)->distance;
if (!msg->prefix->rij->count) {
(*(NSM[msg->prefix->state][eigrp_get_fsm_event(msg)].func))(msg);
}
msg->prefix->state =
msg->prefix->state == EIGRP_FSM_STATE_ACTIVE_1 ?
EIGRP_FSM_STATE_ACTIVE_0 : EIGRP_FSM_STATE_ACTIVE_2;
msg->prefix->distance =
((struct eigrp_neighbor_entry *)successors->head->data)->distance;
if (!msg->prefix->rij->count)
(*(NSM[msg->prefix->state][eigrp_get_fsm_event(msg)].func))(msg);
list_delete(successors);
return 1;
list_delete(successors);
return 1;
}
int eigrp_fsm_event_lr_fcs(struct eigrp_fsm_action_message *msg) {
struct eigrp *eigrp = msg->eigrp;
struct eigrp_prefix_entry *prefix = msg->prefix;
prefix->state = EIGRP_FSM_STATE_PASSIVE;
prefix->distance =
prefix->rdistance =
((struct eigrp_neighbor_entry *) (prefix->entries->head->data))->distance;
prefix->reported_metric =
((struct eigrp_neighbor_entry *) (prefix->entries->head->data))->total_metric;
prefix->fdistance =
prefix->fdistance > prefix->distance ?
prefix->distance : prefix->fdistance;
if (prefix->state == EIGRP_FSM_STATE_ACTIVE_2) {
struct list *successors = eigrp_topology_get_successor(prefix);
int eigrp_fsm_event_lr_fcs(struct eigrp_fsm_action_message *msg)
{
struct eigrp *eigrp = msg->eigrp;
struct eigrp_prefix_entry *prefix = msg->prefix;
prefix->state = EIGRP_FSM_STATE_PASSIVE;
prefix->distance =
prefix->rdistance =
((struct eigrp_neighbor_entry *) (prefix->entries->head->data))->distance;
prefix->reported_metric =
((struct eigrp_neighbor_entry *) (prefix->entries->head->data))->total_metric;
prefix->fdistance =
prefix->fdistance > prefix->distance ?
prefix->distance : prefix->fdistance;
if (prefix->state == EIGRP_FSM_STATE_ACTIVE_2)
{
struct list *successors = eigrp_topology_get_successor(prefix);
assert(successors); // Having a spoon and all you need is a knife
assert(successors); // Having a spoon and all you need is a knife
eigrp_send_reply(((struct eigrp_neighbor_entry *)successors->head->data)->adv_router, prefix);
eigrp_send_reply(((struct eigrp_neighbor_entry *)successors->head->data)->adv_router, prefix);
list_delete(successors);
}
prefix->req_action |= EIGRP_FSM_NEED_UPDATE;
listnode_add(eigrp->topology_changes_internalIPV4,prefix);
eigrp_topology_update_node_flags(prefix);
eigrp_update_routing_table(prefix);
eigrp_update_topology_table_prefix(eigrp->topology_table, prefix);
list_delete(successors);
}
prefix->req_action |= EIGRP_FSM_NEED_UPDATE;
listnode_add(eigrp->topology_changes_internalIPV4,prefix);
eigrp_topology_update_node_flags(prefix);
eigrp_update_routing_table(prefix);
eigrp_update_topology_table_prefix(eigrp->topology_table, prefix);
return 1;
return 1;
}
int eigrp_fsm_event_lr_fcn(struct eigrp_fsm_action_message *msg) {
struct eigrp *eigrp = msg->eigrp;
struct eigrp_prefix_entry *prefix = msg->prefix;
struct list *successors = eigrp_topology_get_successor(prefix);
int eigrp_fsm_event_lr_fcn(struct eigrp_fsm_action_message *msg)
{
struct eigrp *eigrp = msg->eigrp;
struct eigrp_prefix_entry *prefix = msg->prefix;
struct list *successors = eigrp_topology_get_successor(prefix);
assert(successors); // Routing without a stack
assert(successors); // Routing without a stack
prefix->state =
prefix->state == EIGRP_FSM_STATE_ACTIVE_0 ?
EIGRP_FSM_STATE_ACTIVE_1 : EIGRP_FSM_STATE_ACTIVE_3;
struct eigrp_neighbor_entry *best_successor =
((struct eigrp_neighbor_entry *) (successors->head->data));
prefix->rdistance = prefix->distance = best_successor->distance;
prefix->reported_metric = best_successor->total_metric;
if (eigrp_nbr_count_get()) {
prefix->req_action |= EIGRP_FSM_NEED_QUERY;
listnode_add(eigrp->topology_changes_internalIPV4,prefix);
} else {
eigrp_fsm_event_lr(msg); //in the case that there are no more neighbors left
}
prefix->state =
prefix->state == EIGRP_FSM_STATE_ACTIVE_0 ?
EIGRP_FSM_STATE_ACTIVE_1 : EIGRP_FSM_STATE_ACTIVE_3;
struct eigrp_neighbor_entry *best_successor =
((struct eigrp_neighbor_entry *) (successors->head->data));
prefix->rdistance = prefix->distance = best_successor->distance;
prefix->reported_metric = best_successor->total_metric;
list_delete(successors);
if (eigrp_nbr_count_get())
{
prefix->req_action |= EIGRP_FSM_NEED_QUERY;
listnode_add(eigrp->topology_changes_internalIPV4,prefix);
}
else
{
eigrp_fsm_event_lr(msg); //in the case that there are no more neighbors left
}
return 1;
list_delete(successors);
return 1;
}
int eigrp_fsm_event_qact(struct eigrp_fsm_action_message *msg) {
struct list *successors = eigrp_topology_get_successor(msg->prefix);
int eigrp_fsm_event_qact(struct eigrp_fsm_action_message *msg)
{
struct list *successors = eigrp_topology_get_successor(msg->prefix);
assert(successors); // Cats and no Dogs
assert(successors); // Cats and no Dogs
msg->prefix->state = EIGRP_FSM_STATE_ACTIVE_2;
msg->prefix->distance =
((struct eigrp_neighbor_entry *) (successors->head->data))->distance;
msg->prefix->state = EIGRP_FSM_STATE_ACTIVE_2;
msg->prefix->distance =
((struct eigrp_neighbor_entry *) (successors->head->data))->distance;
list_delete(successors);
return 1;
list_delete(successors);
return 1;
}

247
eigrpd/eigrp_hello.c
View File

@ -59,14 +59,14 @@
/* Packet Type String. */
static const struct message eigrp_general_tlv_type_str[] =
{
{ EIGRP_TLV_PARAMETER, "PARAMETER" },
{ EIGRP_TLV_AUTH, "AUTH" },
{ EIGRP_TLV_SEQ, "SEQ" },
{ EIGRP_TLV_SW_VERSION, "SW_VERSION" },
{ EIGRP_TLV_NEXT_MCAST_SEQ, "NEXT_MCAST_SEQ" },
{ EIGRP_TLV_PEER_TERMINATION, "PEER_TERMINATION" },
{ EIGRP_TLV_PEER_MTRLIST, "PEER_MTRLIST" },
{ EIGRP_TLV_PEER_TIDLIST, "PEER_TIDLIST" },
{ EIGRP_TLV_PARAMETER, "PARAMETER" },
{ EIGRP_TLV_AUTH, "AUTH" },
{ EIGRP_TLV_SEQ, "SEQ" },
{ EIGRP_TLV_SW_VERSION, "SW_VERSION" },
{ EIGRP_TLV_NEXT_MCAST_SEQ, "NEXT_MCAST_SEQ" },
{ EIGRP_TLV_PEER_TERMINATION, "PEER_TERMINATION" },
{ EIGRP_TLV_PEER_MTRLIST, "PEER_MTRLIST" },
{ EIGRP_TLV_PEER_TIDLIST, "PEER_TIDLIST" },
};
static const size_t eigrp_general_tlv_type_str_max = sizeof(eigrp_general_tlv_type_str) /
@ -76,9 +76,9 @@ static const size_t eigrp_general_tlv_type_str_max = sizeof(eigrp_general_tlv_ty
/*
* @fn eigrp_hello_timer
*
* @param[in] thread current execution thread timer is associated with
* @param[in] thread current execution thread timer is associated with
*
* @return int always returns 0
* @return int always returns 0
*
* @par
* Called once per "hello" time interval, default 5 seconds
@ -102,7 +102,7 @@ eigrp_hello_timer (struct thread *thread)
/* Hello timer set. */
ei->t_hello = thread_add_timer(master, eigrp_hello_timer, ei,
EIGRP_IF_PARAM(ei, v_hello));
EIGRP_IF_PARAM(ei, v_hello));
return 0;
}
@ -124,7 +124,7 @@ eigrp_hello_timer (struct thread *thread)
*/
static void
eigrp_hello_parameter_decode (struct eigrp_neighbor *nbr,
struct eigrp_tlv_hdr_type *tlv)
struct eigrp_tlv_hdr_type *tlv)
{
struct eigrp *eigrp = nbr->ei->eigrp;
struct TLV_Parameter_Type *param = (struct TLV_Parameter_Type *)tlv;
@ -150,43 +150,43 @@ eigrp_hello_parameter_decode (struct eigrp_neighbor *nbr,
{
if (eigrp_nbr_state_get(nbr) == EIGRP_NEIGHBOR_DOWN)
{
zlog_info("Neighbor %s (%s) is pending: new adjacency",
inet_ntoa(nbr->src), ifindex2ifname(nbr->ei->ifp->ifindex, VRF_DEFAULT));
{
zlog_info("Neighbor %s (%s) is pending: new adjacency",
inet_ntoa(nbr->src), ifindex2ifname(nbr->ei->ifp->ifindex, VRF_DEFAULT));
/* Expedited hello sent */
eigrp_hello_send(nbr->ei, EIGRP_HELLO_NORMAL, NULL);
/* Expedited hello sent */
eigrp_hello_send(nbr->ei, EIGRP_HELLO_NORMAL, NULL);
// if(ntohl(nbr->ei->address->u.prefix4.s_addr) > ntohl(nbr->src.s_addr))
eigrp_update_send_init(nbr);
// if(ntohl(nbr->ei->address->u.prefix4.s_addr) > ntohl(nbr->src.s_addr))
eigrp_update_send_init(nbr);
eigrp_nbr_state_set(nbr, EIGRP_NEIGHBOR_PENDING);
}
eigrp_nbr_state_set(nbr, EIGRP_NEIGHBOR_PENDING);
}
}
else
{
if (eigrp_nbr_state_get(nbr) != EIGRP_NEIGHBOR_DOWN)
{
if ((param->K1 & param->K2 & param->K3 & param->K4 & param->K5) == 255)
{
{
if ((param->K1 & param->K2 & param->K3 & param->K4 & param->K5) == 255)
{
zlog_info ("Neighbor %s (%s) is down: Interface PEER-TERMINATION received",
inet_ntoa (nbr->src),ifindex2ifname (nbr->ei->ifp->ifindex, VRF_DEFAULT));
eigrp_nbr_delete (nbr);
}
else
{
}
else
{
zlog_info ("Neighbor %s (%s) going down: Kvalue mismatch",
inet_ntoa (nbr->src),ifindex2ifname (nbr->ei->ifp->ifindex, VRF_DEFAULT));
eigrp_nbr_state_set(nbr, EIGRP_NEIGHBOR_DOWN);
}
}
}
}
}
}
static u_char
eigrp_hello_authentication_decode(struct stream *s, struct eigrp_tlv_hdr_type *tlv_header, struct eigrp_neighbor *nbr)
eigrp_hello_authentication_decode(struct stream *s, struct eigrp_tlv_hdr_type *tlv_header,
struct eigrp_neighbor *nbr)
{
struct TLV_MD5_Authentication_Type *md5;
md5 = (struct TLV_MD5_Authentication_Type *) tlv_header;
@ -194,7 +194,8 @@ eigrp_hello_authentication_decode(struct stream *s, struct eigrp_tlv_hdr_type *t
if(md5->auth_type == EIGRP_AUTH_TYPE_MD5)
return eigrp_check_md5_digest(s, md5, nbr, EIGRP_AUTH_BASIC_HELLO_FLAG);
else if (md5->auth_type == EIGRP_AUTH_TYPE_SHA256)
return eigrp_check_sha256_digest(s, (struct TLV_SHA256_Authentication_Type *) tlv_header, nbr, EIGRP_AUTH_BASIC_HELLO_FLAG);
return eigrp_check_sha256_digest(s, (struct TLV_SHA256_Authentication_Type *)tlv_header,
nbr, EIGRP_AUTH_BASIC_HELLO_FLAG);
return 0;
}
@ -214,7 +215,7 @@ eigrp_hello_authentication_decode(struct stream *s, struct eigrp_tlv_hdr_type *t
*/
static void
eigrp_sw_version_decode (struct eigrp_neighbor *nbr,
struct eigrp_tlv_hdr_type *tlv)
struct eigrp_tlv_hdr_type *tlv)
{
struct TLV_Software_Type *version = (struct TLV_Software_Type *)tlv;
@ -240,22 +241,22 @@ eigrp_sw_version_decode (struct eigrp_neighbor *nbr,
*/
static void
eigrp_peer_termination_decode (struct eigrp_neighbor *nbr,
struct eigrp_tlv_hdr_type *tlv)
struct eigrp_tlv_hdr_type *tlv)
{
struct TLV_Peer_Termination_type *param = (struct TLV_Peer_Termination_type *)tlv;
struct TLV_Peer_Termination_type *param = (struct TLV_Peer_Termination_type *)tlv;
uint32_t my_ip = nbr->ei->address->u.prefix4.s_addr;
uint32_t received_ip = param->neighbor_ip;
uint32_t my_ip = nbr->ei->address->u.prefix4.s_addr;
uint32_t received_ip = param->neighbor_ip;
if(my_ip == received_ip)
{
zlog_info ("Neighbor %s (%s) is down: Peer Termination received",
inet_ntoa (nbr->src),ifindex2ifname (nbr->ei->ifp->ifindex, VRF_DEFAULT));
/* set neighbor to DOWN */
nbr->state = EIGRP_NEIGHBOR_DOWN;
/* delete neighbor */
eigrp_nbr_delete (nbr);
}
if(my_ip == received_ip)
{
zlog_info ("Neighbor %s (%s) is down: Peer Termination received",
inet_ntoa (nbr->src),ifindex2ifname (nbr->ei->ifp->ifindex, VRF_DEFAULT));
/* set neighbor to DOWN */
nbr->state = EIGRP_NEIGHBOR_DOWN;
/* delete neighbor */
eigrp_nbr_delete (nbr);
}
}
/**
@ -272,30 +273,30 @@ eigrp_peer_termination_decode (struct eigrp_neighbor *nbr,
static u_int16_t
eigrp_peer_termination_encode (struct stream *s, struct in_addr *nbr_addr)
{
u_int16_t length = EIGRP_TLV_PEER_TERMINATION_LEN;
u_int16_t length = EIGRP_TLV_PEER_TERMINATION_LEN;
/* fill in type and length */
stream_putw(s, EIGRP_TLV_PEER_TERMINATION);
stream_putw(s, length);
/* fill in type and length */
stream_putw(s, EIGRP_TLV_PEER_TERMINATION);
stream_putw(s, length);
/* fill in unknown field 0x04 */
stream_putc(s, 0x04);
/* fill in unknown field 0x04 */
stream_putc(s, 0x04);
/* finally neighbor IP address */
stream_put_ipv4(s, nbr_addr->s_addr);
/* finally neighbor IP address */
stream_put_ipv4(s, nbr_addr->s_addr);
return(length);
return(length);
}
/*
* @fn eigrp_hello_receive
*
* @param[in] eigrp eigrp routing process
* @param[in] iph pointer to ip header
* @param[in] eigrph pointer to eigrp header
* @param[in] s input ip stream
* @param[in] ei eigrp interface packet arrived on
* @param[in] size size of eigrp packet
* @param[in] eigrp eigrp routing process
* @param[in] iph pointer to ip header
* @param[in] eigrph pointer to eigrp header
* @param[in] s input ip stream
* @param[in] ei eigrp interface packet arrived on
* @param[in] size size of eigrp packet
*
* @return void
*
@ -310,12 +311,12 @@ eigrp_peer_termination_encode (struct stream *s, struct in_addr *nbr_addr)
*/
void
eigrp_hello_receive (struct eigrp *eigrp, struct ip *iph, struct eigrp_header *eigrph,
struct stream *s, struct eigrp_interface *ei, int size)
struct stream *s, struct eigrp_interface *ei, int size)
{
struct eigrp_tlv_hdr_type *tlv_header;
struct eigrp_neighbor *nbr;
uint16_t type;
uint16_t length;
uint16_t type;
uint16_t length;
/* get neighbor struct */
nbr = eigrp_nbr_get(ei, eigrph, iph);
@ -325,8 +326,8 @@ eigrp_hello_receive (struct eigrp *eigrp, struct ip *iph, struct eigrp_header *e
if (IS_DEBUG_EIGRP_PACKET(eigrph->opcode - 1, RECV))
zlog_debug("Processing Hello size[%u] int(%s) nbr(%s)",
size, ifindex2ifname(nbr->ei->ifp->ifindex, VRF_DEFAULT),
inet_ntoa(nbr->src));
size, ifindex2ifname(nbr->ei->ifp->ifindex, VRF_DEFAULT),
inet_ntoa(nbr->src));
size -= EIGRP_HEADER_LEN;
if (size < 0)
@ -340,40 +341,40 @@ eigrp_hello_receive (struct eigrp *eigrp, struct ip *iph, struct eigrp_header *e
if ((length > 0) && (length <= size))
{
if (IS_DEBUG_EIGRP_PACKET(0, RECV))
zlog_debug(" General TLV(%s)", LOOKUP(eigrp_general_tlv_type_str, type));
if (IS_DEBUG_EIGRP_PACKET(0, RECV))
zlog_debug(" General TLV(%s)", LOOKUP(eigrp_general_tlv_type_str, type));
// determine what General TLV is being processed
switch (type)
{
case EIGRP_TLV_PARAMETER:
eigrp_hello_parameter_decode(nbr, tlv_header);
break;
case EIGRP_TLV_AUTH:
{
// determine what General TLV is being processed
switch (type)
{
case EIGRP_TLV_PARAMETER:
eigrp_hello_parameter_decode(nbr, tlv_header);
break;
case EIGRP_TLV_AUTH:
{
if(eigrp_hello_authentication_decode(s,tlv_header,nbr) == 0)
return;
else
break;
break;
}
case EIGRP_TLV_SEQ:
break;
case EIGRP_TLV_SW_VERSION:
eigrp_sw_version_decode(nbr, tlv_header);
break;
case EIGRP_TLV_NEXT_MCAST_SEQ:
break;
case EIGRP_TLV_PEER_TERMINATION:
eigrp_peer_termination_decode(nbr, tlv_header);
break;
case EIGRP_TLV_PEER_MTRLIST:
case EIGRP_TLV_PEER_TIDLIST:
break;
default:
break;
}
}
}
case EIGRP_TLV_SEQ:
break;
case EIGRP_TLV_SW_VERSION:
eigrp_sw_version_decode(nbr, tlv_header);
break;
case EIGRP_TLV_NEXT_MCAST_SEQ:
break;
case EIGRP_TLV_PEER_TERMINATION:
eigrp_peer_termination_decode(nbr, tlv_header);
break;
case EIGRP_TLV_PEER_MTRLIST:
case EIGRP_TLV_PEER_TIDLIST:
break;
default:
break;
}
}
tlv_header = (struct eigrp_tlv_hdr_type *)(((char *)tlv_header) + length);
size -= length;
@ -391,8 +392,7 @@ eigrp_hello_receive (struct eigrp *eigrp, struct ip *iph, struct eigrp_header *e
}
if (IS_DEBUG_EIGRP_PACKET(0, RECV))
zlog_debug("Hello Packet received from %s", inet_ntoa(nbr->src));
zlog_debug("Hello Packet received from %s", inet_ntoa(nbr->src));
}
/**
@ -418,8 +418,8 @@ eigrp_sw_version_encode (struct stream *s)
// encode the version of quagga we're running
// DVS: need to figure out a cleaner way to do this
stream_putc(s, 0); //!< major os version
stream_putc(s, 99); //!< minor os version
stream_putc(s, 0); //!< major os version
stream_putc(s, 99); //!< minor os version
/* and the core eigrp version */
stream_putc(s, EIGRP_MAJOR_VERSION);
@ -532,9 +532,9 @@ eigrp_next_sequence_encode (struct stream *s)
}
// add in the parameters TLV
stream_putw(s, EIGRP_TLV_NEXT_MCAST_SEQ);
stream_putw(s, EIGRP_NEXT_SEQUENCE_TLV_SIZE);
stream_putl(s,eigrp->sequence_number+1);
stream_putw(s, EIGRP_TLV_NEXT_MCAST_SEQ);
stream_putw(s, EIGRP_NEXT_SEQUENCE_TLV_SIZE);
stream_putl(s,eigrp->sequence_number+1);
return length;
}
@ -557,7 +557,7 @@ eigrp_next_sequence_encode (struct stream *s)
static u_int16_t
eigrp_hello_parameter_encode (struct eigrp_interface *ei, struct stream *s, u_char flags)
{
u_int16_t length = EIGRP_TLV_PARAMETER_LEN;
u_int16_t length = EIGRP_TLV_PARAMETER_LEN;
// add in the parameters TLV
stream_putw(s, EIGRP_TLV_PARAMETER);
@ -605,7 +605,8 @@ eigrp_hello_parameter_encode (struct eigrp_interface *ei, struct stream *s, u_ch
*
*/
static struct eigrp_packet *
eigrp_hello_encode (struct eigrp_interface *ei, in_addr_t addr, u_int32_t ack, u_char flags, struct in_addr *nbr_addr)
eigrp_hello_encode (struct eigrp_interface *ei, in_addr_t addr, u_int32_t ack,
u_char flags, struct in_addr *nbr_addr)
{
struct eigrp_packet *ep;
u_int16_t length = EIGRP_HEADER_LEN;
@ -619,11 +620,13 @@ eigrp_hello_encode (struct eigrp_interface *ei, in_addr_t addr, u_int32_t ack, u
eigrp_packet_header_init(EIGRP_OPC_HELLO, ei, ep->s, 0, 0, ack);
// encode Authentication TLV
if((IF_DEF_PARAMS (ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) && (IF_DEF_PARAMS (ei->ifp)->auth_keychain != NULL))
if((IF_DEF_PARAMS (ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) &&
(IF_DEF_PARAMS (ei->ifp)->auth_keychain != NULL))
{
length += eigrp_add_authTLV_MD5_to_stream(ep->s,ei);
}
else if((IF_DEF_PARAMS (ei->ifp)->auth_type == EIGRP_AUTH_TYPE_SHA256) && (IF_DEF_PARAMS (ei->ifp)->auth_keychain != NULL))
else if((IF_DEF_PARAMS (ei->ifp)->auth_type == EIGRP_AUTH_TYPE_SHA256) &&
(IF_DEF_PARAMS (ei->ifp)->auth_keychain != NULL))
{
length += eigrp_add_authTLV_SHA256_to_stream(ep->s,ei);
}
@ -648,7 +651,7 @@ eigrp_hello_encode (struct eigrp_interface *ei, in_addr_t addr, u_int32_t ack, u
/* encode Peer Termination TLV if needed */
if(flags & EIGRP_HELLO_GRACEFUL_SHUTDOWN_NBR)
length += eigrp_peer_termination_encode(ep->s, nbr_addr);
length += eigrp_peer_termination_encode(ep->s, nbr_addr);
// Set packet length
ep->length = length;
@ -656,11 +659,13 @@ eigrp_hello_encode (struct eigrp_interface *ei, in_addr_t addr, u_int32_t ack, u
// set soruce address for the hello packet
ep->dst.s_addr = addr;
if((IF_DEF_PARAMS (ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) && (IF_DEF_PARAMS (ei->ifp)->auth_keychain != NULL))
if((IF_DEF_PARAMS (ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) &&
(IF_DEF_PARAMS (ei->ifp)->auth_keychain != NULL))
{
eigrp_make_md5_digest(ei,ep->s, EIGRP_AUTH_BASIC_HELLO_FLAG);
}
else if((IF_DEF_PARAMS (ei->ifp)->auth_type == EIGRP_AUTH_TYPE_SHA256) && (IF_DEF_PARAMS (ei->ifp)->auth_keychain != NULL))
else if((IF_DEF_PARAMS (ei->ifp)->auth_type == EIGRP_AUTH_TYPE_SHA256) &&
(IF_DEF_PARAMS (ei->ifp)->auth_keychain != NULL))
{
eigrp_make_sha256_digest(ei,ep->s, EIGRP_AUTH_BASIC_HELLO_FLAG);
}
@ -696,21 +701,21 @@ eigrp_hello_send_ack (struct eigrp_neighbor *nbr)
if (ep)
{
if (IS_DEBUG_EIGRP_PACKET(0, SEND))
zlog_debug("Queueing [Hello] Ack Seq [%u] nbr [%s]",
nbr->recv_sequence_number, inet_ntoa(nbr->src));
zlog_debug("Queueing [Hello] Ack Seq [%u] nbr [%s]",
nbr->recv_sequence_number, inet_ntoa(nbr->src));
/* Add packet to the top of the interface output queue*/
eigrp_fifo_push_head(nbr->ei->obuf, ep);
/* Hook thread to write packet. */
if (nbr->ei->on_write_q == 0)
{
listnode_add(nbr->ei->eigrp->oi_write_q, nbr->ei);
nbr->ei->on_write_q = 1;
}
{
listnode_add(nbr->ei->eigrp->oi_write_q, nbr->ei);
nbr->ei->on_write_q = 1;
}
if (nbr->ei->eigrp->t_write == NULL)
nbr->ei->eigrp->t_write =
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd);
nbr->ei->eigrp->t_write =
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd);
}
}
@ -734,9 +739,9 @@ eigrp_hello_send (struct eigrp_interface *ei, u_char flags, struct in_addr *nbr_
struct eigrp_packet *ep = NULL;
/* If this is passive interface, do not send EIGRP Hello.
if ((EIGRP_IF_PASSIVE_STATUS (ei) == EIGRP_IF_PASSIVE) ||
(ei->type != EIGRP_IFTYPE_NBMA))
return;
if ((EIGRP_IF_PASSIVE_STATUS (ei) == EIGRP_IF_PASSIVE) ||
(ei->type != EIGRP_IFTYPE_NBMA))
return;
*/
if (IS_DEBUG_EIGRP_PACKET(0, SEND))
@ -762,13 +767,13 @@ eigrp_hello_send (struct eigrp_interface *ei, u_char flags, struct in_addr *nbr_
if(flags & EIGRP_HELLO_GRACEFUL_SHUTDOWN)
{
ei->eigrp->t_write =
thread_execute(master, eigrp_write, ei->eigrp, ei->eigrp->fd);
thread_execute(master, eigrp_write, ei->eigrp, ei->eigrp->fd);
}
else
{
ei->eigrp->t_write =
thread_add_write(master, eigrp_write, ei->eigrp, ei->eigrp->fd);
}
}
}
}
}

53
eigrpd/eigrp_interface.c
View File

@ -106,9 +106,9 @@ eigrp_if_new (struct eigrp *eigrp, struct interface *ifp, struct prefix *p)
/* Initialize lists */
for (i = 0; i < EIGRP_FILTER_MAX; i++)
{
ei->list[i] = NULL;
ei->prefix[i] = NULL;
ei->routemap[i] = NULL;
ei->list[i] = NULL;
ei->prefix[i] = NULL;
ei->routemap[i] = NULL;
}
return ei;
@ -138,7 +138,6 @@ eigrp_if_table_lookup (struct interface *ifp, struct prefix *prefix)
int
eigrp_if_delete_hook (struct interface *ifp)
{
struct route_node *rn;
route_table_finish (IF_OIFS (ifp));
@ -222,7 +221,6 @@ eigrp_new_if_params (void)
UNSET_IF_PARAM (eip, auth_keychain);
UNSET_IF_PARAM (eip, auth_type);
return eip;
}
@ -401,7 +399,7 @@ eigrp_if_set_multicast (struct eigrp_interface *ei)
/* The interface should belong to the EIGRP-all-routers group. */
if (!EI_MEMBER_CHECK (ei, MEMBER_ALLROUTERS)
&& (eigrp_if_add_allspfrouters (ei->eigrp, ei->address,
ei->ifp->ifindex) >= 0))
ei->ifp->ifindex) >= 0))
/* Set the flag only if the system call to join succeeded. */
EI_MEMBER_JOINED (ei, MEMBER_ALLROUTERS);
}
@ -413,10 +411,10 @@ eigrp_if_set_multicast (struct eigrp_interface *ei)
/* Only actually drop if this is the last reference */
if (EI_MEMBER_COUNT (ei, MEMBER_ALLROUTERS) == 1)
eigrp_if_drop_allspfrouters (ei->eigrp, ei->address,
ei->ifp->ifindex);
ei->ifp->ifindex);
/* Unset the flag regardless of whether the system call to leave
the group succeeded, since it's much safer to assume that
we are not a member. */
the group succeeded, since it's much safer to assume that
we are not a member. */
EI_MEMBER_LEFT (ei, MEMBER_ALLROUTERS);
}
}
@ -484,7 +482,7 @@ eigrp_delete_from_if (struct interface *ifp, struct eigrp_interface *ei)
}
/* Simulate down/up on the interface. This is needed, for example, when
the MTU changes. */
the MTU changes. */
void
eigrp_if_reset (struct interface *ifp)
{
@ -504,7 +502,7 @@ eigrp_if_reset (struct interface *ifp)
struct eigrp_interface *
eigrp_if_lookup_by_local_addr (struct eigrp *eigrp, struct interface *ifp,
struct in_addr address)
struct in_addr address)
{
struct listnode *node;
struct eigrp_interface *ei;
@ -535,26 +533,26 @@ eigrp_if_lookup_by_local_addr (struct eigrp *eigrp, struct interface *ifp,
struct eigrp_interface *
eigrp_if_lookup_by_name (struct eigrp *eigrp, const char *if_name)
{
struct eigrp_interface *ei;
struct listnode *node;
struct eigrp_interface *ei;
struct listnode *node;
/* iterate over all eigrp interfaces */
for (ALL_LIST_ELEMENTS_RO (eigrp->eiflist, node, ei))
{
/* compare int name with eigrp interface's name */
if(strcmp(ei->ifp->name, if_name) == 0)
{
return ei;
}
}
/* iterate over all eigrp interfaces */
for (ALL_LIST_ELEMENTS_RO (eigrp->eiflist, node, ei))
{
/* compare int name with eigrp interface's name */
if(strcmp(ei->ifp->name, if_name) == 0)
{
return ei;
}
}
return NULL;
return NULL;
}
/* determine receiving interface by ifp and source address */
struct eigrp_interface *
eigrp_if_lookup_recv_if (struct eigrp *eigrp, struct in_addr src,
struct interface *ifp)
struct interface *ifp)
{
struct route_node *rn;
struct prefix_ipv4 addr;
@ -577,7 +575,7 @@ eigrp_if_lookup_recv_if (struct eigrp *eigrp, struct in_addr src,
continue;
if (prefix_match (CONNECTED_PREFIX (ei->connected),
(struct prefix *) &addr))
(struct prefix *) &addr))
{
if ((match == NULL)
|| (match->address->prefixlen < ei->address->prefixlen))
@ -594,10 +592,9 @@ eigrp_bandwidth_to_scaled (u_int32_t bandwidth)
u_int64_t temp_bandwidth = (256ull * 10000000) / bandwidth;
temp_bandwidth =
temp_bandwidth < EIGRP_MAX_METRIC ? temp_bandwidth : EIGRP_MAX_METRIC;
temp_bandwidth < EIGRP_MAX_METRIC ? temp_bandwidth : EIGRP_MAX_METRIC;
return (u_int32_t) temp_bandwidth;
}
u_int32_t
@ -606,7 +603,7 @@ eigrp_scaled_to_bandwidth (u_int32_t scaled)
u_int64_t temp_scaled = scaled * (256ull * 10000000);
temp_scaled =
temp_scaled < EIGRP_MAX_METRIC ? temp_scaled : EIGRP_MAX_METRIC;
temp_scaled < EIGRP_MAX_METRIC ? temp_scaled : EIGRP_MAX_METRIC;
return (u_int32_t) temp_scaled;
}

14
eigrpd/eigrp_main.c
View File

@ -91,9 +91,9 @@ struct zebra_privs_t eigrpd_privs =
/* EIGRPd options. */
struct option longopts[] =
{
{ 0 }
};
{
{ 0 }
};
/* Master of threads. */
struct thread_master *master;
@ -211,11 +211,11 @@ main (int argc, char **argv, char **envp)
prefix_list_delete_hook (eigrp_distribute_update_all);
/*eigrp_route_map_init();
route_map_add_hook (eigrp_rmap_update);
route_map_delete_hook (eigrp_rmap_update);*/
route_map_add_hook (eigrp_rmap_update);
route_map_delete_hook (eigrp_rmap_update);*/
/*if_rmap_init (EIGRP_NODE);
if_rmap_hook_add (eigrp_if_rmap_update);
if_rmap_hook_delete (eigrp_if_rmap_update);*/
if_rmap_hook_add (eigrp_if_rmap_update);
if_rmap_hook_delete (eigrp_if_rmap_update);*/
/* Distribute list install. */
distribute_list_init (EIGRP_NODE);

168
eigrpd/eigrp_neighbor.c
View File

@ -67,7 +67,6 @@ eigrp_nbr_new (struct eigrp_interface *ei)
nbr->ei = ei;
/* Set default values. */
eigrp_nbr_state_set (nbr, EIGRP_NEIGHBOR_DOWN);
return nbr;
@ -89,9 +88,9 @@ eigrp_nbr_add (struct eigrp_interface *ei, struct eigrp_header *eigrph,
nbr = eigrp_nbr_new (ei);
nbr->src = iph->ip_src;
// if (IS_DEBUG_EIGRP_EVENT)
// zlog_debug("NSM[%s:%s]: start", IF_NAME (nbr->oi),
// inet_ntoa (nbr->router_id));
// if (IS_DEBUG_EIGRP_EVENT)
// zlog_debug("NSM[%s:%s]: start", IF_NAME (nbr->oi),
// inet_ntoa (nbr->router_id));
return nbr;
}
@ -149,8 +148,8 @@ eigrp_nbr_lookup_by_addr (struct eigrp_interface *ei, struct in_addr *addr)
/**
* @fn eigrp_nbr_lookup_by_addr_process
*
* @param[in] eigrp EIGRP process
* @param[in] nbr_addr Address of neighbor
* @param[in] eigrp EIGRP process
* @param[in] nbr_addr Address of neighbor
*
* @return void
*
@ -161,25 +160,25 @@ eigrp_nbr_lookup_by_addr (struct eigrp_interface *ei, struct in_addr *addr)
struct eigrp_neighbor *
eigrp_nbr_lookup_by_addr_process (struct eigrp *eigrp, struct in_addr nbr_addr)
{
struct eigrp_interface *ei;
struct listnode *node, *node2, *nnode2;
struct eigrp_neighbor *nbr;
struct eigrp_interface *ei;
struct listnode *node, *node2, *nnode2;
struct eigrp_neighbor *nbr;
/* iterate over all eigrp interfaces */
for (ALL_LIST_ELEMENTS_RO (eigrp->eiflist, node, ei))
{
/* iterate over all neighbors on eigrp interface */
for (ALL_LIST_ELEMENTS (ei->nbrs, node2, nnode2, nbr))
{
/* compare if neighbor address is same as arg address */
if (nbr->src.s_addr == nbr_addr.s_addr)
{
return nbr;
}
}
}
/* iterate over all eigrp interfaces */
for (ALL_LIST_ELEMENTS_RO (eigrp->eiflist, node, ei))
{
/* iterate over all neighbors on eigrp interface */
for (ALL_LIST_ELEMENTS (ei->nbrs, node2, nnode2, nbr))
{
/* compare if neighbor address is same as arg address */
if (nbr->src.s_addr == nbr_addr.s_addr)
{
return nbr;
}
}
}
return NULL;
return NULL;
}
@ -187,7 +186,6 @@ eigrp_nbr_lookup_by_addr_process (struct eigrp *eigrp, struct in_addr nbr_addr)
void
eigrp_nbr_delete (struct eigrp_neighbor *nbr)
{
eigrp_nbr_state_set(nbr, EIGRP_NEIGHBOR_DOWN);
eigrp_topology_neighbor_down(nbr->ei->eigrp, nbr);
@ -209,7 +207,7 @@ holddown_timer_expired (struct thread *thread)
nbr = THREAD_ARG (thread);
zlog_info ("Neighbor %s (%s) is down: holding time expired",
inet_ntoa(nbr->src), ifindex2ifname(nbr->ei->ifp->ifindex, VRF_DEFAULT));
inet_ntoa(nbr->src), ifindex2ifname(nbr->ei->ifp->ifindex, VRF_DEFAULT));
nbr->state = EIGRP_NEIGHBOR_DOWN;
eigrp_nbr_delete (nbr);
@ -225,7 +223,6 @@ eigrp_nbr_state_get (struct eigrp_neighbor *nbr)
void
eigrp_nbr_state_set (struct eigrp_neighbor *nbr, u_char state)
{
nbr->state = state;
if (eigrp_nbr_state_get(nbr) == EIGRP_NEIGHBOR_DOWN)
@ -251,7 +248,7 @@ eigrp_nbr_state_set (struct eigrp_neighbor *nbr, u_char state)
if (nbr->multicast_queue)
eigrp_fifo_free (nbr->multicast_queue);
if (nbr->retrans_queue)
eigrp_fifo_free (nbr->retrans_queue);
eigrp_fifo_free (nbr->retrans_queue);
/* in with the new */
nbr->retrans_queue = eigrp_fifo_new ();
@ -291,56 +288,55 @@ eigrp_nbr_state_update (struct eigrp_neighbor *nbr)
{
case EIGRP_NEIGHBOR_DOWN:
{
/*Start Hold Down Timer for neighbor*/
// THREAD_OFF(nbr->t_holddown);
// THREAD_TIMER_ON(master, nbr->t_holddown, holddown_timer_expired,
// nbr, nbr->v_holddown);
break;
/*Start Hold Down Timer for neighbor*/
// THREAD_OFF(nbr->t_holddown);
// THREAD_TIMER_ON(master, nbr->t_holddown, holddown_timer_expired,
// nbr, nbr->v_holddown);
break;
}
case EIGRP_NEIGHBOR_PENDING:
{
/*Reset Hold Down Timer for neighbor*/
THREAD_OFF(nbr->t_holddown);
THREAD_TIMER_ON(master, nbr->t_holddown, holddown_timer_expired, nbr,
nbr->v_holddown);
break;
/*Reset Hold Down Timer for neighbor*/
THREAD_OFF(nbr->t_holddown);
THREAD_TIMER_ON(master, nbr->t_holddown, holddown_timer_expired, nbr,
nbr->v_holddown);
break;
}
case EIGRP_NEIGHBOR_UP:
{
/*Reset Hold Down Timer for neighbor*/
THREAD_OFF(nbr->t_holddown);
THREAD_TIMER_ON(master, nbr->t_holddown, holddown_timer_expired, nbr,
nbr->v_holddown);
break;
/*Reset Hold Down Timer for neighbor*/
THREAD_OFF(nbr->t_holddown);
THREAD_TIMER_ON(master, nbr->t_holddown, holddown_timer_expired, nbr,
nbr->v_holddown);
break;
}
}
}
int eigrp_nbr_count_get(void){
struct eigrp_interface *iface;
struct listnode *node, *node2, *nnode2;
struct eigrp_neighbor *nbr;
struct eigrp *eigrp = eigrp_lookup();
u_int32_t counter;
struct eigrp_interface *iface;
struct listnode *node, *node2, *nnode2;
struct eigrp_neighbor *nbr;
struct eigrp *eigrp = eigrp_lookup();
u_int32_t counter;
if (eigrp == NULL)
{
zlog_debug("EIGRP Routing Process not enabled");
return 0;
}
if (eigrp == NULL)
{
zlog_debug("EIGRP Routing Process not enabled");
return 0;
}
counter=0;
for (ALL_LIST_ELEMENTS_RO(eigrp->eiflist, node, iface))
{
for (ALL_LIST_ELEMENTS(iface->nbrs, node2, nnode2, nbr))
{
if (nbr->state == EIGRP_NEIGHBOR_UP){
counter++;
}
}
}
return counter;
counter=0;
for (ALL_LIST_ELEMENTS_RO(eigrp->eiflist, node, iface))
{
for (ALL_LIST_ELEMENTS(iface->nbrs, node2, nnode2, nbr))
{
if (nbr->state == EIGRP_NEIGHBOR_UP){
counter++;
}
}
}
return counter;
}
/**
@ -357,28 +353,28 @@ int eigrp_nbr_count_get(void){
*/
void eigrp_nbr_hard_restart(struct eigrp_neighbor *nbr, struct vty *vty)
{
if(nbr == NULL)
{
zlog_err("Nbr Hard restart: Neighbor not specified.");
return;
}
if(nbr == NULL)
{
zlog_err("Nbr Hard restart: Neighbor not specified.");
return;
}
zlog_debug ("Neighbor %s (%s) is down: manually cleared",
inet_ntoa (nbr->src),
ifindex2ifname (nbr->ei->ifp->ifindex, VRF_DEFAULT));
if(vty != NULL)
{
vty_time_print (vty, 0);
vty_out (vty, "Neighbor %s (%s) is down: manually cleared%s",
inet_ntoa (nbr->src),
ifindex2ifname (nbr->ei->ifp->ifindex, VRF_DEFAULT),
VTY_NEWLINE);
}
zlog_debug ("Neighbor %s (%s) is down: manually cleared",
inet_ntoa (nbr->src),
ifindex2ifname (nbr->ei->ifp->ifindex, VRF_DEFAULT));
if(vty != NULL)
{
vty_time_print (vty, 0);
vty_out (vty, "Neighbor %s (%s) is down: manually cleared%s",
inet_ntoa (nbr->src),
ifindex2ifname (nbr->ei->ifp->ifindex, VRF_DEFAULT),
VTY_NEWLINE);
}
/* send Hello with Peer Termination TLV */
eigrp_hello_send(nbr->ei, EIGRP_HELLO_GRACEFUL_SHUTDOWN_NBR, &(nbr->src));
/* set neighbor to DOWN */
nbr->state = EIGRP_NEIGHBOR_DOWN;
/* delete neighbor */
eigrp_nbr_delete (nbr);
/* send Hello with Peer Termination TLV */
eigrp_hello_send(nbr->ei, EIGRP_HELLO_GRACEFUL_SHUTDOWN_NBR, &(nbr->src));
/* set neighbor to DOWN */
nbr->state = EIGRP_NEIGHBOR_DOWN;
/* delete neighbor */
eigrp_nbr_delete (nbr);
}

76
eigrpd/eigrp_network.c
View File

@ -63,7 +63,7 @@ eigrp_sock_init(void)
if (eigrpd_privs.change(ZPRIVS_RAISE))
zlog_err("eigrp_sock_init: could not raise privs, %s",
safe_strerror(errno));
safe_strerror(errno));
eigrp_sock = socket(AF_INET, SOCK_RAW, IPPROTO_EIGRPIGP);
if (eigrp_sock < 0)
@ -71,7 +71,7 @@ eigrp_sock_init(void)
int save_errno = errno;
if (eigrpd_privs.change(ZPRIVS_LOWER))
zlog_err("eigrp_sock_init: could not lower privs, %s",
safe_strerror(errno));
safe_strerror(errno));
zlog_err("eigrp_read_sock_init: socket: %s", safe_strerror(save_errno));
exit(1);
}
@ -84,9 +84,9 @@ eigrp_sock_init(void)
int save_errno = errno;
if (eigrpd_privs.change(ZPRIVS_LOWER))
zlog_err("eigrp_sock_init: could not lower privs, %s",
safe_strerror(errno));
safe_strerror(errno));
zlog_warn("Can't set IP_HDRINCL option for fd %d: %s", eigrp_sock,
safe_strerror(save_errno));
safe_strerror(save_errno));
}
#elif defined (IPTOS_PREC_INTERNETCONTROL)
@ -97,10 +97,10 @@ eigrp_sock_init(void)
{
int save_errno = errno;
if ( eigrpd_privs.change (ZPRIVS_LOWER) )
zlog_err ("eigrpd_sock_init: could not lower privs, %s",
safe_strerror (errno) );
zlog_err ("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, eigrp_sock, safe_strerror (save_errno));
tos, eigrp_sock, safe_strerror (save_errno));
close (eigrp_sock); /* Prevent sd leak. */
return ret;
}
@ -117,7 +117,7 @@ eigrp_sock_init(void)
if (eigrpd_privs.change(ZPRIVS_LOWER))
{
zlog_err("eigrp_sock_init: could not lower privs, %s",
safe_strerror(errno));
safe_strerror(errno));
}
return eigrp_sock;
@ -132,6 +132,7 @@ eigrp_adjust_sndbuflen(struct eigrp * eigrp, unsigned int buflen)
return;
if (eigrpd_privs.change(ZPRIVS_RAISE))
zlog_err("%s: could not raise privs, %s", __func__, safe_strerror(errno));
/* Now we try to set SO_SNDBUF to what our caller has requested
* (the MTU of a newly added interface). However, if the OS has
* truncated the actual buffer size to somewhat less size, try
@ -143,7 +144,7 @@ eigrp_adjust_sndbuflen(struct eigrp * eigrp, unsigned int buflen)
newbuflen = getsockopt_so_sendbuf(eigrp->fd);
if (newbuflen < 0 || newbuflen < (int) buflen)
zlog_warn("%s: tried to set SO_SNDBUF to %u, but got %d", __func__, buflen,
newbuflen);
newbuflen);
if (newbuflen >= 0)
eigrp->maxsndbuflen = (unsigned int) newbuflen;
else
@ -172,13 +173,13 @@ eigrp_if_ipmulticast(struct eigrp *top, struct prefix *p, unsigned int ifindex)
ret = setsockopt(top->fd, IPPROTO_IP, IP_MULTICAST_TTL, (void *) &val, len);
if (ret < 0)
zlog_warn("can't setsockopt IP_MULTICAST_TTL (1) for fd %d: %s", top->fd,
safe_strerror(errno));
safe_strerror(errno));
ret = setsockopt_ipv4_multicast_if(top->fd, p->u.prefix4, ifindex);
if (ret < 0)
zlog_warn("can't setsockopt IP_MULTICAST_IF (fd %d, addr %s, "
"ifindex %u): %s", top->fd, inet_ntoa(p->u.prefix4), ifindex,
safe_strerror(errno));
"ifindex %u): %s", top->fd, inet_ntoa(p->u.prefix4), ifindex,
safe_strerror(errno));
return ret;
}
@ -186,7 +187,7 @@ eigrp_if_ipmulticast(struct eigrp *top, struct prefix *p, unsigned int ifindex)
/* Join to the EIGRP multicast group. */
int
eigrp_if_add_allspfrouters(struct eigrp *top, struct prefix *p,
unsigned int ifindex)
unsigned int ifindex)
{
int ret;
@ -194,19 +195,19 @@ eigrp_if_add_allspfrouters(struct eigrp *top, struct prefix *p,
htonl(EIGRP_MULTICAST_ADDRESS), ifindex);
if (ret < 0)
zlog_warn("can't setsockopt IP_ADD_MEMBERSHIP (fd %d, addr %s, "
"ifindex %u, AllSPFRouters): %s; perhaps a kernel limit "
"on # of multicast group memberships has been exceeded?", top->fd,
inet_ntoa(p->u.prefix4), ifindex, safe_strerror(errno));
"ifindex %u, AllSPFRouters): %s; perhaps a kernel limit "
"on # of multicast group memberships has been exceeded?", top->fd,
inet_ntoa(p->u.prefix4), ifindex, safe_strerror(errno));
else
zlog_debug("interface %s [%u] join EIGRP Multicast group.",
inet_ntoa(p->u.prefix4), ifindex);
inet_ntoa(p->u.prefix4), ifindex);
return ret;
}
int
eigrp_if_drop_allspfrouters(struct eigrp *top, struct prefix *p,
unsigned int ifindex)
unsigned int ifindex)
{
int ret;
@ -214,11 +215,11 @@ eigrp_if_drop_allspfrouters(struct eigrp *top, struct prefix *p,
htonl(EIGRP_MULTICAST_ADDRESS), ifindex);
if (ret < 0)
zlog_warn("can't setsockopt IP_DROP_MEMBERSHIP (fd %d, addr %s, "
"ifindex %u, AllSPFRouters): %s", top->fd, inet_ntoa(p->u.prefix4),
ifindex, safe_strerror(errno));
"ifindex %u, AllSPFRouters): %s", top->fd, inet_ntoa(p->u.prefix4),
ifindex, safe_strerror(errno));
else
zlog_debug("interface %s [%u] leave EIGRP Multicast group.",
inet_ntoa(p->u.prefix4), ifindex);
inet_ntoa(p->u.prefix4), ifindex);
return ret;
}
@ -230,7 +231,6 @@ eigrp_network_set(struct eigrp *eigrp, struct prefix_ipv4 *p)
struct interface *ifp;
struct listnode *node;
zlog_debug ("A");
rn = route_node_get(eigrp->networks, (struct prefix *) p);
if (rn->info)
{
@ -243,10 +243,9 @@ eigrp_network_set(struct eigrp *eigrp, struct prefix_ipv4 *p)
PREFIX_COPY_IPV4(pref,p);
rn->info = (void *) pref;
zlog_debug ("B");
/* Schedule Router ID Update. */
// if (eigrp->router_id == 0)
// eigrp_router_id_update(eigrp);
// if (eigrp->router_id == 0)
// eigrp_router_id_update(eigrp);
/* Run network config now. */
/* Get target interface. */
for (ALL_LIST_ELEMENTS_RO(vrf_iflist(VRF_DEFAULT), node, ifp))
@ -269,13 +268,13 @@ eigrp_network_match_iface(const struct connected *co, const struct prefix *net)
static void
eigrp_network_run_interface(struct eigrp *eigrp, struct prefix *p,
struct interface *ifp)
struct interface *ifp)
{
struct listnode *cnode;
struct connected *co;
/* if interface prefix is match specified prefix,
then create socket and join multicast group. */
then create socket and join multicast group. */
for (ALL_LIST_ELEMENTS_RO(ifp->connected, cnode, co))
{
@ -298,7 +297,7 @@ eigrp_network_run_interface(struct eigrp *eigrp, struct prefix *p,
/* update network type as interface flag */
/* If network type is specified previously,
skip network type setting. */
skip network type setting. */
ei->type = IF_DEF_PARAMS (ifp)->type;
/* if router_id is not configured, dont bring up
@ -354,7 +353,7 @@ eigrp_network_unset(struct eigrp *eigrp, struct prefix_ipv4 *p)
route_unlock_node (rn);
if (!IPV4_ADDR_SAME (&pref->u.prefix4, &p->prefix))
return 0;
return 0;
prefix_ipv4_free(rn->info);
rn->info = NULL;
@ -373,7 +372,6 @@ eigrp_network_unset(struct eigrp *eigrp, struct prefix_ipv4 *p)
if (eigrp_network_match_iface(co, &rn->p))
{
zlog_debug("eigrp_network_unset()2");
found = 1;
route_unlock_node(rn);
break;
@ -404,7 +402,7 @@ eigrp_calculate_metrics(struct eigrp *eigrp, struct eigrp_metrics *metric)
temp_metric += (eigrp->k_values[0] * metric->bandwith);
if (eigrp->k_values[1])
temp_metric += ((eigrp->k_values[1] * metric->bandwith)
/ (256 - metric->load));
/ (256 - metric->load));
if (eigrp->k_values[2])
temp_metric += (eigrp->k_values[2] * metric->delay);
if (eigrp->k_values[3] && !eigrp->k_values[4])
@ -413,7 +411,7 @@ eigrp_calculate_metrics(struct eigrp *eigrp, struct eigrp_metrics *metric)
temp_metric *= (eigrp->k_values[4] / metric->reliability);
if (eigrp->k_values[3] && eigrp->k_values[4])
temp_metric *= ((eigrp->k_values[4] / metric->reliability)
+ eigrp->k_values[3]);
+ eigrp->k_values[3]);
if (temp_metric <= EIGRP_MAX_METRIC)
return (u_int32_t) temp_metric;
@ -423,24 +421,24 @@ eigrp_calculate_metrics(struct eigrp *eigrp, struct eigrp_metrics *metric)
u_int32_t
eigrp_calculate_total_metrics(struct eigrp *eigrp,
struct eigrp_neighbor_entry *entry)
struct eigrp_neighbor_entry *entry)
{
entry->total_metric = entry->reported_metric;
u_int64_t temp_delay = (u_int64_t) entry->total_metric.delay
+ (u_int64_t) EIGRP_IF_PARAM (entry->ei, delay);
+ (u_int64_t) EIGRP_IF_PARAM (entry->ei, delay);
entry->total_metric.delay =
temp_delay > EIGRP_MAX_METRIC ? EIGRP_MAX_METRIC : (u_int32_t) temp_delay;
temp_delay > EIGRP_MAX_METRIC ? EIGRP_MAX_METRIC : (u_int32_t) temp_delay;
u_int32_t bw = EIGRP_IF_PARAM (entry->ei,bandwidth);
entry->total_metric.bandwith =
entry->total_metric.bandwith > bw ? bw : entry->total_metric.bandwith;
entry->total_metric.bandwith > bw ? bw : entry->total_metric.bandwith;
return eigrp_calculate_metrics(eigrp, &entry->total_metric);
}
u_char
eigrp_metrics_is_same(struct eigrp_metrics *metric1,
struct eigrp_metrics *metric2)
struct eigrp_metrics *metric2)
{
if ((metric1->bandwith == metric2->bandwith)
&& (metric1->delay == metric2->delay)
@ -452,12 +450,12 @@ eigrp_metrics_is_same(struct eigrp_metrics *metric1,
&& (metric1->mtu[2] == metric2->mtu[2]))
return 1;
return 0; // if different
return 0; // if different
}
void
eigrp_external_routes_refresh (struct eigrp *eigrp, int type)
{
}

371
eigrpd/eigrp_packet.c
View File

@ -59,18 +59,19 @@
/* Packet Type String. */
const struct message eigrp_packet_type_str[] =
{
{ EIGRP_OPC_UPDATE, "Update" },
{ EIGRP_OPC_REQUEST, "Request" },
{ EIGRP_OPC_QUERY, "Query" },
{ EIGRP_OPC_REPLY, "Reply" },
{ EIGRP_OPC_HELLO, "Hello" },
{ EIGRP_OPC_IPXSAP, "IPX-SAP" },
{ EIGRP_OPC_PROBE, "Probe" },
{ EIGRP_OPC_ACK, "Ack" },
{ EIGRP_OPC_SIAQUERY, "SIAQuery" },
{ EIGRP_OPC_SIAREPLY, "SIAReply" },
{
{ EIGRP_OPC_UPDATE, "Update"},
{ EIGRP_OPC_REQUEST, "Request"},
{ EIGRP_OPC_QUERY, "Query"},
{ EIGRP_OPC_REPLY, "Reply"},
{ EIGRP_OPC_HELLO, "Hello"},
{ EIGRP_OPC_IPXSAP, "IPX-SAP"},
{ EIGRP_OPC_PROBE, "Probe"},
{ EIGRP_OPC_ACK, "Ack"},
{ EIGRP_OPC_SIAQUERY, "SIAQuery"},
{ EIGRP_OPC_SIAREPLY, "SIAReply"},
};
const size_t eigrp_packet_type_str_max = sizeof(eigrp_packet_type_str) /
sizeof(eigrp_packet_type_str[0]);
@ -79,10 +80,9 @@ static unsigned char zeropad[16] = {0};
/* Forward function reference*/
static struct stream * eigrp_recv_packet (int, struct interface **, struct stream *);
static int eigrp_verify_header (struct stream *, struct eigrp_interface *, struct ip *,
struct eigrp_header *);
struct eigrp_header *);
static int eigrp_check_network_mask (struct eigrp_interface *, struct in_addr);
static int eigrp_retrans_count_exceeded(struct eigrp_packet *ep, struct eigrp_neighbor *nbr)
{
return 1;
@ -125,7 +125,7 @@ eigrp_make_md5_digest (struct eigrp_interface *ei, struct stream *s, u_char flag
MD5Update(&ctx, ibuf, EIGRP_MD5_BASIC_COMPUTE);
MD5Update(&ctx, key->string, strlen(key->string));
if(strlen(key->string) < 16)
MD5Update(&ctx, zeropad, 16 - strlen(key->string));
MD5Update(&ctx, zeropad, 16 - strlen(key->string));
}
else if(flags & EIGRP_AUTH_UPDATE_INIT_FLAG)
{
@ -136,17 +136,16 @@ eigrp_make_md5_digest (struct eigrp_interface *ei, struct stream *s, u_char flag
MD5Update(&ctx, ibuf, EIGRP_MD5_BASIC_COMPUTE);
MD5Update(&ctx, key->string, strlen(key->string));
if(strlen(key->string) < 16)
MD5Update(&ctx, zeropad, 16 - strlen(key->string));
MD5Update(&ctx, zeropad, 16 - strlen(key->string));
if(backup_end > (EIGRP_HEADER_LEN + EIGRP_AUTH_MD5_TLV_SIZE))
{
MD5Update(&ctx, ibuf + (EIGRP_HEADER_LEN + EIGRP_AUTH_MD5_TLV_SIZE),
backup_end - 20 - (EIGRP_HEADER_LEN + EIGRP_AUTH_MD5_TLV_SIZE));
}
{
MD5Update(&ctx, ibuf + (EIGRP_HEADER_LEN + EIGRP_AUTH_MD5_TLV_SIZE),
backup_end - 20 - (EIGRP_HEADER_LEN + EIGRP_AUTH_MD5_TLV_SIZE));
}
}
MD5Final(digest, &ctx);
/* Append md5 digest to the end of the stream. */
memcpy(auth_TLV->digest,digest,EIGRP_AUTH_TYPE_MD5_LEN);
@ -159,7 +158,8 @@ eigrp_make_md5_digest (struct eigrp_interface *ei, struct stream *s, u_char flag
}
int
eigrp_check_md5_digest (struct stream *s, struct TLV_MD5_Authentication_Type *authTLV,struct eigrp_neighbor *nbr, u_char flags)
eigrp_check_md5_digest (struct stream *s,
struct TLV_MD5_Authentication_Type *authTLV,struct eigrp_neighbor *nbr, u_char flags)
{
MD5_CTX ctx;
unsigned char digest[EIGRP_AUTH_TYPE_MD5_LEN];
@ -170,7 +170,6 @@ eigrp_check_md5_digest (struct stream *s, struct TLV_MD5_Authentication_Type *au
struct TLV_MD5_Authentication_Type *auth_TLV;
struct eigrp_header *eigrph;
if (nbr && ntohl(nbr->crypt_seqnum) > ntohl(authTLV->key_sequence))
{
zlog_warn ("interface %s: eigrp_check_md5 bad sequence %d (expect %d)",
@ -190,8 +189,8 @@ eigrp_check_md5_digest (struct stream *s, struct TLV_MD5_Authentication_Type *au
backup_end = s->endp;
keychain = keychain_lookup(IF_DEF_PARAMS (nbr->ei->ifp)->auth_keychain);
if(keychain)
key = key_lookup_for_send(keychain);
if(keychain)
key = key_lookup_for_send(keychain);
memset(&ctx, 0, sizeof(ctx));
MD5Init(&ctx);
@ -217,7 +216,7 @@ eigrp_check_md5_digest (struct stream *s, struct TLV_MD5_Authentication_Type *au
if(backup_end > (EIGRP_HEADER_LEN + EIGRP_AUTH_MD5_TLV_SIZE))
{
MD5Update(&ctx, ibuf + (EIGRP_HEADER_LEN + EIGRP_AUTH_MD5_TLV_SIZE),
backup_end - 20 - (EIGRP_HEADER_LEN + EIGRP_AUTH_MD5_TLV_SIZE));
backup_end - 20 - (EIGRP_HEADER_LEN + EIGRP_AUTH_MD5_TLV_SIZE));
}
}
@ -231,7 +230,7 @@ eigrp_check_md5_digest (struct stream *s, struct TLV_MD5_Authentication_Type *au
else
{
zlog_warn ("interface %s: eigrp_check_md5 checksum mismatch",
IF_NAME (nbr->ei));
IF_NAME (nbr->ei));
return 0;
}
@ -245,65 +244,67 @@ eigrp_check_md5_digest (struct stream *s, struct TLV_MD5_Authentication_Type *au
int
eigrp_make_sha256_digest (struct eigrp_interface *ei, struct stream *s, u_char flags)
{
struct key *key = NULL;
struct keychain *keychain;
char *source_ip;
struct key *key = NULL;
struct keychain *keychain;
char *source_ip;
unsigned char digest[EIGRP_AUTH_TYPE_SHA256_LEN];
unsigned char buffer[1 + PLAINTEXT_LENGTH + 45 + 1] = { 0 };
HMAC_SHA256_CTX ctx;
void *ibuf;
size_t backup_get, backup_end;
struct TLV_SHA256_Authentication_Type *auth_TLV;
unsigned char digest[EIGRP_AUTH_TYPE_SHA256_LEN];
unsigned char buffer[1 + PLAINTEXT_LENGTH + 45 + 1] = { 0 };
HMAC_SHA256_CTX ctx;
void *ibuf;
size_t backup_get, backup_end;
struct TLV_SHA256_Authentication_Type *auth_TLV;
ibuf = s->data;
backup_end = s->endp;
backup_get = s->getp;
ibuf = s->data;
backup_end = s->endp;
backup_get = s->getp;
auth_TLV = eigrp_authTLV_SHA256_new ();
auth_TLV = eigrp_authTLV_SHA256_new ();
stream_set_getp(s,EIGRP_HEADER_LEN);
stream_get(auth_TLV,s,EIGRP_AUTH_SHA256_TLV_SIZE);
stream_set_getp(s, backup_get);
stream_set_getp(s,EIGRP_HEADER_LEN);
stream_get(auth_TLV,s,EIGRP_AUTH_SHA256_TLV_SIZE);
stream_set_getp(s, backup_get);
keychain = keychain_lookup(IF_DEF_PARAMS (ei->ifp)->auth_keychain);
if(keychain)
key = key_lookup_for_send(keychain);
keychain = keychain_lookup(IF_DEF_PARAMS (ei->ifp)->auth_keychain);
if(keychain)
key = key_lookup_for_send(keychain);
// saved_len[index] = strnzcpyn(saved_key[index], key,
// PLAINTEXT_LENGTH + 1);
// saved_len[index] = strnzcpyn(saved_key[index], key,
// PLAINTEXT_LENGTH + 1);
source_ip = calloc(16, sizeof(char));
inet_ntop(AF_INET, &ei->address->u.prefix4, source_ip, 16);
source_ip = calloc(16, sizeof(char));
inet_ntop(AF_INET, &ei->address->u.prefix4, source_ip, 16);
memset(&ctx, 0, sizeof(ctx));
buffer[0] = '\n';
memcpy(buffer + 1, key, strlen (key->string));
memcpy(buffer + 1 + strlen(key->string), source_ip, strlen(source_ip));
HMAC__SHA256_Init(&ctx, buffer, 1 + strlen (key->string) + strlen(source_ip));
HMAC__SHA256_Update(&ctx, ibuf, strlen(ibuf));
HMAC__SHA256_Final(digest, &ctx);
memset(&ctx, 0, sizeof(ctx));
buffer[0] = '\n';
memcpy(buffer + 1, key, strlen (key->string));
memcpy(buffer + 1 + strlen(key->string), source_ip, strlen(source_ip));
HMAC__SHA256_Init(&ctx, buffer, 1 + strlen (key->string) + strlen(source_ip));
HMAC__SHA256_Update(&ctx, ibuf, strlen(ibuf));
HMAC__SHA256_Final(digest, &ctx);
/* Put hmac-sha256 digest to it's place */
memcpy(auth_TLV->digest,digest,EIGRP_AUTH_TYPE_SHA256_LEN);
/* Put hmac-sha256 digest to it's place */
memcpy(auth_TLV->digest,digest,EIGRP_AUTH_TYPE_SHA256_LEN);
stream_set_endp(s,EIGRP_HEADER_LEN);
stream_put(s,auth_TLV,EIGRP_AUTH_SHA256_TLV_SIZE);
stream_set_endp(s, backup_end);
stream_set_endp(s,EIGRP_HEADER_LEN);
stream_put(s,auth_TLV,EIGRP_AUTH_SHA256_TLV_SIZE);
stream_set_endp(s, backup_end);
eigrp_authTLV_SHA256_free(auth_TLV);
free(source_ip);
eigrp_authTLV_SHA256_free(auth_TLV);
free(source_ip);
return EIGRP_AUTH_TYPE_SHA256_LEN;
return EIGRP_AUTH_TYPE_SHA256_LEN;
}
int
eigrp_check_sha256_digest (struct stream *s, struct TLV_SHA256_Authentication_Type *authTLV,struct eigrp_neighbor *nbr, u_char flags)
eigrp_check_sha256_digest (struct stream *s,
struct TLV_SHA256_Authentication_Type *authTLV,
struct eigrp_neighbor *nbr, u_char flags)
{
return 1;
}
/*
* eigrp_packet_dump
*
@ -313,31 +314,10 @@ eigrp_check_sha256_digest (struct stream *s, struct TLV_SHA256_Authentication_Ty
static void
eigrp_packet_dump (struct stream *s)
{
// not yet...
return;
// not yet...
return;
}
/*
* Converts a 24-bit integer represented as an unsigned char[3] *value
* in network byte order into uint32_t in host byte order
*/
//static uint32_t u24_32 (const unsigned char *value)
//{
// return (value[0] << 16) + (value[1] << 8) + value[2];
//}
//
///*
// * Converts an uint32_t value in host byte order into a 24-bit integer
// * in network byte order represented by unsigned char[3] *result
// */
//static unsigned char * u32_24 (uint32_t value, unsigned char *result)
//{
// value = htonl(value & 0x00FFFFFF);
// memcpy (result, (unsigned char *) &value + 1, 3);
//
// return result;
//}
int
eigrp_write (struct thread *thread)
{
@ -369,7 +349,7 @@ eigrp_write (struct thread *thread)
#ifdef WANT_EIGRP_WRITE_FRAGMENT
/* seed ipid static with low order bits of time */
if (ipid == 0)
ipid = (time(NULL) & 0xffff);
ipid = (time(NULL) & 0xffff);
#endif /* WANT_EIGRP_WRITE_FRAGMENT */
/* Get one packet from queue. */
@ -438,15 +418,15 @@ eigrp_write (struct thread *thread)
eigrph = (struct eigrp_header *) STREAM_DATA(ep->s);
opcode = eigrph->opcode;
zlog_debug("Sending [%s] to [%s] via [%s] ret [%d].",
LOOKUP(eigrp_packet_type_str, opcode), inet_ntoa(ep->dst),
IF_NAME(ei), ret);
LOOKUP(eigrp_packet_type_str, opcode), inet_ntoa(ep->dst),
IF_NAME(ei), ret);
}
if (ret < 0)
zlog_warn("*** sendmsg in eigrp_write failed to %s, "
"id %d, off %d, len %d, interface %s, mtu %u: %s",
inet_ntoa(iph.ip_dst), iph.ip_id, iph.ip_off, iph.ip_len, ei->ifp->name,
ei->ifp->mtu, safe_strerror(errno));
"id %d, off %d, len %d, interface %s, mtu %u: %s",
inet_ntoa(iph.ip_dst), iph.ip_id, iph.ip_off, iph.ip_len, ei->ifp->name,
ei->ifp->mtu, safe_strerror(errno));
/* Show debug sending packet. */
if (IS_DEBUG_EIGRP_TRANSMIT(0, SEND) && (IS_DEBUG_EIGRP_TRANSMIT(0, PACKET_DETAIL)))
@ -504,29 +484,29 @@ eigrp_read (struct thread *thread)
}
/* Note that there should not be alignment problems with this assignment
because this is at the beginning of the stream data buffer. */
because this is at the beginning of the stream data buffer. */
iph = (struct ip *)STREAM_DATA(ibuf);
//Substract IPv4 header size from EIGRP Packet itself
if(iph->ip_v == 4)
length = (iph->ip_len) - 20U;
length = (iph->ip_len) - 20U;
/* IP Header dump. */
if (IS_DEBUG_EIGRP_TRANSMIT(0, RECV) && IS_DEBUG_EIGRP_TRANSMIT(0, PACKET_DETAIL))
eigrp_ip_header_dump(iph);
eigrp_ip_header_dump(iph);
/* Note that sockopt_iphdrincl_swab_systoh was called in eigrp_recv_packet. */
if (ifp == NULL)
{
struct connected *c;
/* Handle cases where the platform does not support retrieving the ifindex,
and also platforms (such as Solaris 8) that claim to support ifindex
retrieval but do not. */
and also platforms (such as Solaris 8) that claim to support ifindex
retrieval but do not. */
c = if_lookup_address((void *)&iph->ip_src, AF_INET, VRF_DEFAULT);
if (c == NULL)
return 0;
return 0;
ifp = c->ifp;
}
@ -547,13 +527,13 @@ eigrp_read (struct thread *thread)
(IPV4_ADDR_SAME(&iph->ip_src.s_addr, &ei->address->u.prefix4)))
{
if (IS_DEBUG_EIGRP_TRANSMIT(0, RECV))
zlog_debug("eigrp_read[%s]: Dropping self-originated packet",
inet_ntoa(iph->ip_src));
zlog_debug("eigrp_read[%s]: Dropping self-originated packet",
inet_ntoa(iph->ip_src));
return 0;
}
/* Advance from IP header to EIGRP header (iph->ip_hl has been verified
by eigrp_recv_packet() to be correct). */
by eigrp_recv_packet() to be correct). */
stream_forward_getp(ibuf, (iph->ip_hl * 4));
eigrph = (struct eigrp_header *) STREAM_PNT(ibuf);
@ -561,18 +541,18 @@ eigrp_read (struct thread *thread)
if (IS_DEBUG_EIGRP_TRANSMIT(0, RECV) && IS_DEBUG_EIGRP_TRANSMIT(0, PACKET_DETAIL))
eigrp_header_dump(eigrph);
// if (MSG_OK != eigrp_packet_examin(eigrph, stream_get_endp(ibuf) - stream_get_getp(ibuf)))
// return -1;
// if (MSG_OK != eigrp_packet_examin(eigrph, stream_get_endp(ibuf) - stream_get_getp(ibuf)))
// return -1;
/* Now it is safe to access all fields of EIGRP packet header. */
/* associate packet with eigrp interface */
ei = eigrp_if_lookup_recv_if(eigrp, iph->ip_src, ifp);
/* eigrp_verify_header() relies on a valid "ei" and thus can be called only
after the checks below are passed. These checks in turn access the
fields of unverified "eigrph" structure for their own purposes and
must remain very accurate in doing this.
*/
after the checks below are passed. These checks in turn access the
fields of unverified "eigrph" structure for their own purposes and
must remain very accurate in doing this.
*/
if (!ei)
return 0;
@ -582,22 +562,22 @@ eigrp_read (struct thread *thread)
char buf[3][INET_ADDRSTRLEN];
if (IS_DEBUG_EIGRP_TRANSMIT(0, RECV))
zlog_debug("ignoring packet from router %s sent to %s, "
"received on a passive interface, %s",
inet_ntop(AF_INET, &eigrph->vrid, buf[0], sizeof(buf[0])),
inet_ntop(AF_INET, &iph->ip_dst, buf[1], sizeof(buf[1])),
inet_ntop(AF_INET, &ei->address->u.prefix4,
buf[2], sizeof(buf[2])));
zlog_debug("ignoring packet from router %s sent to %s, "
"received on a passive interface, %s",
inet_ntop(AF_INET, &eigrph->vrid, buf[0], sizeof(buf[0])),
inet_ntop(AF_INET, &iph->ip_dst, buf[1], sizeof(buf[1])),
inet_ntop(AF_INET, &ei->address->u.prefix4,
buf[2], sizeof(buf[2])));
if (iph->ip_dst.s_addr == htonl(EIGRP_MULTICAST_ADDRESS))
{
/* Try to fix multicast membership.
* Some OS:es may have problems in this area,
* make sure it is removed.
*/
EI_MEMBER_JOINED(ei, MEMBER_ALLROUTERS);
eigrp_if_set_multicast(ei);
}
/* Try to fix multicast membership.
* Some OS:es may have problems in this area,
* make sure it is removed.
*/
EI_MEMBER_JOINED(ei, MEMBER_ALLROUTERS);
eigrp_if_set_multicast(ei);
}
return 0;
}
@ -608,7 +588,7 @@ eigrp_read (struct thread *thread)
{
if (IS_DEBUG_EIGRP_TRANSMIT(0, RECV))
zlog_warn("Packet from [%s] received on wrong link %s",
inet_ntoa(iph->ip_src), ifp->name);
inet_ntoa(iph->ip_src), ifp->name);
return 0;
}
@ -628,13 +608,12 @@ eigrp_read (struct thread *thread)
if (IS_DEBUG_EIGRP_TRANSMIT(0, RECV))
zlog_debug("Received [%s] length [%u] via [%s] src [%s] dst [%s]",
LOOKUP(eigrp_packet_type_str, opcode), length,
IF_NAME(ei), inet_ntoa(iph->ip_src), inet_ntoa(iph->ip_dst));
LOOKUP(eigrp_packet_type_str, opcode), length,
IF_NAME(ei), inet_ntoa(iph->ip_src), inet_ntoa(iph->ip_dst));
/* Read rest of the packet and call each sort of packet routine. */
stream_forward_getp(ibuf, EIGRP_HEADER_LEN);
/* New testing block of code for handling Acks */
if (ntohl(eigrph->ack) != 0)
{
@ -643,42 +622,43 @@ eigrp_read (struct thread *thread)
/* neighbor must be valid, eigrp_nbr_get creates if none existed */
assert(nbr);
struct eigrp_packet *ep;
struct eigrp_packet *ep;
ep = eigrp_fifo_tail(nbr->retrans_queue);
if (ep != NULL)
{
if (ntohl(eigrph->ack) == ep->sequence_number)
{
if((nbr->state == EIGRP_NEIGHBOR_PENDING) && (ntohl(eigrph->ack) == nbr->init_sequence_number))
{
eigrp_nbr_state_set(nbr, EIGRP_NEIGHBOR_UP);
zlog_info("Neighbor adjacency became full");
nbr->init_sequence_number = 0;
nbr->recv_sequence_number = ntohl(eigrph->sequence);
eigrp_update_send_EOT(nbr);
}
ep = eigrp_fifo_pop_tail(nbr->retrans_queue);
/*eigrp_packet_free(ep);*/
if (nbr->retrans_queue->count > 0)
ep = eigrp_fifo_tail(nbr->retrans_queue);
if (ep != NULL)
{
if (ntohl(eigrph->ack) == ep->sequence_number)
{
if((nbr->state == EIGRP_NEIGHBOR_PENDING) &&
(ntohl(eigrph->ack) == nbr->init_sequence_number))
{
eigrp_nbr_state_set(nbr, EIGRP_NEIGHBOR_UP);
zlog_info("Neighbor adjacency became full");
nbr->init_sequence_number = 0;
nbr->recv_sequence_number = ntohl(eigrph->sequence);
eigrp_update_send_EOT(nbr);
}
ep = eigrp_fifo_pop_tail(nbr->retrans_queue);
/*eigrp_packet_free(ep);*/
if (nbr->retrans_queue->count > 0)
{
eigrp_send_packet_reliably(nbr);
}
}
}
ep = eigrp_fifo_tail(nbr->multicast_queue);
if (ep != NULL)
{
if (ntohl(eigrph->ack) == ep->sequence_number)
{
ep = eigrp_fifo_pop_tail(nbr->multicast_queue);
eigrp_packet_free(ep);
if (nbr->multicast_queue->count > 0)
{
eigrp_send_packet_reliably(nbr);
}
}
}
}
}
ep = eigrp_fifo_tail(nbr->multicast_queue);
if (ep != NULL)
{
if (ntohl(eigrph->ack) == ep->sequence_number)
{
ep = eigrp_fifo_pop_tail(nbr->multicast_queue);
eigrp_packet_free(ep);
if (nbr->multicast_queue->count > 0)
{
eigrp_send_packet_reliably(nbr);
}
}
}
}
@ -710,7 +690,7 @@ eigrp_read (struct thread *thread)
break;
default:
zlog_warn("interface %s: EIGRP packet header type %d unsupported",
IF_NAME(ei), opcode);
IF_NAME(ei), opcode);
break;
}
@ -744,12 +724,12 @@ eigrp_recv_packet (int fd, struct interface **ifp, struct stream *ibuf)
if ((unsigned int) ret < sizeof(iph)) /* ret must be > 0 now */
{
zlog_warn("eigrp_recv_packet: discarding runt packet of length %d "
"(ip header size is %u)", ret, (u_int) sizeof(iph));
"(ip header size is %u)", ret, (u_int) sizeof(iph));
return NULL;
}
/* Note that there should not be alignment problems with this assignment
because this is at the beginning of the stream data buffer. */
because this is at the beginning of the stream data buffer. */
iph = (struct ip *) STREAM_DATA(ibuf);
sockopt_iphdrincl_swab_systoh(iph);
@ -789,7 +769,7 @@ eigrp_recv_packet (int fd, struct interface **ifp, struct stream *ibuf)
if (ret != ip_len)
{
zlog_warn("eigrp_recv_packet read length mismatch: ip_len is %d, "
"but recvmsg returned %d", ip_len, ret);
"but recvmsg returned %d", ip_len, ret);
return NULL;
}
@ -867,7 +847,7 @@ eigrp_send_packet_reliably (struct eigrp_neighbor *nbr)
/*Start retransmission timer*/
THREAD_TIMER_ON(master, ep->t_retrans_timer, eigrp_unack_packet_retrans,
nbr, EIGRP_PACKET_RETRANS_TIME);
nbr, EIGRP_PACKET_RETRANS_TIME);
/*Increment sequence number counter*/
nbr->ei->eigrp->sequence_number++;
@ -880,14 +860,14 @@ eigrp_send_packet_reliably (struct eigrp_neighbor *nbr)
}
if (nbr->ei->eigrp->t_write == NULL)
nbr->ei->eigrp->t_write =
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd);
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd);
}
}
/* Calculate EIGRP checksum */
void
eigrp_packet_checksum (struct eigrp_interface *ei, struct stream *s,
u_int16_t length)
u_int16_t length)
{
struct eigrp_header *eigrph;
@ -900,7 +880,7 @@ eigrp_packet_checksum (struct eigrp_interface *ei, struct stream *s,
/* Make EIGRP header. */
void
eigrp_packet_header_init (int type, struct eigrp_interface *ei, struct stream *s,
u_int32_t flags, u_int32_t sequence, u_int32_t ack)
u_int32_t flags, u_int32_t sequence, u_int32_t ack)
{
struct eigrp_header *eigrph;
@ -914,13 +894,13 @@ eigrp_packet_header_init (int type, struct eigrp_interface *ei, struct stream *s
eigrph->ASNumber = htons(ei->eigrp->AS);
eigrph->ack = htonl(ack);
eigrph->sequence = htonl(sequence);
// if(flags == EIGRP_INIT_FLAG)
// eigrph->sequence = htonl(3);
// if(flags == EIGRP_INIT_FLAG)
// eigrph->sequence = htonl(3);
eigrph->flags = htonl(flags);
if (IS_DEBUG_EIGRP_TRANSMIT(0, RECV))
zlog_debug("Packet Header Init Seq [%u] Ack [%u]",
htonl(eigrph->sequence), htonl(eigrph->ack));
htonl(eigrph->sequence), htonl(eigrph->ack));
stream_forward_endp(s, EIGRP_HEADER_LEN);
}
@ -1007,27 +987,26 @@ eigrp_packet_free (struct eigrp_packet *ep)
/* EIGRP Header verification. */
static int
eigrp_verify_header (struct stream *ibuf, struct eigrp_interface *ei,
struct ip *iph, struct eigrp_header *eigrph)
struct ip *iph, struct eigrp_header *eigrph)
{
/* Check network mask, Silently discarded. */
if (!eigrp_check_network_mask(ei, iph->ip_src))
{
zlog_warn("interface %s: eigrp_read network address is not same [%s]",
IF_NAME(ei), inet_ntoa(iph->ip_src));
IF_NAME(ei), inet_ntoa(iph->ip_src));
return -1;
}
//
// /* Check authentication. The function handles logging actions, where required. */
// if (! eigrp_check_auth(ei, eigrph))
// return -1;
//
// /* Check authentication. The function handles logging actions, where required. */
// if (! eigrp_check_auth(ei, eigrph))
// return -1;
return 0;
}
/* Unbound socket will accept any Raw IP packets if proto is matched.
To prevent it, compare src IP address and i/f address with masking
i/f network mask. */
To prevent it, compare src IP address and i/f address with masking
i/f network mask. */
static int
eigrp_check_network_mask (struct eigrp_interface *ei, struct in_addr ip_src)
{
@ -1080,7 +1059,7 @@ eigrp_unack_packet_retrans (struct thread *thread)
}
if (nbr->ei->eigrp->t_write == NULL)
nbr->ei->eigrp->t_write =
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd);
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd);
}
return 0;
@ -1108,7 +1087,7 @@ eigrp_unack_multicast_packet_retrans (struct thread *thread)
/*Start retransmission timer*/
ep->t_retrans_timer =
thread_add_timer(master, eigrp_unack_multicast_packet_retrans, nbr,EIGRP_PACKET_RETRANS_TIME);
thread_add_timer(master, eigrp_unack_multicast_packet_retrans, nbr,EIGRP_PACKET_RETRANS_TIME);
/* Hook thread to write packet. */
if (nbr->ei->on_write_q == 0)
@ -1118,7 +1097,7 @@ eigrp_unack_multicast_packet_retrans (struct thread *thread)
}
if (nbr->ei->eigrp->t_write == NULL)
nbr->ei->eigrp->t_write =
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd);
thread_add_write(master, eigrp_write, nbr->ei->eigrp, nbr->ei->eigrp->fd);
}
return 0;
@ -1189,22 +1168,22 @@ eigrp_read_ipv4_tlv (struct stream *s)
{
tlv->destination_part[0] = stream_getc(s);
tlv->destination.s_addr = (tlv->destination_part[0]);
}
else if (tlv->prefix_length > 8 && tlv->prefix_length <= 16)
{
tlv->destination_part[0] = stream_getc(s);
tlv->destination_part[1] = stream_getc(s);
tlv->destination.s_addr = ((tlv->destination_part[1] << 8)
+ tlv->destination_part[0]);
+ tlv->destination_part[0]);
}
else if (tlv->prefix_length > 16 && tlv->prefix_length <= 24)
{
tlv->destination_part[0] = stream_getc(s);
tlv->destination_part[1] = stream_getc(s);
tlv->destination_part[2] = stream_getc(s);
tlv->destination.s_addr = ((tlv->destination_part[2] << 16)
+ (tlv->destination_part[1] << 8) + tlv->destination_part[0]);
tlv->destination.s_addr = ((tlv->destination_part[2] << 16) +
(tlv->destination_part[1] << 8) +
tlv->destination_part[0]);
}
else if (tlv->prefix_length > 24 && tlv->prefix_length <= 32)
{
@ -1212,16 +1191,17 @@ eigrp_read_ipv4_tlv (struct stream *s)
tlv->destination_part[1] = stream_getc(s);
tlv->destination_part[2] = stream_getc(s);
tlv->destination_part[3] = stream_getc(s);
tlv->destination.s_addr = ((tlv->destination_part[3] << 24)
+ (tlv->destination_part[2] << 16) + (tlv->destination_part[1] << 8)
+ tlv->destination_part[0]);
tlv->destination.s_addr = ((tlv->destination_part[3] << 24) +
(tlv->destination_part[2] << 16) +
(tlv->destination_part[1] << 8) +
tlv->destination_part[0]);
}
return tlv;
}
u_int16_t
eigrp_add_internalTLV_to_stream (struct stream *s,
struct eigrp_prefix_entry *pe)
struct eigrp_prefix_entry *pe)
{
u_int16_t length;
@ -1295,7 +1275,7 @@ eigrp_add_internalTLV_to_stream (struct stream *s,
u_int16_t
eigrp_add_authTLV_MD5_to_stream (struct stream *s,
struct eigrp_interface *ei)
struct eigrp_interface *ei)
{
struct key *key;
struct keychain *keychain;
@ -1310,7 +1290,6 @@ eigrp_add_authTLV_MD5_to_stream (struct stream *s,
authTLV->key_sequence = 0;
memset(authTLV->Nullpad,0,sizeof(authTLV->Nullpad));
keychain = keychain_lookup(IF_DEF_PARAMS (ei->ifp)->auth_keychain);
if(keychain)
key = key_lookup_for_send(keychain);
@ -1338,7 +1317,7 @@ eigrp_add_authTLV_MD5_to_stream (struct stream *s,
u_int16_t
eigrp_add_authTLV_SHA256_to_stream (struct stream *s,
struct eigrp_interface *ei)
struct eigrp_interface *ei)
{
struct key *key;
struct keychain *keychain;
@ -1353,7 +1332,6 @@ eigrp_add_authTLV_SHA256_to_stream (struct stream *s,
authTLV->key_sequence = 0;
memset(authTLV->Nullpad,0,sizeof(authTLV->Nullpad));
keychain = keychain_lookup(IF_DEF_PARAMS (ei->ifp)->auth_keychain);
if(keychain)
key = key_lookup_for_send(keychain);
@ -1377,7 +1355,6 @@ eigrp_add_authTLV_SHA256_to_stream (struct stream *s,
eigrp_authTLV_SHA256_free(authTLV);
return 0;
}
struct TLV_MD5_Authentication_Type *
@ -1393,7 +1370,6 @@ eigrp_authTLV_MD5_new ()
void
eigrp_authTLV_MD5_free (struct TLV_MD5_Authentication_Type *authTLV)
{
XFREE(MTYPE_EIGRP_AUTH_TLV, authTLV);
}
@ -1410,11 +1386,9 @@ eigrp_authTLV_SHA256_new ()
void
eigrp_authTLV_SHA256_free (struct TLV_SHA256_Authentication_Type *authTLV)
{
XFREE(MTYPE_EIGRP_AUTH_SHA256_TLV, authTLV);
}
struct TLV_IPv4_Internal_type *
eigrp_IPv4_InternalTLV_new ()
{
@ -1428,7 +1402,6 @@ eigrp_IPv4_InternalTLV_new ()
void
eigrp_IPv4_InternalTLV_free (struct TLV_IPv4_Internal_type *IPv4_InternalTLV)
{
XFREE(MTYPE_EIGRP_IPV4_INT_TLV, IPv4_InternalTLV);
}

58
eigrpd/eigrp_query.c
View File

@ -122,17 +122,17 @@ eigrp_query_receive (struct eigrp *eigrp, struct ip *iph, struct eigrp_header *e
dest_addr = prefix_ipv4_new();
dest_addr->prefix = tlv->destination;
dest_addr->prefixlen = tlv->prefix_length;
struct eigrp_prefix_entry *dest = eigrp_topology_table_lookup_ipv4(
eigrp->topology_table, dest_addr);
struct eigrp_prefix_entry *dest =
eigrp_topology_table_lookup_ipv4(eigrp->topology_table, dest_addr);
/* If the destination exists (it should, but one never know)*/
if (dest != NULL)
{
struct eigrp_fsm_action_message *msg;
msg = XCALLOC(MTYPE_EIGRP_FSM_MSG,
sizeof(struct eigrp_fsm_action_message));
struct eigrp_neighbor_entry *entry = eigrp_prefix_entry_lookup(
dest->entries, nbr);
sizeof(struct eigrp_fsm_action_message));
struct eigrp_neighbor_entry *entry =
eigrp_prefix_entry_lookup(dest->entries, nbr);
msg->packet_type = EIGRP_OPC_QUERY;
msg->eigrp = eigrp;
msg->data_type = EIGRP_TLV_IPv4_INT;
@ -168,7 +168,8 @@ eigrp_send_query (struct eigrp_interface *ei)
ei->eigrp->sequence_number, 0);
// encode Authentication TLV, if needed
if((IF_DEF_PARAMS (ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) && (IF_DEF_PARAMS (ei->ifp)->auth_keychain != NULL))
if((IF_DEF_PARAMS (ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) &&
(IF_DEF_PARAMS (ei->ifp)->auth_keychain != NULL))
{
length += eigrp_add_authTLV_MD5_to_stream(ep->s,ei);
}
@ -181,11 +182,11 @@ eigrp_send_query (struct eigrp_interface *ei)
length += eigrp_add_internalTLV_to_stream(ep->s, pe);
for (ALL_LIST_ELEMENTS(ei->nbrs, node2, nnode2, nbr))
{
if(nbr->state == EIGRP_NEIGHBOR_UP)
{
listnode_add(pe->rij, nbr);
if(nbr->state == EIGRP_NEIGHBOR_UP)
{
listnode_add(pe->rij, nbr);
has_tlv = 1;
}
}
}
}
}
@ -196,31 +197,32 @@ eigrp_send_query (struct eigrp_interface *ei)
return;
}
if((IF_DEF_PARAMS (ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) && (IF_DEF_PARAMS (ei->ifp)->auth_keychain != NULL))
if((IF_DEF_PARAMS (ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) &&
(IF_DEF_PARAMS (ei->ifp)->auth_keychain != NULL))
{
eigrp_make_md5_digest(ei,ep->s, EIGRP_AUTH_UPDATE_FLAG);
}
/* EIGRP Checksum */
eigrp_packet_checksum(ei, ep->s, length);
eigrp_packet_checksum(ei, ep->s, length);
ep->length = length;
ep->dst.s_addr = htonl(EIGRP_MULTICAST_ADDRESS);
ep->length = length;
ep->dst.s_addr = htonl(EIGRP_MULTICAST_ADDRESS);
/*This ack number we await from neighbor*/
ep->sequence_number = ei->eigrp->sequence_number;
/*This ack number we await from neighbor*/
ep->sequence_number = ei->eigrp->sequence_number;
for (ALL_LIST_ELEMENTS(ei->nbrs, node2, nnode2, nbr))
{
if (nbr->state == EIGRP_NEIGHBOR_UP)
{
/*Put packet to retransmission queue*/
eigrp_fifo_push_head(nbr->retrans_queue, ep);
for (ALL_LIST_ELEMENTS(ei->nbrs, node2, nnode2, nbr))
{
if (nbr->state == EIGRP_NEIGHBOR_UP)
{
/*Put packet to retransmission queue*/
eigrp_fifo_push_head(nbr->retrans_queue, ep);
if (nbr->retrans_queue->count == 1)
{
eigrp_send_packet_reliably(nbr);
}
}
}
if (nbr->retrans_queue->count == 1)
{
eigrp_send_packet_reliably(nbr);
}
}
}
}

96
eigrpd/eigrp_reply.c
View File

@ -89,18 +89,20 @@ eigrp_send_reply (struct eigrp_neighbor *nbr, struct eigrp_prefix_entry *pe)
zlog_info("REPLY SEND Prefix: %s", inet_ntoa(nbr->src));
/* Check if any list fits */
if ((alist && access_list_apply (alist, (struct prefix *) pe2->destination_ipv4) == FILTER_DENY)||
(plist && prefix_list_apply (plist, (struct prefix *) pe2->destination_ipv4) == PREFIX_DENY)||
(alist_i && access_list_apply (alist_i, (struct prefix *) pe2->destination_ipv4) == FILTER_DENY)||
(plist_i && prefix_list_apply (plist_i, (struct prefix *) pe2->destination_ipv4) == PREFIX_DENY))
{
zlog_info("REPLY SEND: Setting Metric to max");
pe2->reported_metric.delay = EIGRP_MAX_METRIC;
} else {
zlog_info("REPLY SEND: Not setting metric");
}
if ((alist &&
access_list_apply (alist, (struct prefix *) pe2->destination_ipv4) == FILTER_DENY) ||
(plist && prefix_list_apply (plist, (struct prefix *) pe2->destination_ipv4) == PREFIX_DENY)||
(alist_i && access_list_apply (alist_i, (struct prefix *) pe2->destination_ipv4) == FILTER_DENY)||
(plist_i && prefix_list_apply (plist_i, (struct prefix *) pe2->destination_ipv4) == PREFIX_DENY))
{
zlog_info("REPLY SEND: Setting Metric to max");
pe2->reported_metric.delay = EIGRP_MAX_METRIC;
}
else
{
zlog_info("REPLY SEND: Not setting metric");
}
/*
* End of filtering
@ -113,7 +115,8 @@ eigrp_send_reply (struct eigrp_neighbor *nbr, struct eigrp_prefix_entry *pe)
nbr->ei->eigrp->sequence_number, 0);
// encode Authentication TLV, if needed
if((IF_DEF_PARAMS (nbr->ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) && (IF_DEF_PARAMS (nbr->ei->ifp)->auth_keychain != NULL))
if((IF_DEF_PARAMS (nbr->ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) &&
(IF_DEF_PARAMS (nbr->ei->ifp)->auth_keychain != NULL))
{
length += eigrp_add_authTLV_MD5_to_stream(ep->s,nbr->ei);
}
@ -121,7 +124,8 @@ eigrp_send_reply (struct eigrp_neighbor *nbr, struct eigrp_prefix_entry *pe)
length += eigrp_add_internalTLV_to_stream(ep->s, pe2);
if((IF_DEF_PARAMS (nbr->ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) && (IF_DEF_PARAMS (nbr->ei->ifp)->auth_keychain != NULL))
if((IF_DEF_PARAMS (nbr->ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) &&
(IF_DEF_PARAMS (nbr->ei->ifp)->auth_keychain != NULL))
{
eigrp_make_md5_digest(nbr->ei,ep->s, EIGRP_AUTH_UPDATE_FLAG);
}
@ -184,8 +188,8 @@ eigrp_reply_receive (struct eigrp *eigrp, struct ip *iph, struct eigrp_header *e
dest_addr = prefix_ipv4_new();
dest_addr->prefix = tlv->destination;
dest_addr->prefixlen = tlv->prefix_length;
struct eigrp_prefix_entry *dest = eigrp_topology_table_lookup_ipv4(
eigrp->topology_table, dest_addr);
struct eigrp_prefix_entry *dest =
eigrp_topology_table_lookup_ipv4 (eigrp->topology_table, dest_addr);
/*
* Destination must exists
*/
@ -193,9 +197,9 @@ eigrp_reply_receive (struct eigrp *eigrp, struct ip *iph, struct eigrp_header *e
struct eigrp_fsm_action_message *msg;
msg = XCALLOC(MTYPE_EIGRP_FSM_MSG,
sizeof(struct eigrp_fsm_action_message));
struct eigrp_neighbor_entry *entry = eigrp_prefix_entry_lookup(
dest->entries, nbr);
sizeof(struct eigrp_fsm_action_message));
struct eigrp_neighbor_entry *entry =
eigrp_prefix_entry_lookup(dest->entries, nbr);
/*
* Filtering
@ -210,35 +214,35 @@ eigrp_reply_receive (struct eigrp *eigrp, struct ip *iph, struct eigrp_header *e
plist_i = ei->prefix[EIGRP_FILTER_IN];
zlog_info("REPLY Receive: Filtering");
zlog_info("REPLY RECEIVE Prefix: %s", inet_ntoa(dest_addr->prefix));
/* Check if any list fits */
if ((alist && access_list_apply (alist,
(struct prefix *) dest_addr) == FILTER_DENY)||
(plist && prefix_list_apply (plist,
(struct prefix *) dest_addr) == PREFIX_DENY)||
(alist_i && access_list_apply (alist_i,
(struct prefix *) dest_addr) == FILTER_DENY)||
(plist_i && prefix_list_apply (plist_i,
(struct prefix *) dest_addr) == PREFIX_DENY))
{
zlog_info("REPLY RECEIVE: Setting metric to max");
tlv->metric.delay = EIGRP_MAX_METRIC;
zlog_info("REPLY RECEIVE Prefix: %s", inet_ntoa(dest_addr->prefix));
} else {
zlog_info("REPLY RECEIVE: Not setting metric");
}
/*
* End of filtering
*/
/* Check if any list fits */
if ((alist && access_list_apply (alist,
(struct prefix *) dest_addr) == FILTER_DENY)||
(plist && prefix_list_apply (plist,
(struct prefix *) dest_addr) == PREFIX_DENY)||
(alist_i && access_list_apply (alist_i,
(struct prefix *) dest_addr) == FILTER_DENY)||
(plist_i && prefix_list_apply (plist_i,
(struct prefix *) dest_addr) == PREFIX_DENY))
{
zlog_info("REPLY RECEIVE: Setting metric to max");
tlv->metric.delay = EIGRP_MAX_METRIC;
zlog_info("REPLY RECEIVE Prefix: %s", inet_ntoa(dest_addr->prefix));
} else {
zlog_info("REPLY RECEIVE: Not setting metric");
}
/*
* End of filtering
*/
msg->packet_type = EIGRP_OPC_REPLY;
msg->eigrp = eigrp;
msg->data_type = EIGRP_TLV_IPv4_INT;
msg->adv_router = nbr;
msg->data.ipv4_int_type = tlv;
msg->entry = entry;
msg->prefix = dest;
int event = eigrp_get_fsm_event(msg);
eigrp_fsm_event(msg, event);
msg->packet_type = EIGRP_OPC_REPLY;
msg->eigrp = eigrp;
msg->data_type = EIGRP_TLV_IPv4_INT;
msg->adv_router = nbr;
msg->data.ipv4_int_type = tlv;
msg->entry = entry;
msg->prefix = dest;
int event = eigrp_get_fsm_event(msg);
eigrp_fsm_event(msg, event);
eigrp_IPv4_InternalTLV_free (tlv);

747
eigrpd/eigrp_routemap.c
View File

File diff suppressed because it is too large Load Diff

51
eigrpd/eigrp_siaquery.c
View File

@ -58,7 +58,7 @@
/*EIGRP SIA-QUERY read function*/
void
eigrp_siaquery_receive (struct eigrp *eigrp, struct ip *iph, struct eigrp_header *eigrph,
struct stream * s, struct eigrp_interface *ei, int size)
struct stream * s, struct eigrp_interface *ei, int size)
{
struct eigrp_neighbor *nbr;
struct TLV_IPv4_Internal_type *tlv;
@ -89,17 +89,17 @@ eigrp_siaquery_receive (struct eigrp *eigrp, struct ip *iph, struct eigrp_header
dest_addr = prefix_ipv4_new();
dest_addr->prefix = tlv->destination;
dest_addr->prefixlen = tlv->prefix_length;
struct eigrp_prefix_entry *dest = eigrp_topology_table_lookup_ipv4(
eigrp->topology_table, dest_addr);
struct eigrp_prefix_entry *dest =
eigrp_topology_table_lookup_ipv4(eigrp->topology_table, dest_addr);
/* If the destination exists (it should, but one never know)*/
if (dest != NULL)
{
struct eigrp_fsm_action_message *msg;
msg = XCALLOC(MTYPE_EIGRP_FSM_MSG,
sizeof(struct eigrp_fsm_action_message));
struct eigrp_neighbor_entry *entry = eigrp_prefix_entry_lookup(
dest->entries, nbr);
sizeof(struct eigrp_fsm_action_message));
struct eigrp_neighbor_entry *entry =
eigrp_prefix_entry_lookup(dest->entries, nbr);
msg->packet_type = EIGRP_OPC_SIAQUERY;
msg->eigrp = eigrp;
msg->data_type = EIGRP_TLV_IPv4_INT;
@ -116,7 +116,6 @@ eigrp_siaquery_receive (struct eigrp *eigrp, struct ip *iph, struct eigrp_header
eigrp_hello_send_ack(nbr);
}
void
eigrp_send_siaquery (struct eigrp_neighbor *nbr, struct eigrp_prefix_entry *pe)
{
@ -127,38 +126,40 @@ eigrp_send_siaquery (struct eigrp_neighbor *nbr, struct eigrp_prefix_entry *pe)
/* Prepare EIGRP INIT UPDATE header */
eigrp_packet_header_init(EIGRP_OPC_SIAQUERY, nbr->ei, ep->s, 0,
nbr->ei->eigrp->sequence_number, 0);
nbr->ei->eigrp->sequence_number, 0);
// encode Authentication TLV, if needed
if((IF_DEF_PARAMS (nbr->ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) && (IF_DEF_PARAMS (nbr->ei->ifp)->auth_keychain != NULL))
if((IF_DEF_PARAMS (nbr->ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) &&
(IF_DEF_PARAMS (nbr->ei->ifp)->auth_keychain != NULL))
{
length += eigrp_add_authTLV_MD5_to_stream(ep->s,nbr->ei);
}
length += eigrp_add_internalTLV_to_stream(ep->s, pe);
length += eigrp_add_internalTLV_to_stream(ep->s, pe);
if((IF_DEF_PARAMS (nbr->ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) && (IF_DEF_PARAMS (nbr->ei->ifp)->auth_keychain != NULL))
if((IF_DEF_PARAMS (nbr->ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) &&
(IF_DEF_PARAMS (nbr->ei->ifp)->auth_keychain != NULL))
{
eigrp_make_md5_digest(nbr->ei,ep->s, EIGRP_AUTH_UPDATE_FLAG);
}
/* EIGRP Checksum */
eigrp_packet_checksum(nbr->ei, ep->s, length);
eigrp_packet_checksum(nbr->ei, ep->s, length);
ep->length = length;
ep->dst.s_addr = nbr->src.s_addr;
ep->length = length;
ep->dst.s_addr = nbr->src.s_addr;
/*This ack number we await from neighbor*/
ep->sequence_number = nbr->ei->eigrp->sequence_number;
/*This ack number we await from neighbor*/
ep->sequence_number = nbr->ei->eigrp->sequence_number;
if (nbr->state == EIGRP_NEIGHBOR_UP)
{
/*Put packet to retransmission queue*/
eigrp_fifo_push_head(nbr->retrans_queue, ep);
if (nbr->state == EIGRP_NEIGHBOR_UP)
{
/*Put packet to retransmission queue*/
eigrp_fifo_push_head(nbr->retrans_queue, ep);
if (nbr->retrans_queue->count == 1)
{
eigrp_send_packet_reliably(nbr);
}
}
if (nbr->retrans_queue->count == 1)
{
eigrp_send_packet_reliably(nbr);
}
}
}

51
eigrpd/eigrp_siareply.c
View File

@ -25,7 +25,6 @@
* Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*/
#include <zebra.h>
#include "thread.h"
@ -58,7 +57,7 @@
/*EIGRP SIA-REPLY read function*/
void
eigrp_siareply_receive (struct eigrp *eigrp, struct ip *iph, struct eigrp_header *eigrph,
struct stream * s, struct eigrp_interface *ei, int size)
struct stream * s, struct eigrp_interface *ei, int size)
{
struct eigrp_neighbor *nbr;
struct TLV_IPv4_Internal_type *tlv;
@ -89,17 +88,17 @@ eigrp_siareply_receive (struct eigrp *eigrp, struct ip *iph, struct eigrp_header
dest_addr = prefix_ipv4_new();
dest_addr->prefix = tlv->destination;
dest_addr->prefixlen = tlv->prefix_length;
struct eigrp_prefix_entry *dest = eigrp_topology_table_lookup_ipv4(
eigrp->topology_table, dest_addr);
struct eigrp_prefix_entry *dest =
eigrp_topology_table_lookup_ipv4(eigrp->topology_table, dest_addr);
/* If the destination exists (it should, but one never know)*/
if (dest != NULL)
{
struct eigrp_fsm_action_message *msg;
msg = XCALLOC(MTYPE_EIGRP_FSM_MSG,
sizeof(struct eigrp_fsm_action_message));
struct eigrp_neighbor_entry *entry = eigrp_prefix_entry_lookup(
dest->entries, nbr);
sizeof(struct eigrp_fsm_action_message));
struct eigrp_neighbor_entry *entry =
eigrp_prefix_entry_lookup(dest->entries, nbr);
msg->packet_type = EIGRP_OPC_SIAQUERY;
msg->eigrp = eigrp;
msg->data_type = EIGRP_TLV_IPv4_INT;
@ -126,40 +125,42 @@ eigrp_send_siareply (struct eigrp_neighbor *nbr, struct eigrp_prefix_entry *pe)
/* Prepare EIGRP INIT UPDATE header */
eigrp_packet_header_init(EIGRP_OPC_SIAREPLY, nbr->ei, ep->s, 0,
nbr->ei->eigrp->sequence_number, 0);
nbr->ei->eigrp->sequence_number, 0);
// encode Authentication TLV, if needed
if((IF_DEF_PARAMS (nbr->ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) && (IF_DEF_PARAMS (nbr->ei->ifp)->auth_keychain != NULL))
if((IF_DEF_PARAMS (nbr->ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) &&
(IF_DEF_PARAMS (nbr->ei->ifp)->auth_keychain != NULL))
{
length += eigrp_add_authTLV_MD5_to_stream(ep->s,nbr->ei);
}
length += eigrp_add_internalTLV_to_stream(ep->s, pe);
length += eigrp_add_internalTLV_to_stream(ep->s, pe);
if((IF_DEF_PARAMS (nbr->ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) && (IF_DEF_PARAMS (nbr->ei->ifp)->auth_keychain != NULL))
if((IF_DEF_PARAMS (nbr->ei->ifp)->auth_type == EIGRP_AUTH_TYPE_MD5) &&
(IF_DEF_PARAMS (nbr->ei->ifp)->auth_keychain != NULL))
{
eigrp_make_md5_digest(nbr->ei,ep->s, EIGRP_AUTH_UPDATE_FLAG);
}
/* EIGRP Checksum */
eigrp_packet_checksum(nbr->ei, ep->s, length);
eigrp_packet_checksum(nbr->ei, ep->s, length);
ep->length = length;
ep->dst.s_addr = nbr->src.s_addr;
ep->length = length;
ep->dst.s_addr = nbr->src.s_addr;
/*This ack number we await from neighbor*/
ep->sequence_number = nbr->ei->eigrp->sequence_number;
/*This ack number we await from neighbor*/
ep->sequence_number = nbr->ei->eigrp->sequence_number;
if (nbr->state == EIGRP_NEIGHBOR_UP)
{
/*Put packet to retransmission queue*/
eigrp_fifo_push_head(nbr->retrans_queue, ep);
if (nbr->state == EIGRP_NEIGHBOR_UP)
{
/*Put packet to retransmission queue*/
eigrp_fifo_push_head(nbr->retrans_queue, ep);
if (nbr->retrans_queue->count == 1)
{
eigrp_send_packet_reliably(nbr);
}
}
if (nbr->retrans_queue->count == 1)
{
eigrp_send_packet_reliably(nbr);
}
}
}

2238
eigrpd/eigrp_snmp.c
View File

File diff suppressed because it is too large Load Diff

84
eigrpd/eigrp_topology.c
View File

@ -52,17 +52,12 @@
#include "eigrpd/eigrp_fsm.h"
#include "eigrpd/eigrp_memory.h"
static int
eigrp_prefix_entry_cmp(struct eigrp_prefix_entry *, struct eigrp_prefix_entry *);
static void
eigrp_prefix_entry_del(struct eigrp_prefix_entry *);
static int
eigrp_neighbor_entry_cmp(struct eigrp_neighbor_entry *,
struct eigrp_neighbor_entry *);
static int eigrp_prefix_entry_cmp(struct eigrp_prefix_entry *, struct eigrp_prefix_entry *);
static void eigrp_prefix_entry_del(struct eigrp_prefix_entry *);
static int eigrp_neighbor_entry_cmp(struct eigrp_neighbor_entry *,
struct eigrp_neighbor_entry *);
/*
* asdf;laksdjf;lajsdf;kasdjf;asdjf;
* asdfaskdjfa;sdkjf;adlskj
* Returns linkedlist used as topology table
* cmp - assigned function for comparing topology nodes
* del - assigned function executed before deleting topology node by list function
@ -72,9 +67,9 @@ eigrp_topology_new()
{
struct list* new = list_new();
new->cmp = (int
(*)(void *, void *)) eigrp_prefix_entry_cmp;
(*)(void *, void *)) eigrp_prefix_entry_cmp;
new->del = (void
(*)(void *)) eigrp_prefix_entry_del;
(*)(void *)) eigrp_prefix_entry_del;
return new;
}
@ -85,7 +80,7 @@ eigrp_topology_new()
static int
eigrp_prefix_entry_cmp(struct eigrp_prefix_entry *node1,
struct eigrp_prefix_entry *node2)
struct eigrp_prefix_entry *node2)
{
if (node1->af == AF_INET)
{
@ -135,7 +130,6 @@ eigrp_prefix_entry_del(struct eigrp_prefix_entry *node)
* Returns new created toplogy node
* cmp - assigned function for comparing topology entry
*/
struct eigrp_prefix_entry *
eigrp_prefix_entry_new()
{
@ -154,10 +148,9 @@ eigrp_prefix_entry_new()
/*
* Topology entry comparison
*/
static int
eigrp_neighbor_entry_cmp(struct eigrp_neighbor_entry *entry1,
struct eigrp_neighbor_entry *entry2)
struct eigrp_neighbor_entry *entry2)
{
if (entry1->distance < entry2->distance) // parameter used in list_add_sort ()
return -1; // actually set to sort by distance
@ -177,7 +170,7 @@ eigrp_neighbor_entry_new()
struct eigrp_neighbor_entry *new;
new = XCALLOC(MTYPE_EIGRP_NEIGHBOR_ENTRY,
sizeof(struct eigrp_neighbor_entry));
sizeof(struct eigrp_neighbor_entry));
new->reported_distance = EIGRP_MAX_METRIC;
new->distance = EIGRP_MAX_METRIC;
@ -187,7 +180,6 @@ eigrp_neighbor_entry_new()
/*
* Freeing topology table list
*/
void
eigrp_topology_free(struct list *list)
{
@ -197,7 +189,6 @@ eigrp_topology_free(struct list *list)
/*
* Deleting all topology nodes in table
*/
void
eigrp_topology_cleanup(struct list *topology)
{
@ -209,7 +200,6 @@ eigrp_topology_cleanup(struct list *topology)
/*
* Adding topology node to topology table
*/
void
eigrp_prefix_entry_add(struct list *topology, struct eigrp_prefix_entry *node)
{
@ -222,10 +212,9 @@ eigrp_prefix_entry_add(struct list *topology, struct eigrp_prefix_entry *node)
/*
* Adding topology entry to topology node
*/
void
eigrp_neighbor_entry_add(struct eigrp_prefix_entry *node,
struct eigrp_neighbor_entry *entry)
struct eigrp_neighbor_entry *entry)
{
if (listnode_lookup(node->entries, entry) == NULL)
{
@ -237,10 +226,9 @@ eigrp_neighbor_entry_add(struct eigrp_prefix_entry *node,
/*
* Deleting topology node from topology table
*/
void
eigrp_prefix_entry_delete(struct list *topology,
struct eigrp_prefix_entry *node)
struct eigrp_prefix_entry *node)
{
struct eigrp *eigrp = eigrp_lookup ();
@ -263,10 +251,9 @@ eigrp_prefix_entry_delete(struct list *topology,
/*
* Deleting topology entry from topology node
*/
void
eigrp_neighbor_entry_delete(struct eigrp_prefix_entry *node,
struct eigrp_neighbor_entry *entry)
struct eigrp_neighbor_entry *entry)
{
if (listnode_lookup(node->entries, entry) != NULL)
{
@ -278,7 +265,6 @@ eigrp_neighbor_entry_delete(struct eigrp_prefix_entry *node,
/*
* Deleting all nodes from topology table
*/
void
eigrp_topology_delete_all(struct list *topology)
{
@ -289,7 +275,6 @@ eigrp_topology_delete_all(struct list *topology)
* Return 0 if topology is not empty
* otherwise return 1
*/
unsigned int
eigrp_topology_table_isempty(struct list *topology)
{
@ -301,13 +286,12 @@ eigrp_topology_table_isempty(struct list *topology)
struct eigrp_prefix_entry *
eigrp_topology_table_lookup_ipv4(struct list *topology_table,
struct prefix_ipv4 * address)
struct prefix_ipv4 * address)
{
struct eigrp_prefix_entry *data;
struct listnode *node;
for (ALL_LIST_ELEMENTS_RO(topology_table, node, data))
{
if ((data->af == AF_INET)
&& (data->destination_ipv4->prefix.s_addr == address->prefix.s_addr)
&& (data->destination_ipv4->prefixlen == address->prefixlen))
@ -353,19 +337,19 @@ eigrp_topology_get_successor(struct eigrp_prefix_entry *table_node)
struct list *
eigrp_topology_get_successor_max(struct eigrp_prefix_entry *table_node,
unsigned int maxpaths)
unsigned int maxpaths)
{
struct list *successors = eigrp_topology_get_successor(table_node);
if (successors && successors->count > maxpaths)
{
do
{
struct listnode *node = listtail(successors);
{
struct listnode *node = listtail(successors);
list_delete_node(successors, node);
list_delete_node(successors, node);
} while (successors->count > maxpaths);
} while (successors->count > maxpaths);
}
return successors;
@ -401,13 +385,13 @@ eigrp_neighbor_prefixes_lookup(struct eigrp *eigrp, struct eigrp_neighbor *nbr)
/* iterate over all prefixes in topology table */
for (ALL_LIST_ELEMENTS(eigrp->topology_table, node1, node11, prefix))
{
/* iterate over all neighbor entry in prefix */
/* iterate over all neighbor entry in prefix */
for (ALL_LIST_ELEMENTS(prefix->entries, node2, node22, entry))
{
/* if entry is from specified neighbor, add to list */
/* if entry is from specified neighbor, add to list */
if (entry->adv_router == nbr)
{
listnode_add(prefixes, prefix);
listnode_add(prefixes, prefix);
}
}
}
@ -435,20 +419,20 @@ eigrp_topology_update_distance(struct eigrp_fsm_action_message *msg)
return 0; // No change
}
change =
entry->reported_distance
< eigrp_calculate_metrics(eigrp, &int_data->metric) ? 1 :
entry->reported_distance
< eigrp_calculate_metrics(eigrp, &int_data->metric) ? 1 :
entry->reported_distance
> eigrp_calculate_metrics(eigrp, &int_data->metric) ? 2 : 3; // Increase : Decrease : No change
> eigrp_calculate_metrics(eigrp, &int_data->metric) ? 2 : 3; // Increase : Decrease : No change
entry->reported_metric = int_data->metric;
entry->reported_distance = eigrp_calculate_metrics(eigrp,
&int_data->metric);
entry->reported_distance =
eigrp_calculate_metrics(eigrp, &int_data->metric);
entry->distance = eigrp_calculate_total_metrics(eigrp, entry);
}
else
{
ext_data = msg->data.ipv4_ext_data;
if (eigrp_metrics_is_same (&ext_data->metric, &entry->reported_metric))
return 0;
return 0;
}
/*
* Move to correct position in list according to new distance
@ -481,7 +465,7 @@ eigrp_topology_update_node_flags(struct eigrp_prefix_entry *dest)
for (ALL_LIST_ELEMENTS_RO(dest->entries, node, entry))
{
if ((entry->distance <= (u_int64_t)(dest->distance*eigrp->variance)) &&
entry->distance != EIGRP_MAX_METRIC) // is successor
entry->distance != EIGRP_MAX_METRIC) // is successor
{
entry->flags |= EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG;
entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_FSUCCESSOR_FLAG;
@ -494,8 +478,8 @@ eigrp_topology_update_node_flags(struct eigrp_prefix_entry *dest)
else
{
entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_FSUCCESSOR_FLAG;
entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG;
}
entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG;
}
}
}
@ -511,7 +495,7 @@ eigrp_update_routing_table(struct eigrp_prefix_entry * prefix)
{
eigrp_zebra_route_add(prefix->destination_ipv4, successors);
for (ALL_LIST_ELEMENTS_RO (successors, node, entry))
entry->flags |= EIGRP_NEIGHBOR_ENTRY_INTABLE_FLAG;
entry->flags |= EIGRP_NEIGHBOR_ENTRY_INTABLE_FLAG;
list_delete(successors);
}
@ -519,7 +503,7 @@ eigrp_update_routing_table(struct eigrp_prefix_entry * prefix)
{
eigrp_zebra_route_delete(prefix->destination_ipv4);
for (ALL_LIST_ELEMENTS_RO (prefix->entries, node, entry))
entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_INTABLE_FLAG;
entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_INTABLE_FLAG;
}
}
@ -538,7 +522,7 @@ eigrp_topology_neighbor_down(struct eigrp *eigrp, struct eigrp_neighbor * nbr)
{
struct eigrp_fsm_action_message *msg;
msg = XCALLOC(MTYPE_EIGRP_FSM_MSG,
sizeof(struct eigrp_fsm_action_message));
sizeof(struct eigrp_fsm_action_message));
struct TLV_IPv4_Internal_type * tlv = eigrp_IPv4_InternalTLV_new();
tlv->metric.delay = EIGRP_MAX_METRIC;
msg->packet_type = EIGRP_OPC_UPDATE;

1018
eigrpd/eigrp_update.c
View File

File diff suppressed because it is too large Load Diff

135
eigrpd/eigrp_vty.c
View File

@ -56,7 +56,6 @@
#include "eigrpd/eigrp_dump.h"
#include "eigrpd/eigrp_const.h"
static int
config_write_network (struct vty *vty, struct eigrp *eigrp)
{
@ -119,7 +118,7 @@ config_write_interfaces (struct vty *vty, struct eigrp *eigrp)
}
/*Separate this EIGRP interface configuration from the others*/
vty_out (vty, "!%s", VTY_NEWLINE);
vty_out (vty, "!%s", VTY_NEWLINE);
}
return 0;
@ -168,8 +167,8 @@ config_write_eigrp_router (struct vty *vty, struct eigrp *eigrp)
{
struct in_addr router_id_static;
router_id_static.s_addr = htonl(eigrp->router_id_static);
vty_out (vty, " eigrp router-id %s%s",
inet_ntoa (router_id_static), VTY_NEWLINE);
vty_out (vty, " eigrp router-id %s%s",
inet_ntoa (router_id_static), VTY_NEWLINE);
}
/* Network area print. */
@ -185,11 +184,11 @@ config_write_eigrp_router (struct vty *vty, struct eigrp *eigrp)
}
DEFUN_NOSH (router_eigrp,
router_eigrp_cmd,
"router eigrp (1-65535)",
"Enable a routing process\n"
"Start EIGRP configuration\n"
"AS Number to use\n")
router_eigrp_cmd,
"router eigrp (1-65535)",
"Enable a routing process\n"
"Start EIGRP configuration\n"
"AS Number to use\n")
{
struct eigrp *eigrp = eigrp_get (argv[2]->arg);
VTY_PUSH_CONTEXT(EIGRP_NODE, eigrp);
@ -197,7 +196,6 @@ DEFUN_NOSH (router_eigrp,
return CMD_SUCCESS;
}
DEFUN (no_router_eigrp,
no_router_eigrp_cmd,
"no router eigrp (1-65535)",
@ -337,7 +335,7 @@ DEFUN (eigrp_network,
"Enable routing on an IP network\n"
"EIGRP network prefix\n")
{
VTY_DECLVAR_CONTEXT(eigrp, eigrp)
VTY_DECLVAR_CONTEXT(eigrp, eigrp);
struct prefix_ipv4 p;
int ret;
@ -418,22 +416,22 @@ DEFUN (show_ip_eigrp_topology,
eigrp = eigrp_lookup ();
if (eigrp == NULL)
{
vty_out (vty, " EIGRP Routing Process not enabled%s", VTY_NEWLINE);
return CMD_SUCCESS;
}
{
vty_out (vty, " EIGRP Routing Process not enabled%s", VTY_NEWLINE);
return CMD_SUCCESS;
}
show_ip_eigrp_topology_header (vty, eigrp);
for (ALL_LIST_ELEMENTS (eigrp->topology_table, node, nnode, tn))
{
show_ip_eigrp_prefix_entry (vty,tn);
for (ALL_LIST_ELEMENTS (tn->entries, node2, nnode2, te))
{
if (((te->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG) == EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG)||
((te->flags & EIGRP_NEIGHBOR_ENTRY_FSUCCESSOR_FLAG) == EIGRP_NEIGHBOR_ENTRY_FSUCCESSOR_FLAG))
show_ip_eigrp_neighbor_entry (vty, eigrp, te);
}
{
show_ip_eigrp_prefix_entry (vty,tn);
for (ALL_LIST_ELEMENTS (tn->entries, node2, nnode2, te))
{
if (((te->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG) == EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG)||
((te->flags & EIGRP_NEIGHBOR_ENTRY_FSUCCESSOR_FLAG) == EIGRP_NEIGHBOR_ENTRY_FSUCCESSOR_FLAG))
show_ip_eigrp_neighbor_entry (vty, eigrp, te);
}
}
return CMD_SUCCESS;
@ -507,36 +505,36 @@ DEFUN (show_ip_eigrp_interfaces,
if (argc !=3)
{
show_ip_eigrp_interface_header (vty, eigrp);
show_ip_eigrp_interface_header (vty, eigrp);
}
int idx = 0;
for (ALL_LIST_ELEMENTS_RO (eigrp->eiflist, node, ei))
{
if (argv_find (argv, argc, "detail", &idx))
{
show_ip_eigrp_interface_header (vty, eigrp);
}
{
if (argv_find (argv, argc, "detail", &idx))
{
show_ip_eigrp_interface_header (vty, eigrp);
}
show_ip_eigrp_interface_sub (vty, eigrp, ei);
idx = 0;
if (argv_find (argv, argc, "detail", &idx))
{
show_ip_eigrp_interface_detail (vty, eigrp, ei);
}
}
show_ip_eigrp_interface_sub (vty, eigrp, ei);
idx = 0;
if (argv_find (argv, argc, "detail", &idx))
{
show_ip_eigrp_interface_detail (vty, eigrp, ei);
}
}
return CMD_SUCCESS;
}
ALIAS (show_ip_eigrp_interfaces,
show_ip_eigrp_interfaces_detail_cmd,
"show ip eigrp interfaces <" INT_TYPES_CMD_STR ">",
SHOW_STR
IP_STR
"IP-EIGRP show commands\n"
"IP-EIGRP interfaces\n"
INT_TYPES_DESC)
show_ip_eigrp_interfaces_detail_cmd,
"show ip eigrp interfaces <" INT_TYPES_CMD_STR ">",
SHOW_STR
IP_STR
"IP-EIGRP show commands\n"
"IP-EIGRP interfaces\n"
INT_TYPES_DESC)
DEFUN (show_ip_eigrp_neighbors,
show_ip_eigrp_neighbors_cmd,
@ -567,8 +565,8 @@ DEFUN (show_ip_eigrp_neighbors,
{
for (ALL_LIST_ELEMENTS (ei->nbrs, node2, nnode2, nbr))
{
if (detail || (nbr->state == EIGRP_NEIGHBOR_UP))
show_ip_eigrp_neighbor_sub (vty, nbr, detail);
if (detail || (nbr->state == EIGRP_NEIGHBOR_UP))
show_ip_eigrp_neighbor_sub (vty, nbr, detail);
}
}
@ -576,13 +574,13 @@ DEFUN (show_ip_eigrp_neighbors,
}
ALIAS (show_ip_eigrp_neighbors,
show_ip_eigrp_neighbors_detail_cmd,
"show ip eigrp neighbors <" INT_TYPES_CMD_STR ">",
SHOW_STR
IP_STR
"IP-EIGRP show commands\n"
"IP-EIGRP neighbors\n"
INT_TYPES_DESC)
show_ip_eigrp_neighbors_detail_cmd,
"show ip eigrp neighbors <" INT_TYPES_CMD_STR ">",
SHOW_STR
IP_STR
"IP-EIGRP show commands\n"
"IP-EIGRP neighbors\n"
INT_TYPES_DESC)
DEFUN (eigrp_if_delay,
eigrp_if_delay_cmd,
@ -691,8 +689,8 @@ DEFUN (no_eigrp_if_bandwidth,
{
for (ALL_LIST_ELEMENTS (pe->entries, node2, nnode2, ne))
{
if (ne->ei == ei)
break;
if (ne->ei == ei)
break;
/*TODO: */
}
}
@ -750,8 +748,6 @@ DEFUN (no_eigrp_if_ip_hellointerval,
return CMD_SUCCESS;
}
DEFUN (eigrp_if_ip_holdinterval,
eigrp_if_ip_holdinterval_cmd,
"ip hold-time eigrp (1-65535)",
@ -863,7 +859,7 @@ static int
str2auth_type (const char *str, struct interface *ifp)
{
/* Sanity check. */
if (str == NULL)
if (str == NULL)
return CMD_WARNING;
if(strncmp(str, "md5",3) == 0)
@ -878,7 +874,6 @@ str2auth_type (const char *str, struct interface *ifp)
}
return CMD_WARNING;
}
DEFUN (eigrp_authentication_mode,
@ -902,10 +897,10 @@ DEFUN (eigrp_authentication_mode,
return CMD_SUCCESS;
}
// if(strncmp(argv[2], "md5",3))
// IF_DEF_PARAMS (ifp)->auth_type = EIGRP_AUTH_TYPE_MD5;
// else if(strncmp(argv[2], "hmac-sha-256",12))
// IF_DEF_PARAMS (ifp)->auth_type = EIGRP_AUTH_TYPE_SHA256;
// if(strncmp(argv[2], "md5",3))
// IF_DEF_PARAMS (ifp)->auth_type = EIGRP_AUTH_TYPE_MD5;
// else if(strncmp(argv[2], "hmac-sha-256",12))
// IF_DEF_PARAMS (ifp)->auth_type = EIGRP_AUTH_TYPE_SHA256;
return str2auth_type(argv[5]->arg, ifp);
}
@ -996,7 +991,8 @@ DEFUN (no_eigrp_authentication_keychain,
return CMD_SUCCESS;
}
if((IF_DEF_PARAMS (ifp)->auth_keychain != NULL) && (strcmp(IF_DEF_PARAMS (ifp)->auth_keychain,argv[5]->arg)==0))
if((IF_DEF_PARAMS (ifp)->auth_keychain != NULL) &&
(strcmp(IF_DEF_PARAMS (ifp)->auth_keychain,argv[5]->arg)==0))
{
free (IF_DEF_PARAMS (ifp)->auth_keychain);
IF_DEF_PARAMS (ifp)->auth_keychain = NULL;
@ -1007,7 +1003,6 @@ DEFUN (no_eigrp_authentication_keychain,
return CMD_SUCCESS;
}
DEFUN (eigrp_redistribute_source_metric,
eigrp_redistribute_source_metric_cmd,
"redistribute " FRR_REDIST_STR_EIGRPD
@ -1037,12 +1032,11 @@ DEFUN (eigrp_redistribute_source_metric,
return eigrp_redistribute_set (eigrp, source, metrics_from_command);
}
DEFUN (no_eigrp_redistribute_source_metric,
no_eigrp_redistribute_source_metric_cmd,
no_eigrp_redistribute_source_metric_cmd,
"no redistribute " FRR_REDIST_STR_EIGRPD
" metric (1-4294967295) (0-4294967295) (0-255) (1-255) (1-65535)",
"Disable\n"
" metric (1-4294967295) (0-4294967295) (0-255) (1-255) (1-65535)",
"Disable\n"
REDIST_STR
FRR_REDIST_HELP_STR_EIGRPD
"Metric for redistributed routes\n"
@ -1091,7 +1085,6 @@ DEFUN (eigrp_variance,
return CMD_SUCCESS;
}
DEFUN (no_eigrp_variance,
no_eigrp_variance_cmd,
"no variance (1-128)",
@ -1139,7 +1132,6 @@ DEFUN (eigrp_maximum_paths,
return CMD_SUCCESS;
}
DEFUN (no_eigrp_maximum_paths,
no_eigrp_maximum_paths_cmd,
"no maximum-paths <1-32>",
@ -1527,8 +1519,6 @@ eigrp_vty_if_init (void)
/*EIGRP Summarization commands*/
install_element (INTERFACE_NODE, &eigrp_ip_summary_address_cmd);
install_element (INTERFACE_NODE, &no_eigrp_ip_summary_address_cmd);
}
static void
@ -1536,7 +1526,6 @@ eigrp_vty_zebra_init (void)
{
install_element (EIGRP_NODE, &eigrp_redistribute_source_metric_cmd);
install_element (EIGRP_NODE, &no_eigrp_redistribute_source_metric_cmd);
}
/* Install EIGRP related vty commands. */

82
eigrpd/eigrp_zebra.c
View File

@ -68,7 +68,7 @@ static int eigrp_interface_state_down (int, struct zclient *,
static struct interface * zebra_interface_if_lookup (struct stream *);
static int eigrp_zebra_read_ipv4 (int , struct zclient *,
zebra_size_t, vrf_id_t vrf_id);
zebra_size_t, vrf_id_t vrf_id);
/* Zebra structure to hold current status. */
struct zclient *zclient = NULL;
@ -80,7 +80,7 @@ struct in_addr router_id_zebra;
/* Router-id update message from zebra. */
static int
eigrp_router_id_update_zebra (int command, struct zclient *zclient,
zebra_size_t length, vrf_id_t vrf_id)
zebra_size_t length, vrf_id_t vrf_id)
{
struct eigrp *eigrp;
struct prefix router_id;
@ -124,7 +124,7 @@ eigrp_zebra_init (void)
/* Zebra route add and delete treatment. */
static int
eigrp_zebra_read_ipv4 (int command, struct zclient *zclient,
zebra_size_t length, vrf_id_t vrf_id)
zebra_size_t length, vrf_id_t vrf_id)
{
struct stream *s;
struct zapi_ipv4 api;
@ -184,7 +184,7 @@ eigrp_zebra_read_ipv4 (int command, struct zclient *zclient,
/* Inteface addition message from zebra. */
static int
eigrp_interface_add (int command, struct zclient *zclient, zebra_size_t length,
vrf_id_t vrf_id)
vrf_id_t vrf_id)
{
struct interface *ifp;
@ -205,7 +205,7 @@ eigrp_interface_add (int command, struct zclient *zclient, zebra_size_t length,
static int
eigrp_interface_delete (int command, struct zclient *zclient,
zebra_size_t length, vrf_id_t vrf_id)
zebra_size_t length, vrf_id_t vrf_id)
{
struct interface *ifp;
struct stream *s;
@ -224,7 +224,7 @@ eigrp_interface_delete (int command, struct zclient *zclient,
if (IS_DEBUG_EIGRP (zebra, ZEBRA_INTERFACE))
zlog_debug("Zebra: interface delete %s index %d flags %llx metric %d mtu %d",
ifp->name, ifp->ifindex, (unsigned long long)ifp->flags, ifp->metric, ifp->mtu);
ifp->name, ifp->ifindex, (unsigned long long)ifp->flags, ifp->metric, ifp->mtu);
for (rn = route_top (IF_OIFS (ifp)); rn; rn = route_next (rn))
if (rn->info)
@ -236,7 +236,7 @@ eigrp_interface_delete (int command, struct zclient *zclient,
static int
eigrp_interface_address_add (int command, struct zclient *zclient,
zebra_size_t length, vrf_id_t vrf_id)
zebra_size_t length, vrf_id_t vrf_id)
{
struct connected *c;
@ -259,7 +259,7 @@ eigrp_interface_address_add (int command, struct zclient *zclient,
static int
eigrp_interface_address_delete (int command, struct zclient *zclient,
zebra_size_t length, vrf_id_t vrf_id)
zebra_size_t length, vrf_id_t vrf_id)
{
struct connected *c;
struct interface *ifp;
@ -303,7 +303,7 @@ eigrp_interface_address_delete (int command, struct zclient *zclient,
static int
eigrp_interface_state_up (int command, struct zclient *zclient,
zebra_size_t length, vrf_id_t vrf_id)
zebra_size_t length, vrf_id_t vrf_id)
{
struct interface *ifp;
struct eigrp_interface *ei;
@ -330,16 +330,16 @@ eigrp_interface_state_up (int command, struct zclient *zclient,
{
if (IS_DEBUG_EIGRP (zebra, ZEBRA_INTERFACE))
zlog_debug ("Zebra: Interface[%s] bandwidth change %d -> %d.",
ifp->name, if_tmp.bandwidth, ifp->bandwidth);
ifp->name, if_tmp.bandwidth, ifp->bandwidth);
// eigrp_if_recalculate_output_cost (ifp);
// eigrp_if_recalculate_output_cost (ifp);
}
if (if_tmp.mtu != ifp->mtu)
{
if (IS_DEBUG_EIGRP (zebra, ZEBRA_INTERFACE))
zlog_debug ("Zebra: Interface[%s] MTU change %u -> %u.",
ifp->name, if_tmp.mtu, ifp->mtu);
ifp->name, if_tmp.mtu, ifp->mtu);
/* Must reset the interface (simulate down/up) when MTU changes. */
eigrp_if_reset (ifp);
@ -365,7 +365,7 @@ eigrp_interface_state_up (int command, struct zclient *zclient,
static int
eigrp_interface_state_down (int command, struct zclient *zclient,
zebra_size_t length, vrf_id_t vrf_id)
zebra_size_t length, vrf_id_t vrf_id)
{
struct interface *ifp;
struct eigrp_interface *ei;
@ -399,8 +399,8 @@ zebra_interface_if_lookup (struct stream *s)
/* And look it up. */
return if_lookup_by_name_len (ifname_tmp,
strnlen (ifname_tmp, INTERFACE_NAMSIZ),
VRF_DEFAULT);
strnlen (ifname_tmp, INTERFACE_NAMSIZ),
VRF_DEFAULT);
}
void
@ -443,19 +443,19 @@ eigrp_zebra_route_add (struct prefix_ipv4 *p, struct list *successors)
/* Nexthop, ifindex, distance and metric information. */
for (ALL_LIST_ELEMENTS_RO (successors, node, te))
{
stream_putc (s, NEXTHOP_TYPE_IPV4_IFINDEX);
stream_put_in_addr (s, &te->adv_router->src);
stream_putl (s, te->ei->ifp->ifindex);
}
{
stream_putc (s, NEXTHOP_TYPE_IPV4_IFINDEX);
stream_put_in_addr (s, &te->adv_router->src);
stream_putl (s, te->ei->ifp->ifindex);
}
if (IS_DEBUG_EIGRP (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, 0 /*&p->nexthop*/, buf[1], sizeof (buf[1])));
inet_ntop(AF_INET, &p->prefix, buf[0], sizeof (buf[0])),
p->prefixlen,
inet_ntop(AF_INET, 0 /*&p->nexthop*/, buf[1], sizeof (buf[1])));
}
stream_putw_at (s, 0, stream_get_endp (s));
@ -480,12 +480,12 @@ eigrp_zebra_route_delete (struct prefix_ipv4 *p)
zapi_ipv4_route (ZEBRA_IPV4_ROUTE_DELETE, zclient, p, &api);
if (IS_DEBUG_EIGRP (zebra, ZEBRA_REDISTRIBUTE))
{
{
char buf[2][INET_ADDRSTRLEN];
zlog_debug ("Zebra: Route del %s/%d nexthop %s",
inet_ntop (AF_INET, &p->prefix, buf[0], sizeof (buf[0])),
p->prefixlen,
inet_ntop (AF_INET, 0 /*&p->nexthop*/, buf[1], sizeof (buf[1])));
inet_ntop (AF_INET, &p->prefix, buf[0], sizeof (buf[0])),
p->prefixlen,
inet_ntop (AF_INET, 0 /*&p->nexthop*/, buf[1], sizeof (buf[1])));
}
}
@ -512,22 +512,22 @@ eigrp_redistribute_set (struct eigrp *eigrp, int type, struct eigrp_metrics metr
eigrp_external_routes_refresh (eigrp, type);
// if (IS_DEBUG_EIGRP(zebra, ZEBRA_REDISTRIBUTE))
// zlog_debug ("Redistribute[%s]: Refresh Type[%d], Metric[%d]",
// eigrp_redist_string(type),
// metric_type (eigrp, type), metric_value (eigrp, type));
// if (IS_DEBUG_EIGRP(zebra, ZEBRA_REDISTRIBUTE))
// zlog_debug ("Redistribute[%s]: Refresh Type[%d], Metric[%d]",
// eigrp_redist_string(type),
// metric_type (eigrp, type), metric_value (eigrp, type));
return CMD_SUCCESS;
}
eigrp->dmetric[type] = metric;
zclient_redistribute (ZEBRA_REDISTRIBUTE_ADD, zclient,
AFI_IP, type, 0, VRF_DEFAULT);
AFI_IP, type, 0, VRF_DEFAULT);
// if (IS_DEBUG_EIGRP (zebra, ZEBRA_REDISTRIBUTE))
// zlog_debug ("Redistribute[%s]: Start Type[%d], Metric[%d]",
// ospf_redist_string(type),
// metric_type (ospf, type), metric_value (ospf, type));
// if (IS_DEBUG_EIGRP (zebra, ZEBRA_REDISTRIBUTE))
// zlog_debug ("Redistribute[%s]: Start Type[%d], Metric[%d]",
// ospf_redist_string(type),
// metric_type (ospf, type), metric_value (ospf, type));
++eigrp->redistribute;
@ -542,14 +542,14 @@ eigrp_redistribute_unset (struct eigrp *eigrp, int type)
{
memset(&eigrp->dmetric[type], 0, sizeof(struct eigrp_metrics));
zclient_redistribute (ZEBRA_REDISTRIBUTE_DELETE, zclient,
AFI_IP, type, 0, VRF_DEFAULT);
AFI_IP, type, 0, VRF_DEFAULT);
--eigrp->redistribute;
}
// if (IS_DEBUG_EIGRP (zebra, ZEBRA_REDISTRIBUTE))
// zlog_debug ("Redistribute[%s]: Start Type[%d], Metric[%d]",
// ospf_redist_string(type),
// metric_type (ospf, type), metric_value (ospf, type));
// if (IS_DEBUG_EIGRP (zebra, ZEBRA_REDISTRIBUTE))
// zlog_debug ("Redistribute[%s]: Start Type[%d], Metric[%d]",
// ospf_redist_string(type),
// metric_type (ospf, type), metric_value (ospf, type));
return CMD_SUCCESS;
}

18
eigrpd/eigrpd.c
View File

@ -114,8 +114,8 @@ eigrp_router_id_update (struct eigrp *eigrp)
eigrp->router_id = router_id;
if (router_id_old != router_id)
{
// if (IS_DEBUG_EIGRP_EVENT)
// zlog_debug("Router-ID[NEW:%s]: Update", inet_ntoa(eigrp->router_id));
// if (IS_DEBUG_EIGRP_EVENT)
// zlog_debug("Router-ID[NEW:%s]: Update", inet_ntoa(eigrp->router_id));
/* update eigrp_interface's */
for (ALL_LIST_ELEMENTS_RO(vrf_iflist(VRF_DEFAULT), node, ifp))
@ -137,7 +137,6 @@ eigrp_master_init ()
eigrp_om->start_time = tv.tv_sec;
}
/* Allocate new eigrp structure. */
static struct eigrp *
eigrp_new (const char *AS)
@ -246,10 +245,10 @@ eigrp_terminate (void)
struct listnode *node, *nnode;
/* shutdown already in progress */
if (CHECK_FLAG(eigrp_om->options, EIGRP_MASTER_SHUTDOWN))
return;
if (CHECK_FLAG(eigrp_om->options, EIGRP_MASTER_SHUTDOWN))
return;
SET_FLAG(eigrp_om->options, EIGRP_MASTER_SHUTDOWN);
SET_FLAG(eigrp_om->options, EIGRP_MASTER_SHUTDOWN);
/* exit immediately if EIGRP not actually running */
if (listcount(eigrp_om->eigrp) == 0)
@ -266,9 +265,9 @@ eigrp_finish (struct eigrp *eigrp)
eigrp_finish_final(eigrp);
/* eigrp being shut-down? If so, was this the last eigrp instance? */
if (CHECK_FLAG(eigrp_om->options, EIGRP_MASTER_SHUTDOWN)
&& (listcount(eigrp_om->eigrp) == 0))
exit(0);
if (CHECK_FLAG(eigrp_om->options, EIGRP_MASTER_SHUTDOWN)
&& (listcount(eigrp_om->eigrp) == 0))
exit(0);
return;
}
@ -296,7 +295,6 @@ eigrp_finish_final (struct eigrp *eigrp)
eigrp_delete(eigrp);
XFREE(MTYPE_EIGRP_TOP,eigrp);
}
/*Look for existing eigrp process*/