dsr.pc

simulator for ad hoc

void RoutingDsrHandleError(GlomoNode *node, Message *msg, 
                           NODE_ADDR srcAddr, NODE_ADDR destAddr)
{
    GlomoNetworkIp* ipLayer = (GlomoNetworkIp *) node->networkData.networkVar;
    GlomoRoutingDsr* dsr = (GlomoRoutingDsr *) ipLayer->routingProtocol;
    Message *newMsg;
    DSR_RouteError *rerr = (DSR_RouteError *)GLOMO_MsgReturnPacket(msg);

    /* Delete routes in cache that use the broken link */
    RoutingDsrDeleteRouteCache(node,
                               rerr->srcAddr, 
                               rerr->unreachableAddr, 
                               &dsr->routeCacheTable);

    /* If intermediate node of the broken route, then forward the packet */
    if (rerr->path[rerr->hopCount - 1] == node->nodeAddr &&
        destAddr == node->nodeAddr &&
        rerr->destAddr != node->nodeAddr)
    {
        RoutingDsrRelayRERR(node, msg);
    } /* if intended receiver */

    /* if source of the broken route */
    else if (rerr->destAddr == node->nodeAddr)
    {
        GLOMO_MsgFree(node, msg);
    }

} /* Handle Error */

/*
 * RoutingDsrInitRouteCache
 *
 * Initialize the Route Cache Table
 */
void RoutingDsrInitRouteCache(DSR_RouteCache *routeCache)
{
    routeCache->head = NULL;
    routeCache->count = 0;
} /* Init route cache */

/*
 * RoutingDsrInitRequestSeen
 *
 * Initialize the Request Seen Table
 */
void RoutingDsrInitRequestSeen(DSR_RequestSeen *requestSeen)
{
    requestSeen->front = NULL;
    requestSeen->rear = NULL;
    requestSeen->count = 0;
} /* Init Request Seen */

/*
 * RoutingDsrInitRequestTable
 *
 * Initialize the Node Info Cache Table
 */
void RoutingDsrInitRequestTable(DSR_RequestTable *requestTable)
{
    requestTable->head = NULL;
    requestTable->count = 0;
} /* Init node info cache */

/*
 * RoutingDsrInitSeq
 *
 * Initialize the Sequence Table
 */
void RoutingDsrInitSeq(GlomoNode *node)
{
    GlomoNetworkIp* ipLayer = (GlomoNetworkIp *) node->networkData.networkVar;
    GlomoRoutingDsr* dsr = (GlomoRoutingDsr *) ipLayer->routingProtocol;

    dsr->seqNumber = 0;
} /* Init seq */

/*
 * RoutingDsrInitBuffer
 *
 * Initialize the buffer
 */
void RoutingDsrInitBuffer(DSR_BUFFER *buffer)
{
    buffer->head = NULL;
    buffer->size = 0;
}

/* 
 * RoutingDsrInitStats
 *
 * Initialize all the stats variables  
 */
void RoutingDsrInitStats(GlomoNode *node)
{
    GlomoNetworkIp* ipLayer = (GlomoNetworkIp *) node->networkData.networkVar;
    GlomoRoutingDsr* dsr = (GlomoRoutingDsr *) ipLayer->routingProtocol;

    dsr->stats.numRequestSent = 0;
    dsr->stats.numReplySent = 0;
    dsr->stats.numErrorSent = 0;
    dsr->stats.numDataSent = 0;
    dsr->stats.numDataTxed = 0;
    dsr->stats.numDataReceived = 0;
    dsr->stats.numHops = 0;
    dsr->stats.numRoutes = 0;
    dsr->stats.numLinkBreaks = 0;
    dsr->stats.numSalvagedPackets = 0;
    dsr->stats.numDroppedPackets = 0;
} /* Init stats */

/*
 * RoutingDsrDeleteSeenTable
 *
 * Delete a request seen table entry
 */
void RoutingDsrDeleteSeenTable(DSR_RequestSeen *requestSeen)
{
    DSR_RequestSeenEntry *toFree;

    toFree = requestSeen->front;
    requestSeen->front = toFree->next;
    --(requestSeen->count);

    if (requestSeen->count == 0)
    {
        requestSeen->rear = NULL;
    }
} /* Delete Seen Table */

/*
 * RoutingDsrCheckRouteExist
 *
 * Check if a route to a specific node is already known
 * return TRUE if route already exists; FALSE otherwise
 */
