1 files changed, 324 insertions, 368 deletions

diff --git a/eigrpd/eigrp_topology.c b/eigrpd/eigrp_topology.c
index 675031b754..ae1396ebaf 100644
--- a/eigrpd/eigrp_topology.c
+++ b/eigrpd/eigrp_topology.c
@@ -51,263 +51,239 @@
 #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 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 *);
+				    struct eigrp_neighbor_entry *);
 
 /*
  * Returns linkedlist used as topology table
  * cmp - assigned function for comparing topology nodes
- * del - assigned function executed before deleting topology node by list function
+ * del - assigned function executed before deleting topology node by list
+ * function
  */
-struct list *
-eigrp_topology_new()
+struct list *eigrp_topology_new()
 {
-  struct list* new = list_new();
-  new->cmp = (int
-              (*)(void *, void *)) eigrp_prefix_entry_cmp;
-  new->del = (void
-              (*)(void *)) eigrp_prefix_entry_del;
+	struct list *new = list_new();
+	new->cmp = (int (*)(void *, void *))eigrp_prefix_entry_cmp;
+	new->del = (void (*)(void *))eigrp_prefix_entry_del;
 
-  return new;
+	return new;
 }
 
 /*
  * Topology node comparison
  */
 
-static int
-eigrp_prefix_entry_cmp(struct eigrp_prefix_entry *node1,
-                       struct eigrp_prefix_entry *node2)
+static int eigrp_prefix_entry_cmp(struct eigrp_prefix_entry *node1,
+				  struct eigrp_prefix_entry *node2)
 {
-  if (node1->af == AF_INET)
-    {
-      if (node2->af == AF_INET)
-        {
-          if (node1->destination_ipv4->prefix.s_addr
-              < node2->destination_ipv4->prefix.s_addr)
-            {
-              return -1; // if it belong above node2
-            }
-          else
-            {
-              if (node1->destination_ipv4->prefix.s_addr
-                  > node2->destination_ipv4->prefix.s_addr)
-                {
-                  return 1; //if it belongs under node2
-                }
-              else
-                {
-                  return 0; // same value... ERROR...in case of adding same prefix again
-                }
-            }
-        }
-      else
-        {
-          return 1;
-        }
-    }
-  else
-    { // TODO check if the prefix dont exists
-      return 1; // add to end
-    }
+	if (node1->af == AF_INET) {
+		if (node2->af == AF_INET) {
+			if (node1->destination_ipv4->prefix.s_addr
+			    < node2->destination_ipv4->prefix.s_addr) {
+				return -1; // if it belong above node2
+			} else {
+				if (node1->destination_ipv4->prefix.s_addr
+				    > node2->destination_ipv4->prefix.s_addr) {
+					return 1; // if it belongs under node2
+				} else {
+					return 0; // same value... ERROR...in
+						  // case of adding same prefix
+						  // again
+				}
+			}
+		} else {
+			return 1;
+		}
+	} else {	  // TODO check if the prefix dont exists
+		return 1; // add to end
+	}
 }
 
 /*
  * Topology node delete
  */
 
-static void
-eigrp_prefix_entry_del(struct eigrp_prefix_entry *node)
+static void eigrp_prefix_entry_del(struct eigrp_prefix_entry *node)
 {
-  list_delete_all_node(node->entries);
-  list_free(node->entries);
+	list_delete_all_node(node->entries);
+	list_free(node->entries);
 }
 
 /*
  * Returns new created toplogy node
  * cmp - assigned function for comparing topology entry
  */
-struct eigrp_prefix_entry *
-eigrp_prefix_entry_new()
+struct eigrp_prefix_entry *eigrp_prefix_entry_new()
 {
-  struct eigrp_prefix_entry *new;
-  new = XCALLOC(MTYPE_EIGRP_PREFIX_ENTRY, sizeof(struct eigrp_prefix_entry));
-  new->entries = list_new();
-  new->rij = list_new();
-  new->entries->cmp = (int (*)(void *, void *))eigrp_neighbor_entry_cmp;
-  new->distance = new->fdistance = new->rdistance = EIGRP_MAX_METRIC;
-  new->destination_ipv4 = NULL;
-  new->destination_ipv6 = NULL;
-
-  return new;
+	struct eigrp_prefix_entry *new;
+	new = XCALLOC(MTYPE_EIGRP_PREFIX_ENTRY,
+		      sizeof(struct eigrp_prefix_entry));
+	new->entries = list_new();
+	new->rij = list_new();
+	new->entries->cmp = (int (*)(void *, void *))eigrp_neighbor_entry_cmp;
+	new->distance = new->fdistance = new->rdistance = EIGRP_MAX_METRIC;
+	new->destination_ipv4 = NULL;
+	new->destination_ipv6 = NULL;
+
+	return new;
 }
 
 /*
  * Topology entry comparison
  */
