aodv.pc

aodv program to simulate in glomosim simulator

    Message* msg,
    NODE_ADDR destAddr,
    AODV_BUFFER* buffer)
{
    AODV_BUFFER_Node* current;
    AODV_BUFFER_Node* previous;
    
    AODV_BUFFER_Node* newNode = 
       (AODV_BUFFER_Node *)checked_pc_malloc(sizeof(AODV_BUFFER_Node));

    newNode->destAddr = destAddr;
    newNode->msg = msg;
    newNode->timestamp = simclock();
    newNode->next = NULL;
    
    ++(buffer->size);
    
    // Find Insertion point.  Insert after all address matches.
    
    previous = NULL;
    current = buffer->head;
    while ((current != NULL) && (current->destAddr <= destAddr)) {
        previous = current;
        current = current->next;
    }//while//
    
    
    if (previous == NULL) {
        newNode->next = buffer->head;
        buffer->head = newNode;
    } else {
        newNode->next = previous->next;
        previous->next = newNode;
    }//if//
} /* RoutingAodvInsertBuffer */



/*
 * RoutingAodvInsertSent
 *
 * Insert an entry into the sent table if RREQ is sent
 */
static void
RoutingAodvInsertSent(
    NODE_ADDR destAddr,
    int ttl,
    AODV_SENT *sent)
{
    AODV_SENT_Node* current;
    AODV_SENT_Node* previous;
    
    AODV_SENT_Node* newNode = 
       (AODV_SENT_Node *)checked_pc_malloc(sizeof(AODV_SENT_Node));

    newNode->destAddr = destAddr;
    newNode->ttl = ttl;
    newNode->times = 0;
    newNode->next = NULL;
    
    (sent->size)++;
    
    // Find Insertion point.  Insert after all address matches.
    
    previous = NULL;
    current = sent->head;
    while ((current != NULL) && (current->destAddr <= destAddr)) {
        previous = current;
        current = current->next;
    }//while//
    
    
    if (previous == NULL) {
        newNode->next = sent->head;
        sent->head = newNode;
    } else {
        newNode->next = previous->next;
        previous->next = newNode;
    }//if//
} /* RoutingAodvInsertSent */

/*
 * RoutingAodvHandleRouteTimeout
 *
 * Mark route entry as invalid. The entry is scheduled to be deleted after DELETE_PERIOD
 */ 

void RoutingAodvHandleRouteTimeout(GlomoNode *node,NODE_ADDR destAddr)
{
   GlomoNetworkIp* ipLayer = (GlomoNetworkIp *) node->networkData.networkVar;
   GlomoRoutingAodv* aodv = (GlomoRoutingAodv *) ipLayer->routingProtocol;
   AODV_RT_Node *current;
   AODV_RT *routeTable = &aodv->routeTable;
   

   if (routeTable->size == 0 || routeTable->head == NULL)
   {
      return;
   }
   current = routeTable->head;
   while((current!=NULL)&&(current->destAddr<destAddr))
   {
      current = current->next;	   
   }
   if((current==NULL)||(current->destAddr!=destAddr))
   {
      return;
   } 
   assert(current->destAddr == destAddr);
   if(current->valid==FALSE)
   {	
     return;   
   }
   if(current->lifetime<=simclock())
   {
      current->valid = FALSE;
      current->repairable = FALSE;
      current->beingRepaired = FALSE;
      if(current->destSeqValid==TRUE)  current->destSeq++;
      current->lifetime=simclock()+ RoutingAodvGetDeletePeriod();
      RoutingAodvSetTimer(node, MSG_AODV_DeleteRouteEntry,
         destAddr,RoutingAodvGetDeletePeriod());
   }
}/*RoutingAodvHandleRouteTimeout*/

/*
 * RoutingAodvDeleteRouteTable
 *
 * Remove an entry from the route table
 */ 
