diff options
Diffstat (limited to 'eigrpd/eigrp_interface.c')
| -rw-r--r-- | eigrpd/eigrp_interface.c | 613 |
1 files changed, 613 insertions, 0 deletions
diff --git a/eigrpd/eigrp_interface.c b/eigrpd/eigrp_interface.c new file mode 100644 index 0000000000..18573caa00 --- /dev/null +++ b/eigrpd/eigrp_interface.c @@ -0,0 +1,613 @@ +/* + * EIGRP Interface Functions. + * Copyright (C) 2013-2016 + * Authors: + * Donnie Savage + * Jan Janovic + * Matej Perina + * Peter Orsag + * Peter Paluch + * Frantisek Gazo + * Tomas Hvorkovy + * Martin Kontsek + * Lukas Koribsky + * + * This file is part of GNU Zebra. + * + * GNU Zebra is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2, or (at your option) any + * later version. + * + * GNU Zebra is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Zebra; see the file COPYING. If not, write to the Free + * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA + * 02111-1307, USA. + */ + +#include <zebra.h> + +#include "thread.h" +#include "linklist.h" +#include "prefix.h" +#include "if.h" +#include "table.h" +#include "memory.h" +#include "command.h" +#include "stream.h" +#include "log.h" +#include "keychain.h" +#include "vrf.h" + +#include "eigrpd/eigrp_structs.h" +#include "eigrpd/eigrpd.h" +#include "eigrpd/eigrp_interface.h" +#include "eigrpd/eigrp_neighbor.h" +#include "eigrpd/eigrp_packet.h" +#include "eigrpd/eigrp_zebra.h" +#include "eigrpd/eigrp_vty.h" +#include "eigrpd/eigrp_network.h" +#include "eigrpd/eigrp_topology.h" +#include "eigrpd/eigrp_memory.h" + +static void +eigrp_delete_from_if (struct interface *, struct eigrp_interface *); + +static void +eigrp_add_to_if (struct interface *ifp, struct eigrp_interface *ei) +{ + struct route_node *rn; + struct prefix p; + + p = *ei->address; + p.prefixlen = IPV4_MAX_PREFIXLEN; + + rn = route_node_get (IF_OIFS (ifp), &p); + /* rn->info should either be NULL or equal to this ei + * as route_node_get may return an existing node + */ + assert (!rn->info || rn->info == ei); + rn->info = ei; +} + +struct eigrp_interface * +eigrp_if_new (struct eigrp *eigrp, struct interface *ifp, struct prefix *p) +{ + struct eigrp_interface *ei; + int i; + + if ((ei = eigrp_if_table_lookup (ifp, p)) == NULL) + { + ei = XCALLOC (MTYPE_EIGRP_IF, sizeof (struct eigrp_interface)); + memset (ei, 0, sizeof (struct eigrp_interface)); + } + else + return ei; + + /* Set zebra interface pointer. */ + ei->ifp = ifp; + ei->address = p; + + eigrp_add_to_if (ifp, ei); + listnode_add (eigrp->eiflist, ei); + + ei->type = EIGRP_IFTYPE_BROADCAST; + + /* Initialize neighbor list. */ + ei->nbrs = list_new (); + + ei->crypt_seqnum = time (NULL); + + /* Initialize lists */ + for (i = 0; i < EIGRP_FILTER_MAX; i++) + { + ei->list[i] = NULL; + ei->prefix[i] = NULL; + ei->routemap[i] = NULL; + } + + return ei; +} + +/* lookup ei for specified prefix/ifp */ +struct eigrp_interface * +eigrp_if_table_lookup (struct interface *ifp, struct prefix *prefix) +{ + struct prefix p; + struct route_node *rn; + struct eigrp_interface *rninfo = NULL; + + p = *prefix; + p.prefixlen = IPV4_MAX_PREFIXLEN; + + /* route_node_get implicitly locks */ + if ((rn = route_node_lookup (IF_OIFS (ifp), &p))) + { + rninfo = (struct eigrp_interface *) rn->info; + route_unlock_node (rn); + } + + return rninfo; +} + +int +eigrp_if_delete_hook (struct interface *ifp) +{ + + struct route_node *rn; + + route_table_finish (IF_OIFS (ifp)); + + for (rn = route_top (IF_OIFS_PARAMS (ifp)); rn; rn = route_next (rn)) + if (rn->info) + eigrp_del_if_params (rn->info); + route_table_finish (IF_OIFS_PARAMS (ifp)); + + XFREE (MTYPE_EIGRP_IF_INFO, ifp->info); + ifp->info = NULL; + + return 0; +} + +struct list *eigrp_iflist; + +void +eigrp_if_init () +{ + /* Initialize Zebra interface data structure. */ + if_add_hook (IF_NEW_HOOK, eigrp_if_new_hook); + if_add_hook (IF_DELETE_HOOK, eigrp_if_delete_hook); +} + +int +eigrp_if_new_hook (struct interface *ifp) +{ + int rc = 0; + + ifp->info = XCALLOC (MTYPE_EIGRP_IF_INFO, sizeof (struct eigrp_if_info)); + + IF_OIFS (ifp) = route_table_init (); + IF_OIFS_PARAMS (ifp) = route_table_init (); + + IF_DEF_PARAMS (ifp) = eigrp_new_if_params (); + + SET_IF_PARAM (IF_DEF_PARAMS (ifp), v_hello); + IF_DEF_PARAMS (ifp)->v_hello = (u_int32_t) EIGRP_HELLO_INTERVAL_DEFAULT; + + SET_IF_PARAM (IF_DEF_PARAMS (ifp), v_wait); + IF_DEF_PARAMS (ifp)->v_wait = (u_int16_t) EIGRP_HOLD_INTERVAL_DEFAULT; + + SET_IF_PARAM (IF_DEF_PARAMS (ifp), bandwidth); + IF_DEF_PARAMS (ifp)->bandwidth = (u_int32_t) EIGRP_BANDWIDTH_DEFAULT; + + SET_IF_PARAM (IF_DEF_PARAMS (ifp), delay); + IF_DEF_PARAMS (ifp)->delay = (u_int32_t) EIGRP_DELAY_DEFAULT; + + SET_IF_PARAM (IF_DEF_PARAMS (ifp), reliability); + IF_DEF_PARAMS (ifp)->reliability = (u_char) EIGRP_RELIABILITY_DEFAULT; + + SET_IF_PARAM (IF_DEF_PARAMS (ifp), load); + IF_DEF_PARAMS (ifp)->load = (u_char) EIGRP_LOAD_DEFAULT; + + SET_IF_PARAM (IF_DEF_PARAMS (ifp), auth_type); + IF_DEF_PARAMS (ifp)->auth_type = EIGRP_AUTH_TYPE_NONE; + + SET_IF_PARAM (IF_DEF_PARAMS (ifp), auth_keychain); + IF_DEF_PARAMS (ifp)->auth_keychain= NULL; + + return rc; +} + +struct eigrp_if_params * +eigrp_new_if_params (void) +{ + struct eigrp_if_params *eip; + + eip = XCALLOC (MTYPE_EIGRP_IF_PARAMS, sizeof (struct eigrp_if_params)); + if (!eip) + return NULL; + + UNSET_IF_PARAM (eip, passive_interface); + UNSET_IF_PARAM (eip, v_hello); + UNSET_IF_PARAM (eip, v_wait); + UNSET_IF_PARAM (eip, bandwidth); + UNSET_IF_PARAM (eip, delay); + UNSET_IF_PARAM (eip, reliability); + UNSET_IF_PARAM (eip, load); + UNSET_IF_PARAM (eip, auth_keychain); + UNSET_IF_PARAM (eip, auth_type); + + + return eip; +} + +void +eigrp_del_if_params (struct eigrp_if_params *eip) +{ + if(eip->auth_keychain) + free(eip->auth_keychain); + + XFREE (MTYPE_EIGRP_IF_PARAMS, eip); +} + +struct eigrp_if_params * +eigrp_lookup_if_params (struct interface *ifp, struct in_addr addr) +{ + struct prefix_ipv4 p; + struct route_node *rn; + + p.family = AF_INET; + p.prefixlen = IPV4_MAX_PREFIXLEN; + p.prefix = addr; + + rn = route_node_lookup (IF_OIFS_PARAMS (ifp), (struct prefix*) &p); + + if (rn) + { + route_unlock_node (rn); + return rn->info; + } + + return NULL; +} + +int +eigrp_if_up (struct eigrp_interface *ei) +{ + struct eigrp_prefix_entry *pe; + struct eigrp_neighbor_entry *ne; + struct eigrp_metrics metric; + struct eigrp_interface *ei2; + struct listnode *node, *nnode; + struct eigrp *eigrp = eigrp_lookup (); + + if (ei == NULL) + return 0; + + if (eigrp != NULL) + eigrp_adjust_sndbuflen (eigrp, ei->ifp->mtu); + else + zlog_warn ("%s: eigrp_lookup () returned NULL", __func__); + eigrp_if_stream_set (ei); + + /* Set multicast memberships appropriately for new state. */ + eigrp_if_set_multicast (ei); + + thread_add_event (master, eigrp_hello_timer, ei, (1)); + + /*Prepare metrics*/ + metric.bandwith = eigrp_bandwidth_to_scaled (EIGRP_IF_PARAM (ei,bandwidth)); + metric.delay = eigrp_delay_to_scaled (EIGRP_IF_PARAM (ei,delay)); + metric.load = EIGRP_IF_PARAM (ei,load); + metric.reliability = EIGRP_IF_PARAM (ei,reliability); + metric.mtu[0] = 0xDC; + metric.mtu[1] = 0x05; + metric.mtu[2] = 0x00; + metric.hop_count = 0; + metric.flags = 0; + metric.tag = 0; + + /*Add connected entry to topology table*/ + + struct prefix_ipv4 *dest_addr = prefix_ipv4_new (); + + dest_addr->family = AF_INET; + dest_addr->prefix = ei->connected->address->u.prefix4; + dest_addr->prefixlen = ei->connected->address->prefixlen; + apply_mask_ipv4 (dest_addr); + pe = eigrp_topology_table_lookup_ipv4 (eigrp->topology_table, dest_addr); + + if (pe == NULL) + { + pe = eigrp_prefix_entry_new (); + pe->serno = eigrp->serno; + pe->destination_ipv4 = dest_addr; + pe->af = AF_INET; + pe->nt = EIGRP_TOPOLOGY_TYPE_CONNECTED; + + pe->state = EIGRP_FSM_STATE_PASSIVE; + pe->fdistance = eigrp_calculate_metrics (eigrp, &metric); + pe->req_action |= EIGRP_FSM_NEED_UPDATE; + eigrp_prefix_entry_add (eigrp->topology_table, pe); + listnode_add(eigrp->topology_changes_internalIPV4, pe); + } + ne = eigrp_neighbor_entry_new (); + ne->ei = ei; + ne->reported_metric = metric; + ne->total_metric = metric; + ne->distance = eigrp_calculate_metrics (eigrp, &metric); + ne->reported_distance = 0; + ne->prefix = pe; + ne->adv_router = eigrp->neighbor_self; + ne->flags = EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG; + eigrp_neighbor_entry_add (pe, ne); + + for (ALL_LIST_ELEMENTS (eigrp->eiflist, node, nnode, ei2)) + { + if (ei2->nbrs->count != 0) + { + eigrp_update_send (ei2); + } + } + + pe->req_action &= ~EIGRP_FSM_NEED_UPDATE; + listnode_delete(eigrp->topology_changes_internalIPV4, pe); + + return 1; +} + +int +eigrp_if_down (struct eigrp_interface *ei) +{ + struct listnode *node, *nnode; + struct eigrp_neighbor *nbr; + + if (ei == NULL) + return 0; + + /* Shutdown packet reception and sending */ + if(ei->t_hello) + THREAD_OFF (ei->t_hello); + + eigrp_if_stream_unset (ei); + + /*Set infinite metrics to routes learned by this interface and start query process*/ + for (ALL_LIST_ELEMENTS (ei->nbrs, node, nnode, nbr)) + { + eigrp_nbr_delete(nbr); + } + + return 1; +} + +void +eigrp_if_stream_set (struct eigrp_interface *ei) +{ + /* set output fifo queue. */ + if (ei->obuf == NULL) + ei->obuf = eigrp_fifo_new (); +} + +void +eigrp_if_stream_unset (struct eigrp_interface *ei) +{ + struct eigrp *eigrp = ei->eigrp; + + if (ei->obuf) + { + eigrp_fifo_free (ei->obuf); + ei->obuf = NULL; + + if (ei->on_write_q) + { + listnode_delete (eigrp->oi_write_q, ei); + if (list_isempty (eigrp->oi_write_q)) + thread_cancel (eigrp->t_write); + ei->on_write_q = 0; + } + } +} + +void +eigrp_if_set_multicast (struct eigrp_interface *ei) +{ + if ((EIGRP_IF_PASSIVE_STATUS (ei) == EIGRP_IF_ACTIVE)) + { + /* 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)) + /* Set the flag only if the system call to join succeeded. */ + EI_MEMBER_JOINED (ei, MEMBER_ALLROUTERS); + } + else + { + /* The interface should NOT belong to the EIGRP-all-routers group. */ + if (EI_MEMBER_CHECK (ei, MEMBER_ALLROUTERS)) + { + /* 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); + /* 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. */ + EI_MEMBER_LEFT (ei, MEMBER_ALLROUTERS); + } + } +} + +u_char +eigrp_default_iftype (struct interface *ifp) +{ + if (if_is_pointopoint (ifp)) + return EIGRP_IFTYPE_POINTOPOINT; + else if (if_is_loopback (ifp)) + return EIGRP_IFTYPE_LOOPBACK; + else + return EIGRP_IFTYPE_BROADCAST; +} + +void +eigrp_if_free (struct eigrp_interface *ei, int source) +{ + + if (source == INTERFACE_DOWN_BY_VTY) + { + THREAD_OFF (ei->t_hello); + eigrp_hello_send(ei,EIGRP_HELLO_GRACEFUL_SHUTDOWN, NULL); + } + + eigrp_if_down (ei); + + list_delete (ei->nbrs); + eigrp_delete_from_if (ei->ifp, ei); + listnode_delete (ei->eigrp->eiflist, ei); + + thread_cancel_event (master, ei); + + memset (ei, 0, sizeof (*ei)); + XFREE (MTYPE_EIGRP_IF, ei); +} + +static void +eigrp_delete_from_if (struct interface *ifp, struct eigrp_interface *ei) +{ + struct route_node *rn; + struct prefix p; + + p = *ei->address; + p.prefixlen = IPV4_MAX_PREFIXLEN; + + rn = route_node_lookup (IF_OIFS (ei->ifp), &p); + assert (rn); + assert (rn->info); + rn->info = NULL; + route_unlock_node (rn); + route_unlock_node (rn); +} + +/* Simulate down/up on the interface. This is needed, for example, when + the MTU changes. */ +void +eigrp_if_reset (struct interface *ifp) +{ + struct route_node *rn; + + for (rn = route_top (IF_OIFS (ifp)); rn; rn = route_next (rn)) + { + struct eigrp_interface *ei; + + if ((ei = rn->info) == NULL) + continue; + + eigrp_if_down (ei); + eigrp_if_up (ei); + } +} + +struct eigrp_interface * +eigrp_if_lookup_by_local_addr (struct eigrp *eigrp, struct interface *ifp, + struct in_addr address) +{ + struct listnode *node; + struct eigrp_interface *ei; + + for (ALL_LIST_ELEMENTS_RO (eigrp->eiflist, node, ei)) + { + if (ifp && ei->ifp != ifp) + continue; + + if (IPV4_ADDR_SAME (&address, &ei->address->u.prefix4)) + return ei; + } + + return NULL; +} + +/** + * @fn eigrp_if_lookup_by_name + * + * @param[in] eigrp EIGRP process + * @param[in] if_name Name of the interface + * + * @return struct eigrp_interface * + * + * @par + * Function is used for lookup interface by name. + */ +struct eigrp_interface * +eigrp_if_lookup_by_name (struct eigrp *eigrp, const char *if_name) +{ + 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; + } + } + + 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 route_node *rn; + struct prefix_ipv4 addr; + struct eigrp_interface *ei, *match; + + addr.family = AF_INET; + addr.prefix = src; + addr.prefixlen = IPV4_MAX_BITLEN; + + match = NULL; + + for (rn = route_top (IF_OIFS (ifp)); rn; rn = route_next (rn)) + { + ei = rn->info; + + if (!ei) /* oi can be NULL for PtP aliases */ + continue; + + if (if_is_loopback (ei->ifp)) + continue; + + if (prefix_match (CONNECTED_PREFIX (ei->connected), + (struct prefix *) &addr)) + { + if ((match == NULL) + || (match->address->prefixlen < ei->address->prefixlen)) + match = ei; + } + } + + return match; +} + +u_int32_t +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; + + return (u_int32_t) temp_bandwidth; + +} + +u_int32_t +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; + + return (u_int32_t) temp_scaled; +} + +u_int32_t +eigrp_delay_to_scaled (u_int32_t delay) +{ + return delay * 256; +} + +u_int32_t +eigrp_scaled_to_delay (u_int32_t scaled) +{ + return scaled / 256; +} |