aodv_rreq.c

支持IPv6的adov路由协议（本人修改后）

		  ip6_to_str(rreq_dest), ip6_to_str(rreq_orig));
#else
	    DEBUG(LOG_INFO, 0,
		  "rreq_process: Sending G-RREP to %s with rte to %s",
		  ip_to_str(rreq_dest), ip_to_str(rreq_orig));
#endif /* _IPV6 */
	}
    } else if (ip_ttl > 1) {
	int i;
	/* FORWARD the RREQ if the TTL allows it. */
	//PL:
	if((rreq->i)&&(internet_gw_mode==0)) /*disable gw_mode,don't forward GW_SOL*/
		return;
#ifdef _IPV6
	DEBUG(LOG_INFO, 0, "rreq_process: forwarding RREQ src=%s, rreq_id=%lu",
	      ip6_to_str(rreq_orig), rreq_id);
#else
	DEBUG(LOG_INFO, 0, "rreq_process: forwarding RREQ src=%s, rreq_id=%lu",
	      ip_to_str(rreq_orig), rreq_id);
#endif /* _IPV6 */

	/* Queue the received message in the send buffer */
	rreq = (RREQ *) aodv_socket_queue_msg((AODV_msg *) rreq, rreqlen);


	--ip_ttl;
	rreq->hcnt++;		/* Increase hopcount to account for
				   * intermediate route */

	fwd_rt = rt_table_find(rreq_dest);
	if (fwd_rt && fwd_rt->dest_seqno > rreq_dest_seqno)
	    rreq->dest_seqno = htonl(fwd_rt->dest_seqno);

	/* Send out on all interfaces */
	for (i = 0; i < MAX_NR_INTERFACES; i++) {
	    if (!DEV_NR(i).enabled)
		continue;
	    //PL:
#ifdef _IPV6
	    aodv_socket_send((AODV_msg *) rreq, ipv6_multicast_addr, RREQ_SIZE,
			     ip_ttl, &DEV_NR(i));
#else
	    aodv_socket_send((AODV_msg *) rreq, AODV_BROADCAST, RREQ_SIZE,
			     ip_ttl, &DEV_NR(i));
#endif /* _IPV6 */
	}
    }
    return;
}

/* Perform route discovery for a unicast destination */

//PL:
#ifdef _IPV6
void NS_CLASS rreq_route_discovery(struct in6_addr dest_addr, u_int8_t flags,
				   struct ip_data *ipd)
#else
void NS_CLASS rreq_route_discovery(u_int32_t dest_addr, u_int8_t flags,
				   struct ip_data *ipd)