-static int
-eigrp_neighbor_entry_cmp(struct eigrp_neighbor_entry *entry1,
-                         struct eigrp_neighbor_entry *entry2)
+static int eigrp_neighbor_entry_cmp(struct eigrp_neighbor_entry *entry1,
+				    struct eigrp_neighbor_entry *entry2)
 {
-  if (entry1->distance < entry2->distance) // parameter used in list_add_sort ()
-    return -1; // actually set to sort by distance
-  if (entry1->distance > entry2->distance)
-    return 1;
+	if (entry1->distance
+	    < entry2->distance) // parameter used in list_add_sort ()
+		return -1;      // actually set to sort by distance
+	if (entry1->distance > entry2->distance)
+		return 1;
 
-  return 0;
+	return 0;
 }
 
 /*
  * Returns new topology entry
  */
 
-struct eigrp_neighbor_entry *
-eigrp_neighbor_entry_new()
+struct eigrp_neighbor_entry *eigrp_neighbor_entry_new()
 {
-  struct eigrp_neighbor_entry *new;
+	struct eigrp_neighbor_entry *new;
 
-  new = XCALLOC(MTYPE_EIGRP_NEIGHBOR_ENTRY,
-                sizeof(struct eigrp_neighbor_entry));
-  new->reported_distance = EIGRP_MAX_METRIC;
-  new->distance = EIGRP_MAX_METRIC;
+	new = XCALLOC(MTYPE_EIGRP_NEIGHBOR_ENTRY,
+		      sizeof(struct eigrp_neighbor_entry));
+	new->reported_distance = EIGRP_MAX_METRIC;
+	new->distance = EIGRP_MAX_METRIC;
 
-  return new;
+	return new;
 }
 
 /*
  * Freeing topology table list
  */
-void
-eigrp_topology_free(struct list *list)
+void eigrp_topology_free(struct list *list)
 {
-  list_free(list);
+	list_free(list);
 }
 
 /*
  * Deleting all topology nodes in table
  */
-void
-eigrp_topology_cleanup(struct list *topology)
+void eigrp_topology_cleanup(struct list *topology)
 {
-  assert(topology);
+	assert(topology);
 
-  eigrp_topology_delete_all(topology);
+	eigrp_topology_delete_all(topology);
 }
 
 /*
  * Adding topology node to topology table
  */
-void
-eigrp_prefix_entry_add(struct list *topology, struct eigrp_prefix_entry *node)
+void eigrp_prefix_entry_add(struct list *topology,
+			    struct eigrp_prefix_entry *node)
 {
-  if (listnode_lookup(topology, node) == NULL)
-    {
-      listnode_add_sort(topology, node);
-    }
+	if (listnode_lookup(topology, node) == NULL) {
+		listnode_add_sort(topology, node);
+	}
 }
 
 /*
  * Adding topology entry to topology node
  */
-void
-eigrp_neighbor_entry_add(struct eigrp_prefix_entry *node,
-                         struct eigrp_neighbor_entry *entry)
+void eigrp_neighbor_entry_add(struct eigrp_prefix_entry *node,
+			      struct eigrp_neighbor_entry *entry)
 {
-  struct list *l = list_new ();
+	struct list *l = list_new();
 
-  listnode_add (l, entry);
+	listnode_add(l, entry);
 
-  if (listnode_lookup (node->entries, entry) == NULL)
-    {
-      listnode_add_sort (node->entries, entry);
-      entry->prefix = node;
+	if (listnode_lookup(node->entries, entry) == NULL) {
+		listnode_add_sort(node->entries, entry);
+		entry->prefix = node;
 
-      eigrp_zebra_route_add (node->destination_ipv4, l);
-    }
+		eigrp_zebra_route_add(node->destination_ipv4, l);
+	}
 
-  list_delete (l);
+	list_delete(l);
 }
 
 /*
  * Deleting topology node from topology table
  */
