odmrp.pc

simulator for ad hoc

 */
void RoutingOdmrpInitTempTable(ODMRP_TT *tempTable)
{
    tempTable->head = NULL;
    tempTable->size = 0;
} /* RoutingOdmrpInitTempTable */

/*
 * FUNCTION     RoutingOdmrpInitRouteTable
 * PURPOSE      Initialize the route table.
 *
 * Parameters:
 *     routeTable: Route table.
 */
void RoutingOdmrpInitRouteTable(ODMRP_RT *routeTable)
{
    routeTable->head = NULL;
    routeTable->size = 0;
} /* RoutingOdmrpInitRouteTable */

/*
 * FUNCTION     RoutingOdmrpInitMessageCache
 * PURPOSE      Initialize the message cache.
 *
 * Parameters:
 *     messageCache:  Message cache.
 */
void RoutingOdmrpInitMessageCache(ODMRP_MC *messageCache)
{
    messageCache->front = NULL;
    messageCache->rear = NULL;
    messageCache->size = 0;
} /* RoutingOdmrpInitMessageCache */

/*
 * FUNCTION     RoutingOdmrpInitSeqTable
 * PURPOSE      Initialize the sequence table.
 *
 * Parameters:
 *     node:         Node that is initializing the sequence table.
 */
void RoutingOdmrpInitSeqTable(GlomoNode *node)
{
    GlomoNetworkIp* ipLayer = (GlomoNetworkIp *) node->networkData.networkVar;
    GlomoRoutingOdmrp* odmrp = (GlomoRoutingOdmrp *) ipLayer->routingProtocol;

    odmrp->seqTable = 0;
} /* RoutingOdmrpInitSeqTable */

/*
 * FUNCTION     RoutingOdmrpInitSent
 * PURPOSE      Initialize the source sent table.
 *
 * Parameters:
 *     sentTable: Source sent table.
 */
void RoutingOdmrpInitSent(ODMRP_SS *sentTable)
{
    sentTable->head = NULL;
    sentTable->size = 0;
} /* RoutingOdmrpInitSent */

/* 
 * FUNCTION     RoutingOdmrpInitStats
 * PURPOSE      Initialize all the stats variables.
 *
 * Parameters:
 *     node: Node that is initializing the stats variables.
 */
void RoutingOdmrpInitStats(GlomoNode *node)
{
    GlomoNetworkIp* ipLayer = (GlomoNetworkIp *) node->networkData.networkVar;
    GlomoRoutingOdmrp* odmrp = (GlomoRoutingOdmrp *) ipLayer->routingProtocol;

    /* Total number of data join packets sent. */
    odmrp->stats.numQueryTxed = 0;

    /* Total number of join table packets sent. */
    odmrp->stats.numReplySent = 0;

    /* Total number of explicit acks sent. */
    odmrp->stats.numAckSent = 0;

    /* Total number of data packets sent by the source. */
    odmrp->stats.numDataSent = 0;

    /* Total number of data packets received by the destination. */
    odmrp->stats.numDataReceived = 0;

    /* Total number of data packets should be received by the destination. */
    odmrp->stats.numDataToReceive = 0;

    odmrp->stats.numDataTxed = 0;

} /* RoutingOdmrpInitStats */

/*
 * FUNCTION     RoutingOdmrpDeleteMsgCache
 * PURPOSE      Remove an entry from the message cache
 *
 * Parameters:
 *     messageCache:  Message cache table.
 */

void RoutingOdmrpDeleteMsgCache(ODMRP_MC *messageCache)
{
    ODMRP_MC_Node *toFree;

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

    if (messageCache->size == 0)
    {
        messageCache->rear = NULL;
    }
} /* RoutingOdmrpDeleteMsgCache */

/*
 * FUNCTION     RoutingOdmrpLookupMessageCache
 * PURPOSE      Check if the join query/data packet is seen before.
 *
 * Parameters:
 *     sourceAddr:      Originating node of the packet.
 *     seqNumber:       Sequece number of the packet.
 *     messageCache: Message cache table.
 *
 * Return: TRUE if seen before; FALSE otherwise.
 */

BOOL RoutingOdmrpLookupMessageCache(
            NODE_ADDR srcAddr, int seqNumber, ODMRP_MC *messageCache)
{
    ODMRP_MC_Node *current;

    if (messageCache->size == 0)
    {
        return (FALSE);
    }

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

    return (FALSE);
} /* OdmrpLookupMessageCache */