#endif /* _IPV6 */
{
    RREQ *rreq;
    struct timeval now;
    rt_table_t *rt_entry;
    seek_list_t *seek_entry;
    u_int32_t dest_seqno;
    int ttl, i;

    gettimeofday(&now, NULL);
    if ((gw_find_flag==GW_FIND_NO_NEED)&&expanding_ring_search)
	ttl = TTL_START;
    else
	ttl = NET_DIAMETER;	/* This is the TTL if we don't use expanding
				   ring search */

    /* If we already have a route entry, we must check if it is an
       invalid (hopcnt = INFNTY). */
    rt_entry = rt_table_find(dest_addr);

    if (rt_entry == NULL)
	dest_seqno = 0;
    else if (rt_entry->hcnt == INFTY || (rt_entry->flags & UNIDIR)) {
	/* If a RREP was previously received, the hop count of that
	   packet is remembered as Last Hop Count in the routing table
	   of non active routes.  We use this value (if available) for
	   calculating an intital TTL in the IP header. We also use the
	   last known sequence number... */
	dest_seqno = rt_entry->dest_seqno;

	if ((gw_find_flag==GW_FIND_NO_NEED)&&expanding_ring_search && rt_entry->last_hcnt != INFTY)
	    ttl = rt_entry->last_hcnt + TTL_INCREMENT;

	/* A routing table entry waiting for a RREP should not be expunged
	   before PATH_TRAVERSAL_TIME... (Draft 10 section 6.4) */
	if (timeval_diff(&rt_entry->rt_timer.timeout, &now) / 1000 <
	    PATH_TRAVERSAL_TIME)
	    rt_table_update_timeout(rt_entry, PATH_TRAVERSAL_TIME);

    } else {

      //PL:
#ifdef _IPV6
	DEBUG(LOG_INFO, 0,
	      "rreq_route_discovery: Route already exist for %s??",
	      ip6_to_str(dest_addr));
#else
	DEBUG(LOG_INFO, 0,
	      "rreq_route_discovery: Route already exist for %s??",
	      ip_to_str(dest_addr));
#endif /* _IPV6 */

	return;			/* Something strange here? */
    }
    /* Remember that we are seeking this destination */
    seek_entry = seek_list_insert(dest_addr, dest_seqno, ttl, flags, ipd);
        /* Set a timer for this RREQ */
    
    if ((gw_find_flag==GW_FIND_NO_NEED)&&expanding_ring_search)
	timer_add_msec(&seek_entry->seek_timer, 2 * ttl * NODE_TRAVERSAL_TIME);
    else
	timer_add_msec(&seek_entry->seek_timer, NET_TRAVERSAL_TIME);
    //PL:
#ifdef _IPV6
    DEBUG(LOG_DEBUG, 0,
	  "rreq_route_discovery: Seeking %s hop limit=%d", ip6_to_str(dest_addr), ttl);
#else
    DEBUG(LOG_DEBUG, 0,
	  "rreq_route_discovery: Seeking %s ttl=%d", ip_to_str(dest_addr), ttl);
#endif /* _IPV6 */

    /* Check if we should force the gratuitous flag... (-g option). */
    if (rreq_gratuitous)
	flags |= RREQ_GRATUITOUS;

    /* Broadcast on all interfaces */
    for (i = 0; i < MAX_NR_INTERFACES; i++) {
	if (!DEV_NR(i).enabled)
	    continue;
	//rreq = rreq_create(flags, dest_addr, dest_seqno, DEV_NR(i).ipaddr);
	if(new_ip6addr_head)
		rreq = rreq_create(flags, dest_addr, dest_seqno, new_ip6addr_head->ip6_in6addr);
	else
		continue;
	//PL:
#ifdef _IPV6
	aodv_socket_send((AODV_msg *) rreq, ipv6_multicast_addr, RREQ_SIZE, ttl,
			 &DEV_NR(i));
#else
	aodv_socket_send((AODV_msg *) rreq, AODV_BROADCAST, RREQ_SIZE, ttl,
			 &DEV_NR(i));
#endif /* _IPV6 */
    }
    return;
}

/* Local repair is not yet completely implemented... */
void NS_CLASS rreq_local_repair(rt_table_t * rt_entry)
{
    RREQ *rreq;
    seek_list_t *seek_entry;
    int ttl, i;
    u_int8_t flags = 0;

    if (!rt_entry)
	return;

    if (seek_list_find(rt_entry->dest_addr))
	return;

    rt_entry->flags |= LREPAIR;

    ttl = (int) (max(rt_entry->last_hcnt, 0.5 * 1) + LOCAL_ADD_TTL);

    rt_entry->dest_seqno++;

    /* Remember that we are seeking this destination */
    seek_entry =
	seek_list_insert(rt_entry->dest_addr, rt_entry->dest_seqno, ttl,
			 flags, NULL);

    if (expanding_ring_search)
	timer_add_msec(&seek_entry->seek_timer, 2 * ttl * NODE_TRAVERSAL_TIME);
    else
	timer_add_msec(&seek_entry->seek_timer, NET_TRAVERSAL_TIME);

    //PL:
#ifdef _IPV6
    DEBUG(LOG_DEBUG, 0,
	  "rreq_local_repair: Seeking %s ttl=%d",
	  ip6_to_str(rt_entry->dest_addr), ttl);
#else
    DEBUG(LOG_DEBUG, 0,
	  "rreq_local_repair: Seeking %s ttl=%d",
	  ip_to_str(rt_entry->dest_addr), ttl);
#endif /* _IPV6 */

    /* Check if we should force the gratuitous flag... (-g option). */
    if (rreq_gratuitous)
	flags |= RREQ_GRATUITOUS;

    /* Broadcast on all interfaces */
    for (i = 0; i < MAX_NR_INTERFACES; i++) {
	if (!DEV_NR(i).enabled)
	    continue;
	//rreq = rreq_create(flags, rt_entry->dest_addr, rt_entry->dest_seqno,DEV_NR(i).ipaddr);
	if(new_ip6addr_head)
		rreq=rreq_create(flags,rt_entry->dest_addr,rt_entry->dest_seqno,new_ip6addr_head->ip6_in6addr);
	else
		continue;
	//PL:
#ifdef _IPV6
	aodv_socket_send((AODV_msg *) rreq, ipv6_multicast_addr, RREQ_SIZE, ttl,
			 &DEV_NR(i));
#else
	aodv_socket_send((AODV_msg *) rreq, AODV_BROADCAST, RREQ_SIZE, ttl,
			 &DEV_NR(i));
#endif /* _IPV6 */
    }
    return;
}