void RoutingAodvDeleteRouteTable(GlomoNode *node,NODE_ADDR destAddr)
{
    GlomoNetworkIp* ipLayer = (GlomoNetworkIp *) node->networkData.networkVar;
    GlomoRoutingAodv* aodv = (GlomoRoutingAodv *) ipLayer->routingProtocol;
    AODV_RT *routeTable = &aodv->routeTable;
    AODV_RT_Node *toFree;
    AODV_RT_Node *current;
    AODV_PL_Node *plnode; 
   
    if (routeTable->size == 0 || routeTable->head == NULL)
    {
        return;
    }
    else if (routeTable->head->destAddr == destAddr)
    {
        if ((routeTable->head->lifetime <= simclock())&&(routeTable->head->valid==FALSE))
        {
            toFree = routeTable->head;
            routeTable->head = toFree->next;
	    plnode = toFree->precursorList.head;
	    while(plnode!=NULL)
	    {
	 	toFree->precursorList.head = plnode->next;
	        pc_free(plnode);	
		plnode = toFree->precursorList.head;
	    }
            pc_free(toFree);
            --(routeTable->size);
        }
    }
    else
    {
        for (current = routeTable->head; 
             current->next != NULL && current->next->destAddr < destAddr;
             current = current->next)
        {
        }
        if (current->next != NULL && current->next->destAddr == destAddr &&
            current->next->lifetime <= simclock() &&(current->next->valid==FALSE))
        {
            toFree = current->next;
            current->next = toFree->next;
	    plnode = toFree->precursorList.head;
	    while(plnode!=NULL)
	    {
	       toFree->precursorList.head = plnode->next;
	       pc_free(plnode);	
	       plnode = toFree->precursorList.head;
	    }
            pc_free(toFree);
            --(routeTable->size);
        }
    }
} /* RoutingAodvDeleteRouteTable */



/*
 * RoutingAodvDeleteNbrTable
 *
 * Remove an entry from the neighbor table ONLY if last helloed time was DELETE_PERIOD ago or more .....
 */
void RoutingAodvDeleteNbrTable(GlomoNode *node, NODE_ADDR nbrAddr)
{
  GlomoNetworkIp* ipLayer = (GlomoNetworkIp *) node->networkData.networkVar;
  GlomoRoutingAodv* aodv = (GlomoRoutingAodv *) ipLayer->routingProtocol;
  AODV_NT* nbrTable = &aodv->nbrTable;
  AODV_NT_Node *toFree;
  AODV_NT_Node *current;
  
    if (nbrTable->size == 0) 
    {
        return;
    } 
    else if ((nbrTable->head->nbrAddr == nbrAddr) && (nbrTable->head->lastHello + RoutingAodvGetDeletePeriod() <= simclock()))
    {
      toFree = nbrTable->head;
      nbrTable->head =toFree->next;
      pc_free(toFree);
      --(nbrTable->size);
      return;
    }
    else
    {
        for (current = nbrTable->head;
             ((current->next != NULL) && (current->next->nbrAddr < nbrAddr));
             current = current->next)
        {
        }

        if ((current->next != NULL )&& (current->next->nbrAddr == nbrAddr) && (current->next->lastHello + RoutingAodvGetDeletePeriod() <= simclock()))
        {
	  toFree = current->next;
	  current->next = toFree->next;
	  pc_free(toFree);
	  --(nbrTable->size);
	  return;
        }
    }
} /* RoutingAodvDeleteNbrTable */





/*
 * RoutingAodvDeleteSeenTable
 *
 * Remove an entry from the seen table
 */
void RoutingAodvDeleteSeenTable(AODV_RST *seenTable)
{
    AODV_RST_Node *toFree;

    toFree = seenTable->front;
    seenTable->front = toFree->next;
    pc_free(toFree);
    --(seenTable->size);

    if (seenTable->size == 0)
    {
        seenTable->rear = NULL;
    }

} /* RoutingAodvDeleteSeenTable */

/*
 * RoutingAodvDeleteBuffer
 *
 * Remove a packet from the buffer; Return TRUE if deleted
 */
