dsr.pc

simulator for ad hoc

    }
    else if (old->destAddr > destAddr)
    {
        newOne = (DSR_BUFFER_Node *)pc_malloc(sizeof(DSR_BUFFER_Node));
        assert(newOne != NULL);

        newOne->destAddr = destAddr;
        newOne->msg = msg;
        newOne->timestamp = simclock();
        newOne->next = old;
    }
    else if (old->destAddr == destAddr)
    {
        newOne = (DSR_BUFFER_Node *)pc_malloc(sizeof(DSR_BUFFER_Node));
        assert(newOne != NULL);

        newOne->destAddr = destAddr;
        newOne->msg = old->msg;
        old->msg = msg;
        newOne->timestamp = old->timestamp;
        old->timestamp = simclock();
        newOne->next = old;
    }
    else
    {
        newOne = old;
        newOne->next = RoutingDsrInsertBufInOrder(msg, destAddr, old->next);
    }

    return (newOne);
}

/*
 * RoutingDsrCompareRoute
 *
 * Check if new route is the same as the one in cache
 * return TRUE if new route is the same; FALSE otherwise
 */
BOOL RoutingDsrCompareRoute(NODE_ADDR destAddr,
                            int hopCount,
                            NODE_ADDR *path,
                            DSR_RouteCache *routeCache)
{
    int i, j;
    BOOL found = FALSE;
    DSR_RouteCacheEntry *current;

/*
printf("COMPARE ROUTE: hop count = %d\n", hopCount);
*/

    for (current = routeCache->head;
         current != NULL && current->destAddr <= destAddr;
         current = current->next)
    {
        if (current->destAddr == destAddr && current->hopCount == hopCount)
        {
            for (i = 0; i < hopCount; i++)
            {
                if (current->path[i] != path[i])
                {
                    found = FALSE;
                    break;
                }
                else
                {
                    found = TRUE;
                }
            }
            if (found == TRUE)
            {
                return (found);
            }
        }
    }

    return (found);

} /* Compare route */
 
/*
 * RoutingDsrDeleteRouteCache
 *
 * Delete route entries that use the broken link
 */
void RoutingDsrDeleteRouteCache(GlomoNode *node,
                                NODE_ADDR fromHop,
                                NODE_ADDR nextHop,
                                DSR_RouteCache *routeCache)
{
    int i;
    DSR_RouteCacheEntry *toFree;
    DSR_RouteCacheEntry *current;
    BOOL found;

    if (routeCache->count == 0 || routeCache->head == NULL)
    {
        return;
    }
    else
    {
        current = routeCache->head;
        while (current != NULL)
        {
            if (current->path[0] == nextHop && fromHop == node->nodeAddr)
            {
                toFree = current;

                if (current->prev == NULL && current->next == NULL)
                {
                    routeCache->head = current->next;
                }
                else if (current->prev == NULL)
                {
                    current->next->prev = current->prev;
                    routeCache->head = current->next;
                }
                else if (current->next == NULL)
                {
                    current->prev->next = current->next;
                }
                else
                { 
                    current->prev->next = current->next;
                    current->next->prev = current->prev;
                }

                current = current->next;
                pc_free(toFree);
                --(routeCache->count);
            }

            else 
            {
                found = FALSE;
                for (i = 0; i < current->hopCount - 1; i++)
                {
                    if (current->path[i] == fromHop && 
                        current->path[i + 1] == nextHop)
                    {
                        toFree = current;
                        found = TRUE;

                        if (current->prev == NULL && current->next == NULL)
                        {
                            routeCache->head = current->next;
                        }
                        else if (current->prev == NULL)
                        {
                            current->next->prev = current->prev;
                            routeCache->head = current->next;
                        }
                        else if (current->next == NULL)
                        {
                            current->prev->next = current->next;
                        }
                        else
                        { 
                            current->prev->next = current->next;
                            current->next->prev = current->prev;
                        }

                        current = current->next;
                        pc_free(toFree);
                        --(routeCache->count);

                        break;
                    }
                }

                if (found == FALSE)
                {
                    current = current->next;
                }
            }
        }
    }

} /* Delete route cache */

/*
 * RoutingDsrDeleteBuffer
 *
 * Remove an entry from teh buffer
 */
BOOL RoutingDsrDeleteBuffer(NODE_ADDR destAddr, DSR_BUFFER *buffer)
{
    DSR_BUFFER_Node *toFree;
    DSR_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);

}

/*
 * RoutingDsrDeleteRequestTable
 *
 * Remove an entry from the request table
 */
void RoutingDsrDeleteRequestTable(NODE_ADDR destAddr,
                                  DSR_RequestTable *requestTable)
{
    DSR_RequestTableEntry *toFree;
    DSR_RequestTableEntry *current;

    if (requestTable->count == 0)
    {
        return;
    }
    else if (requestTable->head->destAddr == destAddr)
    {
        toFree = requestTable->head;
        requestTable->head = toFree->next;
        pc_free(toFree);
        --(requestTable->count);
    }
    else
    {
        for (current = requestTable->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);
            --(requestTable->count);
        }
    }
}