//PL:
#ifdef _IPV6
NS_STATIC struct rreq_record *NS_CLASS rreq_record_insert(struct in6_addr orig_addr,
							  u_int32_t rreq_id)
#else
NS_STATIC struct rreq_record *NS_CLASS rreq_record_insert(u_int32_t orig_addr,
							  u_int32_t rreq_id)
#endif /* _IPV6 */
{
    struct rreq_record *rreq_pkt;

    /* First check if this rreq packet is already buffered */
    rreq_pkt = rreq_record_find(orig_addr, rreq_id);

    /* If already buffered, should we update the timer??? Section 8.3 in
       the draft is not clear about this. */
    if (rreq_pkt)
	return rreq_pkt;

    if ((rreq_pkt =
	 (struct rreq_record *) malloc(sizeof(struct rreq_record))) < 0) {
	fprintf(stderr, "rreq_record_insert: Malloc failed!!!\n");
	exit(-1);
    }
    //PL:
#ifdef _IPV6
    memcpy(&rreq_pkt->orig_addr, &orig_addr, sizeof(struct in6_addr));
#else
    rreq_pkt->orig_addr = orig_addr;
#endif /* _IPV6 */
    rreq_pkt->rreq_id = rreq_id;
    rreq_pkt->rec_timer.handler = &NS_CLASS rreq_record_timeout;
    rreq_pkt->rec_timer.data = rreq_pkt;
    rreq_pkt->next = rreq_record_head;
    rreq_record_head = rreq_pkt;

    //PL:
#ifdef _IPV6
    DEBUG(LOG_INFO, 0, "Buffering RREQ %s rreq_id=%lu time=%u",
	  ip6_to_str(orig_addr), rreq_id, PATH_TRAVERSAL_TIME);
#else
    DEBUG(LOG_INFO, 0, "Buffering RREQ %s rreq_id=%lu time=%u",
	  ip_to_str(orig_addr), rreq_id, PATH_TRAVERSAL_TIME);
#endif /* _IPV6 */

    timer_add_msec(&rreq_pkt->rec_timer, PATH_TRAVERSAL_TIME);
    return rreq_pkt;
}

//PL:
#ifdef _IPV6
NS_STATIC struct rreq_record *NS_CLASS rreq_record_find(struct in6_addr orig_addr,
							u_int32_t rreq_id)
#else
NS_STATIC struct rreq_record *NS_CLASS rreq_record_find(u_int32_t orig_addr,
							u_int32_t rreq_id)
#endif /* _IPV6 */
{
    struct rreq_record *rreq_pkt;

    rreq_pkt = rreq_record_head;

    while (rreq_pkt != NULL) 
      {
	//PL:
#ifdef _IPV6
	if ( (memcmp(&rreq_pkt->orig_addr, &orig_addr, sizeof(struct in6_addr)) == 0) 
	     && (rreq_pkt->rreq_id == rreq_id))
#else
	if (rreq_pkt->orig_addr == orig_addr && (rreq_pkt->rreq_id == rreq_id))
#endif /* _IPV6 */
	  {	
	    return rreq_pkt;
	  }
	rreq_pkt = rreq_pkt->next;
      }
    return NULL;
}