BOOL RoutingAodvDeleteBuffer(NODE_ADDR destAddr, AODV_BUFFER *buffer)
{
    AODV_BUFFER_Node *toFree;
    AODV_BUFFER_Node *current;
    BOOL deleted;

    if (buffer->size == 0)
    {
        deleted = FALSE;
    }
    else if (buffer->head->destAddr == destAddr)
    {
        toFree = buffer->head;
        buffer->head = toFree->next;
        pc_free(toFree);
        --(buffer->size);
        deleted = TRUE;
    }
    else
    {
        for (current = buffer->head;
             current->next != NULL && current->next->destAddr < destAddr;
             current = current->next)
        {
        }

        if (current->next != NULL && current->next->destAddr == destAddr)
        {
            toFree = current->next;
            current->next = toFree->next;
            pc_free(toFree);
            --(buffer->size);
            deleted = TRUE;
        }
        else
        {
            deleted = FALSE;
        }
    }

    return (deleted);

} /* RoutingAodvDeleteBuffer */

/*
 * RoutingAodvDeleteSent
 *
 * Remove an entry from the sent table
 */
void RoutingAodvDeleteSent(NODE_ADDR destAddr, AODV_SENT *sent)
{
    AODV_SENT_Node *toFree;
    AODV_SENT_Node *current;

    if (sent->size == 0)
    {
        return;
    }
    else if (sent->head->destAddr == destAddr)
    {
        toFree = sent->head;
        sent->head = toFree->next;
        pc_free(toFree);
        --(sent->size);
    }
    else
    {
        for (current = sent->head;
             current->next != NULL && current->next->destAddr < destAddr;
             current = current->next)
        {
        }

        if (current->next != NULL && current->next->destAddr == destAddr)
        {
            toFree = current->next;
            current->next = toFree->next;
            pc_free(toFree);
            --(sent->size);
        }
    }

} /* RoutingAodvDeleteSent */


/*
 * RoutingAodvUpdateLifetime
 *
 * Update the lifetime field of the destination entry in the route table
 */
void RoutingAodvUpdateLifetime(NODE_ADDR destAddr, AODV_RT *routeTable)
{
    AODV_RT_Node *current;

    for (current = routeTable->head;
         current != NULL && current->destAddr <= destAddr;
         current = current->next)
    {
        if (current->destAddr == destAddr && current->valid==TRUE)
        {
	  if(current->lifetime < simclock() + ACTIVE_ROUTE_TIMEOUT)	
            current->lifetime = simclock() + ACTIVE_ROUTE_TIMEOUT;
	  
            return;
        }
    }
} /* RoutingAodvUpdateLifetime */

/*
 * RoutingAodvIncreaseSeq
 *
 * Increase the sequence number
 */
void RoutingAodvIncreaseSeq(GlomoNode *node)
{
    GlomoNetworkIp* ipLayer = (GlomoNetworkIp *) node->networkData.networkVar;
    GlomoRoutingAodv* aodv = (GlomoRoutingAodv *) ipLayer->routingProtocol;

    aodv->seqNumber++;

} /* RoutingAodvIncreaseSeq */

/*
 * RoutingAodvIncreaseTtl
 *
 * Increase the TTL value
 */
void RoutingAodvIncreaseTtl(NODE_ADDR destAddr, AODV_SENT *sent)
{
    AODV_SENT_Node *current;

    for (current = sent->head;
         current != NULL && current->destAddr <= destAddr;
         current = current->next)
    {
        if (current->destAddr == destAddr)
        {
            current->ttl += TTL_INCREMENT;

            if (current->ttl > TTL_THRESHOLD)
            {
                current->ttl = NET_DIAMETER;
            }
	   
            return;
        }

    }

} /* RoutingAodvIncreaseTtl */


/*
 * RoutingAodvIncreaseTimes
 *
 * Increase the number of times RREQ sent in TTL = NET_DIAMETER
 */
void RoutingAodvIncreaseTimes(NODE_ADDR destAddr, AODV_SENT *sent)
{
    AODV_SENT_Node *current;

    for (current = sent->head;
         current != NULL && current->destAddr <= destAddr;
         current = current->next)
    {
        if (current->destAddr == destAddr)
        {
            current->times++;
            return;
        }
    }

} /* RoutingAodvIncreaseTimes */

/*
 * RoutingAodvActivateRoute
 *
 * Activate a route in the route table