-void
-eigrp_prefix_entry_delete(struct list *topology,
-                          struct eigrp_prefix_entry *node)
+void eigrp_prefix_entry_delete(struct list *topology,
+			       struct eigrp_prefix_entry *node)
 {
-  struct eigrp *eigrp = eigrp_lookup ();
-
-  /*
-   * Emergency removal of the node from this list.
-   * Whatever it is.
-   */
-  listnode_delete (eigrp->topology_changes_internalIPV4, node);
-
-  if (listnode_lookup (topology, node) != NULL)
-    {
-      list_delete_all_node (node->entries);
-      list_free (node->entries);
-      list_free (node->rij);
-      listnode_delete (topology, node);
-      eigrp_zebra_route_delete (node->destination_ipv4);
-      XFREE (MTYPE_EIGRP_PREFIX_ENTRY,node);
-    }
+	struct eigrp *eigrp = eigrp_lookup();
+
+	/*
+	 * Emergency removal of the node from this list.
+	 * Whatever it is.
+	 */
+	listnode_delete(eigrp->topology_changes_internalIPV4, node);
+
+	if (listnode_lookup(topology, node) != NULL) {
+		list_delete_all_node(node->entries);
+		list_free(node->entries);
+		list_free(node->rij);
+		listnode_delete(topology, node);
+		eigrp_zebra_route_delete(node->destination_ipv4);
+		XFREE(MTYPE_EIGRP_PREFIX_ENTRY, node);
+	}
 }
 
 /*
  * Deleting topology entry from topology node
  */
-void
-eigrp_neighbor_entry_delete(struct eigrp_prefix_entry *node,
-                            struct eigrp_neighbor_entry *entry)
+void eigrp_neighbor_entry_delete(struct eigrp_prefix_entry *node,
+				 struct eigrp_neighbor_entry *entry)
 {
-  if (listnode_lookup(node->entries, entry) != NULL)
-    {
-      listnode_delete(node->entries, entry);
-      eigrp_zebra_route_delete (node->destination_ipv4);
-      XFREE(MTYPE_EIGRP_NEIGHBOR_ENTRY,entry);
-    }
+	if (listnode_lookup(node->entries, entry) != NULL) {
+		listnode_delete(node->entries, entry);
+		eigrp_zebra_route_delete(node->destination_ipv4);
+		XFREE(MTYPE_EIGRP_NEIGHBOR_ENTRY, entry);
+	}
 }
 
 /*
  * Deleting all nodes from topology table
  */
-void
-eigrp_topology_delete_all(struct list *topology)
+void eigrp_topology_delete_all(struct list *topology)
 {
-  list_delete_all_node(topology);
+	list_delete_all_node(topology);
 }
 
 /*
  * Return 0 if topology is not empty
  * otherwise return 1
  */
-unsigned int
-eigrp_topology_table_isempty(struct list *topology)
+unsigned int eigrp_topology_table_isempty(struct list *topology)
 {
-  if (topology->count)
-    return 1;
-  else
-    return 0;
+	if (topology->count)
+		return 1;
+	else
+		return 0;
 }
 
 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))
-        return data;
-    }
-
-  return NULL;
+	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))
+			return data;
+	}
+
+	return NULL;
 }
 
 /*
@@ -317,256 +293,236 @@ eigrp_topology_table_lookup_ipv4(struct list *topology_table,
  * That way we can clean up all the list_new and list_delete's
  * that we are doing.  DBS
  */
-struct list *
-eigrp_topology_get_successor(struct eigrp_prefix_entry *table_node)
+struct list *eigrp_topology_get_successor(struct eigrp_prefix_entry *table_node)
 {
-  struct list *successors = list_new();
-  struct eigrp_neighbor_entry *data;
-  struct listnode *node1, *node2;
-
-  for (ALL_LIST_ELEMENTS(table_node->entries, node1, node2, data))
-    {
-      if (data->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG)
-        {
-          listnode_add(successors, data);
-        }
-    }
-
-  /*
-   * If we have no successors return NULL
-   */
-  if (!successors->count)
-    {
-      list_delete(successors);
-      successors = NULL;
-    }
-
-  return successors;
+	struct list *successors = list_new();
+	struct eigrp_neighbor_entry *data;
+	struct listnode *node1, *node2;
+
+	for (ALL_LIST_ELEMENTS(table_node->entries, node1, node2, data)) {
+		if (data->flags & EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG) {
+			listnode_add(successors, data);
+		}
+	}
+
+	/*
+	 * If we have no successors return NULL
+	 */
+	if (!successors->count) {
+		list_delete(successors);
+		successors = NULL;
+	}
+
+	return successors;
 }
 
 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 list *successors = eigrp_topology_get_successor(table_node);
 