BOOL RoutingDsrCheckRouteExist(NODE_ADDR destAddr,
                               DSR_RouteCache *routeCache)
{
    DSR_RouteCacheEntry *current;

    if (routeCache->count == 0)
    {
        return (FALSE);
    }

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

    return (FALSE);
}

/*
 * RoutingDsrLookupRequestSeen
 *
 * Check if the route request packet is seen before
 * return TRUE if seen before; FALSE otherwise
 */
BOOL RoutingDsrLookupRequestSeen(NODE_ADDR srcAddr,
                                 int seq,
                                 DSR_RequestSeen *requestSeen)
{
    DSR_RequestSeenEntry *current;

    if (requestSeen->count == 0)
    {
        return (FALSE);
    }

    for (current = requestSeen->front;
         current != NULL;
         current = current->next)
    {
        if (current->srcAddr == srcAddr && current->seqNumber == seq)
        {
            return (TRUE);
        }
    }

    return (FALSE);
}

/*
 * RoutingDsrLookupRequestTable
 *
 * Check if backoff interval has expired for a destination
 * return TRUE if interval expired; FALSE otherwise
 */
BOOL RoutingDsrLookupRequestTable(NODE_ADDR destAddr,
                                  DSR_RequestTable *requestTable)
{
    DSR_RequestTableEntry *current;

    if (requestTable->count == 0)
    {
        return (TRUE);
    }

    for (current = requestTable->head;
         current != NULL;
         current = current->next)
    {
        if ((current->destAddr == destAddr) &&
            ((simclock() - current->lastRequest) > current->backoffInterval))
        {
            return (TRUE);
        }
    }

    return (FALSE);

} /* Lookup info cache */

/*
 * RoutingDsrInsertRequestSeen
 *
 * Insert a new route request entry
 */
void RoutingDsrInsertRequestSeen(GlomoNode *node,
                                 NODE_ADDR srcAddr,
                                 int seqNumber,
                                 DSR_RequestSeen *requestSeen)
{
    DSR_CR cr;
    if (requestSeen->count == 0)
    {
        requestSeen->rear = (DSR_RequestSeenEntry *)
                            pc_malloc(sizeof(DSR_RequestSeenEntry));
        assert(requestSeen->rear != NULL);
        requestSeen->front = requestSeen->rear;
    }
    else
    {
        requestSeen->rear->next = (DSR_RequestSeenEntry *)
                                  pc_malloc(sizeof(DSR_RequestSeenEntry));
        assert(requestSeen->rear->next != NULL);
        requestSeen->rear = requestSeen->rear->next;
    }

    requestSeen->rear->srcAddr = srcAddr;
    requestSeen->rear->seqNumber = seqNumber;
    requestSeen->rear->next = NULL;

    ++(requestSeen->count);

    cr.destAddr = ANY_DEST;
    cr.ttl = 0;

    RoutingDsrSetTimer(node, MSG_NETWORK_FlushTables, cr, DSR_FLUSH_INTERVAL);

} /* Insert request seen */

/*
 * RoutingDsrInsertRouteCache
 *
 * Insert a new route entry
 */
void RoutingDsrInsertRouteCache(NODE_ADDR destAddr,
                                int hopCount,
                                NODE_ADDR *path,
                                DSR_RouteCache *routeCache)
{
    ++(routeCache->count);

    routeCache->head = RoutingDsrInsertRCInOrder(destAddr,
                                                 hopCount,
                                                 path,
                                                 routeCache->head,
                                                 NULL);     
} /* Insert route cache */

/* 
 * RoutingDsrInsertRCInOrder
 *
 * Insert a new route entry in the order of destAddr
 */