/*
 * FUNCTION     RoutingOdmrpLookupMembership
 * PURPOSE      Check if the node is a member of the multicast group.
 *
 * Parameters:
 *     mcastAddr:     Multicast group to check.
 *     memberFlag: Membership flag.
 *
 * Return: TRUE if member; FALSE otherwise.
 */

BOOL RoutingOdmrpLookupMembership(NODE_ADDR mcastAddr,
                                  ODMRP_Membership *memberFlag)
{
    ODMRP_M_Node *current;

    if (memberFlag->size == 0)
    {
        return (FALSE);
    }

    for (current = memberFlag->head;
         current != NULL;
         current = current->next)
    {
        if (current->mcastAddr == mcastAddr)
        {
            return (TRUE);
        }
    }

    return (FALSE);
} /* RoutingOdmrpLookupMembership */

/* 
 * FUNCTION     RoutingOdmrpLookupFgFlag
 * PURPOSE      Check if the node is a forwarding group.
 *
 * Parameters:
 *     mcastAddr: Multicast group to check.
 *     fgFlag: Forwarding group flag.
 *
 * Return: TRUE if member; FALSE otherwise.
 */

BOOL RoutingOdmrpLookupFgFlag(NODE_ADDR mcastAddr, ODMRP_FgFlag *fgFlag)
{
    ODMRP_FF_Node *current;

    if (fgFlag->size == 0)
    {
        return (FALSE);
    }

    for (current = fgFlag->head;
         current != NULL;
         current = current->next)
    {
        if (current->mcastAddr == mcastAddr)
        {
            return (TRUE);
        }
    }

    return (FALSE);

} /* RoutingOdmrpLookupFgFlag */

/*
 * FUNCTION     RoutingOdmrpLookupMemberTable
 * PURPOSE      Check if there exists valid sources for the multicast group.
 *
 * Parameters:
 *     mcastAddr:      Multicast group to check.
 *     memberTable: Member table.
 *
 * Return: TRUE if exists; FALSE otherwise.
 */
BOOL RoutingOdmrpLookupMemberTable(NODE_ADDR mcastAddr, ODMRP_MT *memberTable)
{
    ODMRP_MT_Node *current;

    if (memberTable->size == 0)
    {
        return (FALSE);
    }

    for (current = memberTable->head;
         current != NULL;
         current = current->next)
    {
        if (current->mcastAddr == mcastAddr && current->size > 0)
        {
            return (TRUE);
        }
    }

    return (FALSE);

} /* RoutingOdmrpLookupMemberTable */

/*
 * FUNCTION     RoutingOdmrpLookupSentTable
 * PURPOSE      Check if sent initial data for multicast group.
 *
 * Parameters:
 *     mcastAddr:    Multicast group.
 *     sentTable: Source sent table.
 *
 * Return: TRUE if sent; FALSE otherwise.
 */
BOOL RoutingOdmrpLookupSentTable(NODE_ADDR mcastAddr, ODMRP_SS *sentTable)
{
    ODMRP_SS_Node *current;

    if (sentTable->size == 0)
    {
        return (FALSE);
    }

    for (current = sentTable->head;
         current != NULL;
         current = current->next)
    {
        if (current->mcastAddr == mcastAddr)
        {
            return (TRUE);
        }
    }

    return (FALSE);
} /* RoutingOdmrpLookupSentTable */

/*
 * FUNCTION     RoutingOdmrpCheckFgExpired
 * PURPOSE      Check if FG Flag has been updated within timeout.
 *
 * Parameters:
 *     mcastAddr:  Multicast group.
 *     fgFlag:  Fg flag.
 *
 * Return: TRUE if expired; FALSE otherwise.
 */
BOOL RoutingOdmrpCheckFgExpired(NODE_ADDR mcastAddr, 
                                ODMRP_FgFlag *fgFlag)
{
    ODMRP_FF_Node *current;

    if (fgFlag->size == 0 || fgFlag->head == NULL)
    {
        return (FALSE);
    }

    for (current = fgFlag->head;
         current != NULL;
         current = current->next)
    {
        if (current->mcastAddr == mcastAddr &&
            simclock() - current->timestamp >= ODMRP_FG_TIMEOUT)
        {
            return (TRUE);
        }
    }

    return (FALSE);
} /* RoutingOdmrpCheckFgExpired */