-          list_delete_node(successors, node);
+	if (successors && successors->count > maxpaths) {
+		do {
+			struct listnode *node = listtail(successors);
 
-        } while (successors->count > maxpaths);
-    }
+			list_delete_node(successors, node);
 
-  return successors;
+		} while (successors->count > maxpaths);
+	}
+
+	return successors;
 }
 
 struct eigrp_neighbor_entry *
 eigrp_prefix_entry_lookup(struct list *entries, struct eigrp_neighbor *nbr)
 {
-  struct eigrp_neighbor_entry *data;
-  struct listnode *node, *nnode;
-  for (ALL_LIST_ELEMENTS(entries, node, nnode, data))
-    {
-      if (data->adv_router == nbr)
-        {
-          return data;
-        }
-    }
-
-  return NULL;
+	struct eigrp_neighbor_entry *data;
+	struct listnode *node, *nnode;
+	for (ALL_LIST_ELEMENTS(entries, node, nnode, data)) {
+		if (data->adv_router == nbr) {
+			return data;
+		}
+	}
+
+	return NULL;
 }
 
 /* Lookup all prefixes from specified neighbor */
-struct list *
-eigrp_neighbor_prefixes_lookup(struct eigrp *eigrp, struct eigrp_neighbor *nbr)
+struct list *eigrp_neighbor_prefixes_lookup(struct eigrp *eigrp,
+					    struct eigrp_neighbor *nbr)
 {
-  struct listnode *node1, *node11, *node2, *node22;
-  struct eigrp_prefix_entry *prefix;
-  struct eigrp_neighbor_entry *entry;
-
-  /* create new empty list for prefixes storage */
-  struct list *prefixes = list_new();
-
-  /* iterate over all prefixes in topology table */
-  for (ALL_LIST_ELEMENTS(eigrp->topology_table, node1, node11, 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->adv_router == nbr)
-            {
-              listnode_add(prefixes, prefix);
-            }
-        }
-    }
-
-  /* return list of prefixes from specified neighbor */
-  return prefixes;
+	struct listnode *node1, *node11, *node2, *node22;
+	struct eigrp_prefix_entry *prefix;
+	struct eigrp_neighbor_entry *entry;
+
+	/* create new empty list for prefixes storage */
+	struct list *prefixes = list_new();
+
+	/* iterate over all prefixes in topology table */
+	for (ALL_LIST_ELEMENTS(eigrp->topology_table, node1, node11, 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->adv_router == nbr) {
+				listnode_add(prefixes, prefix);
+			}
+		}
+	}
+
+	/* return list of prefixes from specified neighbor */
+	return prefixes;
 }
 
-int
-eigrp_topology_update_distance(struct eigrp_fsm_action_message *msg)
+int eigrp_topology_update_distance(struct eigrp_fsm_action_message *msg)
 {
-  struct eigrp *eigrp = msg->eigrp;
-  struct eigrp_prefix_entry *prefix = msg->prefix;
-  struct eigrp_neighbor_entry *entry = msg->entry;
-  int change = 0;
-  assert(entry);
-
-  struct TLV_IPv4_External_type *ext_data = NULL;
-  struct TLV_IPv4_Internal_type *int_data = NULL;
-  if (msg->data_type == EIGRP_TLV_IPv4_INT)
-    {
-      int_data = msg->data.ipv4_int_type;
-      if (eigrp_metrics_is_same(int_data->metric, entry->reported_metric))
-        {
-          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) ? 2 : 3; // Increase : Decrease : No change
-      entry->reported_metric = 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;
-    }
-  /*
-   * Move to correct position in list according to new distance
-   */
-  listnode_delete(prefix->entries, entry);
-  listnode_add_sort(prefix->entries, entry);
-
-  return change;
+	struct eigrp *eigrp = msg->eigrp;
+	struct eigrp_prefix_entry *prefix = msg->prefix;
+	struct eigrp_neighbor_entry *entry = msg->entry;
+	int change = 0;
+	assert(entry);
+
+	struct TLV_IPv4_External_type *ext_data = NULL;
+	struct TLV_IPv4_Internal_type *int_data = NULL;
+	if (msg->data_type == EIGRP_TLV_IPv4_INT) {
+		int_data = msg->data.ipv4_int_type;
+		if (eigrp_metrics_is_same(int_data->metric,
+					  entry->reported_metric)) {
+			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)
+					   ? 2
+					   : 3; // Increase : Decrease : No
+						// change
+		entry->reported_metric = 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;
+	}
+	/*
+	 * Move to correct position in list according to new distance
+	 */
+	listnode_delete(prefix->entries, entry);
+	listnode_add_sort(prefix->entries, entry);
+
+	return change;
 }
 