//PL:
#ifdef _IPV6
int NS_CLASS rreq_record_remove(struct in6_addr orig_addr, u_int32_t rreq_id)
#else
int NS_CLASS rreq_record_remove(u_int32_t orig_addr, u_int32_t rreq_id)
#endif /* _IPV6 */
{
    struct rreq_record *curr, *prev;

    prev = NULL;
    curr = rreq_record_head;
    while (curr != NULL)
      {
	//PL:
#ifdef _IPV6
	if ( (memcmp(&curr->orig_addr, &orig_addr, sizeof(struct in6_addr)) == 0)
	     && (curr->rreq_id == rreq_id))
#else
	if (curr->orig_addr == orig_addr && (curr->rreq_id == rreq_id))
#endif /* _IPV6 */
	  {
	    if (prev == NULL)
		rreq_record_head = curr->next;
	    else
		prev->next = curr->next;

	    free(curr);
	    return 0;
	  }
	prev = curr;
	curr = curr->next;
      }
    return -1;
}

//PL:
#ifdef _IPV6
struct blacklist *NS_CLASS rreq_blacklist_insert(struct in6_addr dest_addr)
#else
struct blacklist *NS_CLASS rreq_blacklist_insert(u_int32_t dest_addr)
#endif /* _IPV6 */
{

    struct blacklist *bl_entry;

    /* First check if this rreq packet is already buffered */
    bl_entry = rreq_blacklist_find(dest_addr);

    /* If already buffered, should we update the timer??? Section 8.3 in
       the draft is not clear about this. */
    if (bl_entry)
	return bl_entry;

    if ((bl_entry = (struct blacklist *) malloc(sizeof(struct blacklist))) < 0) {
	fprintf(stderr, "rreq_blacklist_insert: Malloc failed!!!\n");
	exit(-1);
    }
    //PL:
#ifdef _IPV6
    memcpy(&bl_entry->dest_addr, &dest_addr, sizeof(struct in6_addr));
#else
    bl_entry->dest_addr = dest_addr;
#endif /* _IPV6 */
    bl_entry->bl_timer.handler = &NS_CLASS rreq_blacklist_timeout;
    bl_entry->bl_timer.data = bl_entry;
    bl_entry->next = rreq_blacklist_head;
    rreq_blacklist_head = bl_entry;

    timer_add_msec(&bl_entry->bl_timer, BLACKLIST_TIMEOUT);
    return bl_entry;
}

//PL:
#ifdef _IPV6
struct blacklist *NS_CLASS rreq_blacklist_find(struct in6_addr dest_addr)
#else
struct blacklist *NS_CLASS rreq_blacklist_find(u_int32_t dest_addr)
#endif /* _IPV6 */
{
    struct blacklist *bl_entry;

    bl_entry = rreq_blacklist_head;

    while (bl_entry != NULL)
      {
	//PL:
#ifdef _IPV6
        if (memcmp(&bl_entry->dest_addr, &dest_addr, sizeof(struct in6_addr)) == 0)
#else
	if (bl_entry->dest_addr == dest_addr)
#endif /* _IPV6 */
	    return bl_entry;
	bl_entry = bl_entry->next;
      }
    return NULL;
}

//PL:
#ifdef _IPV6
int NS_CLASS rreq_blacklist_remove(struct in6_addr dest_addr)
#else
int NS_CLASS rreq_blacklist_remove(u_int32_t dest_addr)
#endif /* _IPV6 */
{
    struct blacklist *curr, *prev;

    prev = NULL;
    curr = rreq_blacklist_head;
    while (curr != NULL)
      {
	//PL:
#ifdef _IPV6
        if (memcmp(&curr->dest_addr, &dest_addr, sizeof(struct in6_addr)) == 0) 
#else
	if (curr->dest_addr == dest_addr) 
#endif /* _IPV6 */
	  {
	    if (prev == NULL)
		rreq_blacklist_head = curr->next;
	    else
		prev->next = curr->next;

	    free(curr);
	    return 0;
	  }
	prev = curr;
	curr = curr->next;
    }
    return -1;
}