void rt_table_destroy() {
int i = 0;
rt_table_t *entry, *tmp;
for(i = 0; i < RT_TABLESIZE; i++) {
entry = routing_table[i];
while(entry != NULL) {
/* Destroy and free memory used by precursor list for this
entry */
#ifdef DEBUG
log(LOG_INFO, 0, "routing_table_destroy: Clearing bucket %d", i);
#endif
precursor_list_destroy(entry);
if(!IS_INFTY(entry->hcnt)) {
k_del_rte(entry->dest, 0, 0);
/* k_del_arp(entry->dest); */
#ifdef DEBUG
log(LOG_INFO, 0, "routing_table_destroy: Removing kernel route %s",
ip_to_str(entry->dest));
#endif
}
tmp = entry;
entry = entry->next;
/* Free memory used by this route entry */
free(tmp);
}
}
}
void rt_table_destroy()
{
int ret, i = 0;
rt_table_t *rt_entry, *tmp;
for (i = 0; i < RT_TABLESIZE; i++) {
rt_entry = routing_table[i];
while (rt_entry != NULL) {
/* Destroy and free memory used by precursor list for this
entry */
#ifdef DEBUG
log(LOG_INFO, 0, "routing_table_destroy: Clearing bucket %d",
i);
#endif
precursor_list_destroy(rt_entry);
if (rt_entry->hcnt != INFTY) {
ret = k_del_rte(rt_entry->dest_addr, 0, 0);
if (ret < 0)
log(LOG_WARNING, errno,
"rt_table_destroy: Could not delete kernel route!");
}
tmp = rt_entry;
rt_entry = rt_entry->next;
/* Free memory used by this route entry */
free(tmp);
}
}
}
void rt_table_delete(u_int32_t dest_addr)
{
rt_table_t *rt_entry, *prev;
hash_value hash;
unsigned int index;
/* Calculate index */
index = hashing(&dest_addr, &hash);
for (prev = NULL, rt_entry = routing_table[index];
rt_entry != NULL; prev = rt_entry, rt_entry = rt_entry->next) {
if (rt_entry->hash != hash)
continue;
if (memcmp(&dest_addr, &rt_entry->dest_addr, sizeof(u_int32_t)) == 0) {
if (prev == NULL)
routing_table[index] = rt_entry->next;
else
prev->next = rt_entry->next;
precursor_list_destroy(rt_entry);
if (rt_entry->hcnt != INFTY)
k_del_rte(dest_addr, 0, 0);
/* Make sure any timers are removed... */
timer_remove(&rt_entry->rt_timer);
timer_remove(&rt_entry->hello_timer);
timer_remove(&rt_entry->ack_timer);
free(rt_entry);
return;
}
}
}
void NS_CLASS local_repair_timeout(void *arg)
{
rt_table_t *rt;
struct in_addr rerr_dest;
RERR *rerr = NULL;
rt = (rt_table_t *) arg;
if (!rt)
return;
rerr_dest.s_addr = AODV_BROADCAST; /* Default destination */
/* Unset the REPAIR flag */
rt->flags &= ~RT_REPAIR;
#ifndef NS_PORT
nl_send_del_route_msg(rt->dest_addr, rt->next_hop, rt->hcnt);
#endif
/* Route should already be invalidated. */
if (rt->nprec) {
rerr = rerr_create(0, rt->dest_addr, rt->dest_seqno);
if (rt->nprec == 1) {
rerr_dest = FIRST_PREC(rt->precursors)->neighbor;
aodv_socket_send((AODV_msg *) rerr, rerr_dest,
RERR_CALC_SIZE(rerr), 1,
&DEV_IFINDEX(rt->ifindex));
} else {
int i;
for (i = 0; i < MAX_NR_INTERFACES; i++) {
if (!DEV_NR(i).enabled)
continue;
aodv_socket_send((AODV_msg *) rerr, rerr_dest,
RERR_CALC_SIZE(rerr), 1,
&DEV_NR(i));
}
}
DEBUG(LOG_DEBUG, 0, "Sending RERR about %s to %s",
ip_to_str(rt->dest_addr), ip_to_str(rerr_dest));
}
precursor_list_destroy(rt);
/* Purge any packets that may be queued */
/* packet_queue_set_verdict(rt->dest_addr, PQ_DROP); */
rt->rt_timer.handler = &NS_CLASS route_delete_timeout;
timer_set_timeout(&rt->rt_timer, DELETE_PERIOD);
DEBUG(LOG_DEBUG, 0, "%s removed in %u msecs",
ip_to_str(rt->dest_addr), DELETE_PERIOD);
}
rt_table_t *rt_table_update(rt_table_t * rt_entry, u_int32_t next,
u_int8_t hops, u_int32_t seqno,
u_int32_t newlife, u_int16_t flags)
{
int ret;
/* If this previously was an expired route, but will now be active again
we must add it to the kernel routing table... */
if (rt_entry->hcnt == INFTY && hops != INFTY) {
rt_entry->rt_timer.handler = route_expire_timeout;
ret = k_add_rte(rt_entry->dest_addr, next, 0, hops, rt_entry->ifindex);
if (ret < 0)
log(LOG_WARNING, errno,
"rt_table_update: Could not add kernel route!");
#ifdef DEBUG
else
log(LOG_INFO, 0,
"rt_table_update: Added kernel route for expired %s",
ip_to_str(rt_entry->dest_addr));
#endif
} else if (rt_entry->next_hop != 0 &&
rt_entry->next_hop != next) {
#ifdef DEBUG
log(LOG_INFO, 0, "rt_table_update: rt_entry->nxt_addr=%s, next=%s",
ip_to_str(rt_entry->next_hop), ip_to_str(next));
#endif
precursor_list_destroy(rt_entry);
ret = k_chg_rte(rt_entry->dest_addr, next, 0, hops, rt_entry->ifindex);
if (ret < 0)
log(LOG_WARNING, errno,
"rt_table_update: Could not update kernel route!");
}
rt_entry->dest_seqno = seqno;
rt_entry->last_life = newlife;
rt_entry->flags = flags;
rt_entry->next_hop = next;
rt_entry->last_hcnt = rt_entry->hcnt;
rt_entry->hcnt = hops;
if (hops > 1) {
rt_entry->last_hello_time.tv_sec = 0;
rt_entry->last_hello_time.tv_usec = 0;
rt_entry->hello_cnt = 0;
}
/* If newlife = 0 the timer and the expire time should not be
updated... */
if (newlife != 0)
rt_table_update_timeout(rt_entry, newlife);
return rt_entry;
}
/* Route expiry and Deletion, AODV draft v.9, section 8.13. */
int rt_table_invalidate(rt_table_t * rt_entry)
{
#ifdef DEBUG
struct timeval now;
gettimeofday(&now, NULL);
#endif
if (rt_entry == NULL)
return -1;
#ifdef DEBUG
if(rt_entry->hello_timer.used)
log(LOG_DEBUG, 0, "route_expire_timeout: last HELLO: %ld",
timeval_diff(&now, &rt_entry->last_hello_time) / 1000);
#endif
timer_remove(&rt_entry->rt_timer);
timer_remove(&rt_entry->hello_timer);
timer_remove(&rt_entry->ack_timer);
/* Save last hopcount */
rt_entry->last_hcnt = rt_entry->hcnt;
/* Set infinity hop count */
rt_entry->hcnt = INFTY;
/* When the lifetime of a route entry expires, increase the sequence
number for that entry. (AODV draft v.10, section 6.1.) */
rt_entry->dest_seqno++;
rt_entry->flags = 0;
rt_entry->last_life = 0;
if (rt_entry->last_hcnt == 1)
rt_table_remove_precursor(rt_entry->dest_addr);
/* We should delete the precursor list for all unreachable
destinations. */
precursor_list_destroy(rt_entry);
/* Delete kernel routing table entry. */
k_del_rte(rt_entry->dest_addr, 0, 0);
/* Schedule a deletion timer */
rt_entry->rt_timer.handler = route_delete_timeout;
timer_add_msec(&rt_entry->rt_timer, DELETE_PERIOD);
#ifdef DEBUG
log(LOG_DEBUG, 0, "rt_table_invalidate: %s removed in %u msecs",
ip_to_str(rt_entry->dest_addr), DELETE_PERIOD);
#endif
return 0;
}
void NS_CLASS local_repair_timeout(void *arg)
{
rt_table_t *rt;
u_int32_t rerr_dest = AODV_BROADCAST;
RERR *rerr = NULL;
rt = (rt_table_t *) arg;
if (!rt)
return;
/* Unset the REPAIR flag */
rt->flags &= ~RT_REPAIR;
rt->rt_timer.handler = &NS_CLASS route_delete_timeout;
timer_set_timeout(&rt->rt_timer, DELETE_PERIOD);
DEBUG(LOG_DEBUG, 0, "%s removed in %u msecs",
ip_to_str(rt->dest_addr), DELETE_PERIOD);
/* Route should already be invalidated. */
if (rt->nprec) {
rerr = rerr_create(0, rt->dest_addr, rt->dest_seqno);
if (rt->nprec == 1) {
rerr_dest = FIRST_PREC(rt->precursors)->neighbor;
aodv_socket_send((AODV_msg *) rerr, rerr_dest,
RERR_CALC_SIZE(rerr), 1,
&DEV_IFINDEX(rt->ifindex));
} else {
int i;
for (i = 0; i < MAX_NR_INTERFACES; i++) {
if (!DEV_NR(i).enabled)
continue;
aodv_socket_send((AODV_msg *) rerr, rerr_dest,
RERR_CALC_SIZE(rerr), 1, &DEV_NR(i));
}
}
DEBUG(LOG_DEBUG, 0, "Sending RERR about %s to %s",
ip_to_str(rt->dest_addr), ip_to_str(rerr_dest));
}
precursor_list_destroy(rt);
}
void NS_CLASS route_expire_timeout(void *arg)
{
rt_table_t *rt;
rt = (rt_table_t *) arg;
if (!rt) {
log(LOG_WARNING, 0, __FUNCTION__, "arg was NULL, ignoring timeout!");
return;
}
DEBUG(LOG_DEBUG, 0, "Route %s DOWN, seqno=%d",
ip_to_str(rt->dest_addr), rt->dest_seqno);
rt_table_invalidate(rt);
precursor_list_destroy(rt);
return;
}
void rt_table_delete(u_int32_t dest) {
rt_table_t *entry, *prev;
hash_value hash;
unsigned int index;
/* Calculate index */
index = hashing(&dest, &hash);
entry = routing_table[index];
prev = NULL;
for(; entry != NULL; prev = entry, entry = entry->next) {
if(entry->hash != hash)
continue;
if(memcmp(&dest, &entry->dest, sizeof(u_int32_t)) == 0) {
if(prev == NULL)
routing_table[index] = entry->next;
else
prev = entry->next;
total_entries--;
precursor_list_destroy(entry);
if(!IS_INFTY(entry->hcnt)) {
k_del_rte(dest, 0, 0);
/* k_del_arp(entry->dest); */
}
/* Make sure any timers are removed... */
if(entry->timer_id)
timer_remove(entry->timer_id);
if(entry->hello_timer_id)
timer_remove(entry->hello_timer_id);
if(entry->ack_timer_id)
timer_remove(entry->ack_timer_id);
free(entry);
return;
}
}
}
/* Route expiry and Deletion, AODV draft v.9, section 8.13. */
int rt_table_invalidate(rt_table_t *entry) {
if (entry == NULL)
return -1;
/* Remove hello timer if it exists... */
if(entry->hello_timer_id)
timer_remove(entry->hello_timer_id);
/* Save last hopcount */
entry->last_hcnt = entry->hcnt;
/* Set infinity hop count */
entry->hcnt = INFTY;
/* When the lifetime of a route entry expires, increase the sequence
number for that entry. (AODV draft v.9, section 8.13.) */
entry->dest_seqno++;
entry->flags = 0;
entry->last_life = 0;
if(entry->hcnt == 1) {
/* AODV draft 9, section 8.11: When a node invalidates a route to
a neighboring node, it MUST also delete that neighbor from any
precursor lists for routes to other nodes. This prevents
precursor lists from containing stale entries of neighbors with
which the node is no longer able to communicate. The node does
this by inspecting the precursor list of each destination entry
in its routing table, and deleting the lost neighbor from any
list in which it appears. */
rt_table_remove_precursor(entry->dest);
/* We should also update our own sequence number whenever our
neighbor set changes. */
this_host->seqno++;
}
/* We should delete the precursor list for all unreachable
destinations. */
precursor_list_destroy(entry);
/* Delete kernel route and arp entry. Also make sure the routing
cache does not contain any stale entries that could make IP
believe we still have contact with this route */
k_del_rte(entry->dest, 0, 0);
/* k_del_arp(entry->dest); */
/* Schedule a deletion timer, but first make sure a possible existing
timer is deleted */
timer_remove(entry->timer_id);
#ifdef DEBUG
log(LOG_DEBUG, 0, "rt_table_invalidate: %s removed in %u msecs",
ip_to_str(entry->dest), DELETE_PERIOD);
#endif
entry->timer_id = timer_new(DELETE_PERIOD, route_delete_timeout, entry);
return 0;
}