-void
-eigrp_topology_update_all_node_flags(struct eigrp *eigrp)
+void eigrp_topology_update_all_node_flags(struct eigrp *eigrp)
 {
-  struct list *table = eigrp->topology_table;
-  struct eigrp_prefix_entry *data;
-  struct listnode *node, *nnode;
-  for (ALL_LIST_ELEMENTS(table, node, nnode, data))
-    {
-      eigrp_topology_update_node_flags(data);
-    }
+	struct list *table = eigrp->topology_table;
+	struct eigrp_prefix_entry *data;
+	struct listnode *node, *nnode;
+	for (ALL_LIST_ELEMENTS(table, node, nnode, data)) {
+		eigrp_topology_update_node_flags(data);
+	}
 }
 
-void
-eigrp_topology_update_node_flags(struct eigrp_prefix_entry *dest)
+void eigrp_topology_update_node_flags(struct eigrp_prefix_entry *dest)
 {
-  struct listnode *node;
-  struct eigrp_neighbor_entry *entry;
-  struct eigrp * eigrp = eigrp_lookup();
-
-  for (ALL_LIST_ELEMENTS_RO(dest->entries, node, entry))
-    {
-      if (((uint64_t)entry->distance <= (uint64_t)(dest->distance*eigrp->variance)) &&
-          entry->distance != EIGRP_MAX_METRIC) // is successor
-        {
-          entry->flags |= EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG;
-          entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_FSUCCESSOR_FLAG;
-        }
-      else if (entry->reported_distance < dest->fdistance) // is feasible successor
-        {
-          entry->flags |= EIGRP_NEIGHBOR_ENTRY_FSUCCESSOR_FLAG;
-          entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG;
-        }
-      else
-        {
-          entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_FSUCCESSOR_FLAG;
-          entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG;
-        }
-    }
+	struct listnode *node;
+	struct eigrp_neighbor_entry *entry;
+	struct eigrp *eigrp = eigrp_lookup();
+
+	for (ALL_LIST_ELEMENTS_RO(dest->entries, node, entry)) {
+		if (((uint64_t)entry->distance
+		     <= (uint64_t)(dest->distance * eigrp->variance))
+		    && entry->distance != EIGRP_MAX_METRIC) // is successor
+		{
+			entry->flags |= EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG;
+			entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_FSUCCESSOR_FLAG;
+		} else if (entry->reported_distance
+			   < dest->fdistance) // is feasible successor
+		{
+			entry->flags |= EIGRP_NEIGHBOR_ENTRY_FSUCCESSOR_FLAG;
+			entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG;
+		} else {
+			entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_FSUCCESSOR_FLAG;
+			entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_SUCCESSOR_FLAG;
+		}
+	}
 }
 