/*
 * FUNCTION     RoutingOdmrpSetMemberFlag
 * PURPOSE      Set membership flag for a particular multicast group.
 *
 * Parameters:
 *     mcastAddr:     Multicast group.
 *     memberFlag: Membership flag.
 */
void RoutingOdmrpSetMemberFlag(NODE_ADDR mcastAddr,
                               ODMRP_Membership *memberFlag)
{
    ++(memberFlag->size);
    memberFlag->head = RoutingOdmrpSetMemFlagInOrder(
                                            mcastAddr, memberFlag->head);
} /* RoutingOdmrpSetMemberFlag */

/*
 */
ODMRP_M_Node *RoutingOdmrpSetMemFlagInOrder(
                             NODE_ADDR mcastAddr, ODMRP_M_Node *old)
{
    ODMRP_M_Node *newOne;

    if (old == NULL)
    {
        newOne = (ODMRP_M_Node *)pc_malloc(sizeof(ODMRP_M_Node));
        assert(newOne != NULL);
 
        newOne->mcastAddr = mcastAddr;
        newOne->timestamp = simclock();
        newOne->next = NULL;
    }
    else if (old->mcastAddr > mcastAddr)
    {
        newOne = (ODMRP_M_Node *)pc_malloc(sizeof(ODMRP_M_Node));
        assert(newOne != NULL);
 
        newOne->mcastAddr = mcastAddr;
        newOne->timestamp = simclock();
        newOne->next = old;
    }
    else
    {
        newOne = old;
        newOne->next = RoutingOdmrpSetMemFlagInOrder(mcastAddr, old->next);
    }

    return (newOne);
}

/*
 * FUNCTION     RoutingOdmrpResetMemberFlag
 * PURPOSE      Reset membership flag for a particular multicast group.
 *
 * Parameters:
 *     mcastAddr:     Multicast group.
 *     memberFlag: Membership flag.
 */
void RoutingOdmrpResetMemberFlag(NODE_ADDR mcastAddr,
                                 ODMRP_Membership *memberFlag)
{
    ODMRP_M_Node *toFree;
    ODMRP_M_Node *current;

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

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

} /* RoutingOdmrpResetMemberFlag */

/*
 */
void RoutingOdmrpUpdateFgFlag(NODE_ADDR mcastAddr, ODMRP_FgFlag *fgFlag)
{
    ODMRP_FF_Node *current;

    for (current = fgFlag->head; current != NULL; current = current->next)
    {
        if (current->mcastAddr == mcastAddr)
        {
            current->timestamp = simclock();
            break;
        }
    }
}

/*
 * FUNCTION     RoutingOdmrpSetFgFlag
 * PURPOSE      Set fg flag for a particular multicast group.
 *
 * Parameters:
 *     mcastAddr: Multicast group.
 *     fgFlag: Fg flag.
 */
void RoutingOdmrpSetFgFlag(NODE_ADDR mcastAddr, ODMRP_FgFlag *fgFlag)
{
    ++(fgFlag->size);
    fgFlag->head = RoutingOdmrpSetFgFlagInOrder(mcastAddr, fgFlag->head);
} /* RoutingOdmrpSetFgFlag */

/*
 */
ODMRP_FF_Node *RoutingOdmrpSetFgFlagInOrder(
                             NODE_ADDR mcastAddr, ODMRP_FF_Node *old)
{
    ODMRP_FF_Node *newOne;

    if (old == NULL)
    {
        newOne = (ODMRP_FF_Node *)pc_malloc(sizeof(ODMRP_FF_Node));
        assert(newOne != NULL);
 
        newOne->mcastAddr = mcastAddr;
        newOne->timestamp = simclock();
        newOne->next = NULL;
    }
    else if (old->mcastAddr > mcastAddr)
    {
        newOne = (ODMRP_FF_Node *)pc_malloc(sizeof(ODMRP_FF_Node));
        assert(newOne != NULL);
 
        newOne->mcastAddr = mcastAddr;
        newOne->timestamp = simclock();
        newOne->next = old;
    }
    else
    {
        newOne = old;
        newOne->next = RoutingOdmrpSetFgFlagInOrder(mcastAddr, old->next);
    }

    return (newOne);
}

/*
 * FUNCTION     RoutingOdmrpResetFgFlag
 * PURPOSE      Reset fg flag for a particular multicast group.
 *
 * Parameters:
 *     mcastAddr: Multicast group.