DSR_RouteCacheEntry *RoutingDsrInsertRCInOrder(NODE_ADDR destAddr,
                                               int hopCount,
                                               NODE_ADDR *path,
                                               DSR_RouteCacheEntry *old,
                                               DSR_RouteCacheEntry *last)
{
    DSR_RouteCacheEntry *newOne;
    int i;

    if (old == NULL)
    {
        newOne = (DSR_RouteCacheEntry *)pc_malloc(sizeof(DSR_RouteCacheEntry));
        assert(newOne != NULL);

        newOne->destAddr = destAddr;
        newOne->hopCount = hopCount;
        for (i = 0; i < DSR_MAX_SR_LEN; i++)
        {
            newOne->path[i] = path[i];
        }
        newOne->prev = last;
        newOne->next = NULL;
    }
    else if ((old->destAddr > destAddr) || 
             ((old->destAddr == destAddr) && (old->hopCount > hopCount)))
    {
        newOne = (DSR_RouteCacheEntry *)pc_malloc(sizeof(DSR_RouteCacheEntry));
        assert(newOne != NULL);
  
        newOne->destAddr = destAddr;
        newOne->hopCount = hopCount;
        for (i = 0; i < DSR_MAX_SR_LEN; i++)
        {
            newOne->path[i] = path[i];
        }

        newOne->prev = old->prev;
        if (old->prev != NULL)
        {
            old->prev->next = newOne;
        }
        old->prev = newOne;
        newOne->next = old;
        
    }
    else if ((old->destAddr == destAddr) && (old->hopCount == hopCount))
    {
        newOne = (DSR_RouteCacheEntry *)pc_malloc(sizeof(DSR_RouteCacheEntry));
        assert(newOne != NULL);
  
        newOne->destAddr = destAddr;
        newOne->hopCount = old->hopCount;
        old->hopCount = hopCount;
        for (i = 0; i < DSR_MAX_SR_LEN; i++)
        {
            newOne->path[i] = old->path[i];
        }
        for (i = 0; i < DSR_MAX_SR_LEN; i++)
        {
            old->path[i] = path[i];
        }

        newOne->prev = old->prev;
        if (old->prev != NULL)
        {
            old->prev->next = newOne;
        }
        old->prev = newOne;
        newOne->next = old;
    }
    else
    {
        newOne = old;
        newOne->next = RoutingDsrInsertRCInOrder(destAddr,
                                                 hopCount,
                                                 path,
                                                 old->next,
                                                 newOne);
    }

    return(newOne);
}

/*
 * RoutingDsrInsertRequestTable
 *
 * Insert a new entry into the request table
 */
void RoutingDsrInsertRequestTable(NODE_ADDR destAddr,
                                  DSR_RequestTable *requestTable)
{
    ++(requestTable->count);
    requestTable->head = RoutingDsrInsertRTInOrder(destAddr,
                                                   requestTable->head);
}

/*
 * RoutingDsrInsertRTInOrder
 *
 * Insert a new entry into the request table in the order of destAddr
 */
DSR_RequestTableEntry *RoutingDsrInsertRTInOrder(NODE_ADDR destAddr,
                                                 DSR_RequestTableEntry *old)
{
    DSR_RequestTableEntry *newOne;

    if (old == NULL)
    {
        newOne = (DSR_RequestTableEntry *)
                 pc_malloc(sizeof(DSR_RequestTableEntry));
        assert(newOne != NULL);

        newOne->destAddr = destAddr;
        newOne->lastRequest = simclock();
        newOne->backoffInterval = DSR_REQUEST_PERIOD;
        newOne->ttl = 1;
        newOne->next = NULL;
    }
    else if (old->destAddr > destAddr)
    {
        newOne = (DSR_RequestTableEntry *)
                 pc_malloc(sizeof(DSR_RequestTableEntry));
        assert(newOne != NULL);

        newOne->destAddr = destAddr;
        newOne->lastRequest = simclock();
        newOne->backoffInterval = DSR_REQUEST_PERIOD;
        newOne->ttl = 1;
        newOne->next = old;
    }
    else
    {
        newOne = old;
        newOne->next = RoutingDsrInsertRTInOrder(destAddr, old->next);
    }

    return (newOne);
}

/*
 * RoutingDsrInsertBuffer
 *
 * Insert a new packet into the buffer
 */
void RoutingDsrInsertBuffer(Message *msg, NODE_ADDR destAddr,
                            DSR_BUFFER *buffer)
{
    ++(buffer->size);
    buffer->head = RoutingDsrInsertBufInOrder(msg, destAddr, buffer->head);
}

/*
 * RoutingDsrInsertBufInOrder
 *
 * Insert a new packet into the buffer in the order of destAddr
 */
DSR_BUFFER_Node *RoutingDsrInsertBufInOrder(Message *msg, NODE_ADDR destAddr,
                                            DSR_BUFFER_Node *old)
{
    DSR_BUFFER_Node *newOne;

    if (old == NULL)
    {
        newOne = (DSR_BUFFER_Node *)pc_malloc(sizeof(DSR_BUFFER_Node));
        assert(newOne != NULL);

        newOne->destAddr = destAddr;
        newOne->msg = msg;
        newOne->timestamp = simclock();
        newOne->next = NULL;