-void
-eigrp_update_routing_table(struct eigrp_prefix_entry * prefix)
+void eigrp_update_routing_table(struct eigrp_prefix_entry *prefix)
 {
-  struct eigrp *eigrp = eigrp_lookup();
-  struct list *successors = eigrp_topology_get_successor_max(prefix, eigrp->max_paths);
-  struct listnode *node;
-  struct eigrp_neighbor_entry *entry;
-
-  if (successors)
-    {
-      eigrp_zebra_route_add(prefix->destination_ipv4, successors);
-      for (ALL_LIST_ELEMENTS_RO (successors, node, entry))
-        entry->flags |= EIGRP_NEIGHBOR_ENTRY_INTABLE_FLAG;
-
-      list_delete(successors);
-    }
-  else
-    {
-      eigrp_zebra_route_delete(prefix->destination_ipv4);
-      for (ALL_LIST_ELEMENTS_RO (prefix->entries, node, entry))
-        entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_INTABLE_FLAG;
-    }
+	struct eigrp *eigrp = eigrp_lookup();
+	struct list *successors =
+		eigrp_topology_get_successor_max(prefix, eigrp->max_paths);
+	struct listnode *node;
+	struct eigrp_neighbor_entry *entry;
+
+	if (successors) {
+		eigrp_zebra_route_add(prefix->destination_ipv4, successors);
+		for (ALL_LIST_ELEMENTS_RO(successors, node, entry))
+			entry->flags |= EIGRP_NEIGHBOR_ENTRY_INTABLE_FLAG;
+
+		list_delete(successors);
+	} else {
+		eigrp_zebra_route_delete(prefix->destination_ipv4);
+		for (ALL_LIST_ELEMENTS_RO(prefix->entries, node, entry))
+			entry->flags &= ~EIGRP_NEIGHBOR_ENTRY_INTABLE_FLAG;
+	}
 }
 
-void
-eigrp_topology_neighbor_down(struct eigrp *eigrp, struct eigrp_neighbor * nbr)
+void eigrp_topology_neighbor_down(struct eigrp *eigrp,
+				  struct eigrp_neighbor *nbr)
 {
-  struct listnode *node1, *node11, *node2, *node22;
-  struct eigrp_prefix_entry *prefix;
-  struct eigrp_neighbor_entry *entry;
-
-  for (ALL_LIST_ELEMENTS(eigrp->topology_table, node1, node11, prefix))
-    {
-      for (ALL_LIST_ELEMENTS(prefix->entries, node2, node22, entry))
-        {
-          if (entry->adv_router == nbr)
-            {
-              struct eigrp_fsm_action_message *msg;
-              msg = XCALLOC(MTYPE_EIGRP_FSM_MSG,
-                            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;
-              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 = prefix;
-              int event = eigrp_get_fsm_event(msg);
-              eigrp_fsm_event(msg, event);
-            }
-        }
-    }
-
-  eigrp_query_send_all(eigrp);
-  eigrp_update_send_all(eigrp,nbr->ei);
-
+	struct listnode *node1, *node11, *node2, *node22;
+	struct eigrp_prefix_entry *prefix;
+	struct eigrp_neighbor_entry *entry;
+
+	for (ALL_LIST_ELEMENTS(eigrp->topology_table, node1, node11, prefix)) {
+		for (ALL_LIST_ELEMENTS(prefix->entries, node2, node22, entry)) {
+			if (entry->adv_router == nbr) {
+				struct eigrp_fsm_action_message *msg;
+				msg = XCALLOC(MTYPE_EIGRP_FSM_MSG,
+					      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;
+				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 = prefix;
+				int event = eigrp_get_fsm_event(msg);
+				eigrp_fsm_event(msg, event);
+			}
+		}
+	}
+
+	eigrp_query_send_all(eigrp);
+	eigrp_update_send_all(eigrp, nbr->ei);
 }
 
-void
-eigrp_update_topology_table_prefix(struct list * table, struct eigrp_prefix_entry * prefix)
+void eigrp_update_topology_table_prefix(struct list *table,
+					struct eigrp_prefix_entry *prefix)
 {
-  struct listnode *node1, *node2;
-
-  struct eigrp_neighbor_entry *entry;
-  for (ALL_LIST_ELEMENTS(prefix->entries, node1, node2, entry))
-    {
-      if(entry->distance == EIGRP_MAX_METRIC)
-        {
-          eigrp_neighbor_entry_delete(prefix,entry);
-        }
-    }
-  if(prefix->distance == EIGRP_MAX_METRIC && prefix->nt != EIGRP_TOPOLOGY_TYPE_CONNECTED)
-    {
-      eigrp_prefix_entry_delete(table,prefix);
-    }
+	struct listnode *node1, *node2;
+
+	struct eigrp_neighbor_entry *entry;
+	for (ALL_LIST_ELEMENTS(prefix->entries, node1, node2, entry)) {
+		if (entry->distance == EIGRP_MAX_METRIC) {
+			eigrp_neighbor_entry_delete(prefix, entry);
+		}
+	}
+	if (prefix->distance == EIGRP_MAX_METRIC
+	    && prefix->nt != EIGRP_TOPOLOGY_TYPE_CONNECTED) {
+		eigrp_prefix_entry_delete(table, prefix);
+	}
 }