/*
 * RoutingDsrCheckDataSeen
 *
 * Check if this data packet has been seen before by looking at the header
 * return TRUE if seen before; FALSE otherwise
 */
BOOL RoutingDsrCheckDataSeen(GlomoNode *node, NODE_ADDR *header, int currentHop)
{
    int i;

    for (i = 0; i < currentHop - 1; i++)
    {
        if (header[i] == node->nodeAddr)
        {
            return (TRUE);
        }
    }

    return(FALSE);
} /* Check data seen */

/*
 * RoutingDsrCheckRequestPath
 *
 * Check if the own node address is already in the request packet's path
 * return TRUE if ID exist in the path; FALSE otherwise
 */
BOOL RoutingDsrCheckRequestPath(
    GlomoNode *node, NODE_ADDR *path, int currentHop)
{
    int i;

    for (i = 0; i < currentHop; i++)
    {
        if (path[i] == node->nodeAddr)
        {
            return (TRUE);
        }
    }

    return (FALSE);
} /* Check request path */

/*
 * RoutingDsrGetRoute
 *
 * Extract a route from the route cache table
 */
NODE_ADDR *RoutingDsrGetRoute(NODE_ADDR destAddr, DSR_RouteCache *routeCache)
{
    DSR_RouteCacheEntry *current;

    for (current = routeCache->head;
         current != NULL && current->destAddr <= destAddr;
         current = current->next)
    {
        if (current->destAddr == destAddr) 
        {
            return(current->path);
        }
    }

    printf("ERROR: Get Route - No route can be retrived from Cache\n");
    return(NULL);
} /* Get route */

/*
 * RoutingDsrGetHop
 *
 * Get the hop count to the destination
 */
int RoutingDsrGetHop(NODE_ADDR destAddr, DSR_RouteCache *routeCache) 
{
    DSR_RouteCacheEntry *current;

    for (current = routeCache->head;
         current != NULL && current->destAddr <= destAddr;
         current = current->next)
    {
        if (current->destAddr == destAddr)
        {
            return(current->hopCount);
        }
    }

    printf("ERROR: Get Hop - No route can be retrived from Cache\n");
    return(DSR_MAX_SR_LEN);
} /* Get hop */

/*
 * RoutingDsrGetSeq
 *
 * Get the sequence number of the packet to send
 */
int RoutingDsrGetSeq(GlomoNode *node)
{
    GlomoNetworkIp* ipLayer = (GlomoNetworkIp *) node->networkData.networkVar;
    GlomoRoutingDsr* dsr = (GlomoRoutingDsr *) ipLayer->routingProtocol;
    int number; 

    number = dsr->seqNumber;
    dsr->seqNumber++;

    return(number);
} /* Get seq */
 
/*
 * RoutingDsrCheckUnprocessedPath
 *
 * Check if the node address can be found in unprocess part of route header
 * return TRUE if found in unprocessed part; FALSE otherwise
 */
BOOL RoutingDsrCheckUnprocessedPath(GlomoNode *node,
                                    int currentHop,
                                    int segmentLeft,
                                    NODE_ADDR *header)
{
    int i;

    for (i = currentHop + 1; i < currentHop + segmentLeft + 1; i++)
    {
        if (header[i] == node->nodeAddr)
        {
            return (TRUE);
        }
    }

    return(FALSE);
} /* Check unprocessed path */

/*
 * RoutingDsrGetBufferedPacket
 *
 * Pop up the buffered data packet so that it can be sent via obtained route
 */
Message *
RoutingDsrGetBufferedPacket(NODE_ADDR destAddr, DSR_BUFFER *buffer)
{
    DSR_BUFFER_Node *current;

    for (current = buffer->head;
         current != NULL && current->destAddr <= destAddr;
         current = current->next)
    {
        if (current->destAddr == destAddr)
        {
            assert((current->timestamp + DSR_MAX_PACKET_BUFFER_TIME) > 
                   simclock());
            
            return(current->msg);
        }
    }
    assert(FALSE); abort(); return NULL;
}


/*
 * RoutingDsrRemoveOldPacketsFromBuffer
 *
 * Check if any packets have expired and remove them.
 */
void RoutingDsrRemoveOldPacketsFromBuffer(DSR_BUFFER *buffer)
{
    DSR_BUFFER_Node* current;
    DSR_BUFFER_Node* last = NULL;

    if (buffer->size == 0)
    {
        return;
    }//if//
    
    last = NULL;
    current = buffer->head;
    while (current != NULL) { 
        if ((current->timestamp + DSR_MAX_PACKET_BUFFER_TIME) < simclock())
        {
            DSR_BUFFER_Node* toFree = current;
            if (buffer->head == current) {
               buffer->head = current->next;
            } else {
               last->next = current->next;
            }//if//
            current = current->next;
            pc_free(toFree);