odmrp.pc

simulator for ad hoc

 *     fgFlag: Fg flag.
 */
void RoutingOdmrpResetFgFlag(NODE_ADDR mcastAddr, ODMRP_FgFlag *fgFlag)
{
    ODMRP_FF_Node *toFree;
    ODMRP_FF_Node *current;

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

} 

/*
 * FUNCTION     RoutingOdmrpSetSent
 * PURPOSE      Set sent flag for a particular multicast group.
 *
 * Parameters:
 *     mcastAddr:    Multicast group.
 *     sentTable: Source sent table.
 */
void RoutingOdmrpSetSent(NODE_ADDR mcastAddr, ODMRP_SS *sentTable)
{
    ++(sentTable->size);
    sentTable->head = RoutingOdmrpSetSentInOrder(mcastAddr, sentTable->head);
}

/*
 */
ODMRP_SS_Node *RoutingOdmrpSetSentInOrder(
                             NODE_ADDR mcastAddr, ODMRP_SS_Node *old)
{
    ODMRP_SS_Node *newOne;

    if (old == NULL)
    {
        newOne = (ODMRP_SS_Node *)pc_malloc(sizeof(ODMRP_SS_Node));
        assert(newOne != NULL);
 
        newOne->mcastAddr = mcastAddr;
        newOne->minExpireTime = simclock() + ODMRP_JR_REFRESH;
        newOne->lastSent = simclock();
        newOne->nextQuerySend = FALSE;
        newOne->next = NULL;
    }
    else if (old->mcastAddr > mcastAddr)
    {
        newOne = (ODMRP_SS_Node *)pc_malloc(sizeof(ODMRP_SS_Node));
        assert(newOne != NULL);
 
        newOne->mcastAddr = mcastAddr;
        newOne->minExpireTime = simclock() + ODMRP_JR_REFRESH;
        newOne->lastSent = simclock();
        newOne->nextQuerySend = FALSE;
        newOne->next = old;
    }
    else
    {
        newOne = old;
        newOne->next = RoutingOdmrpSetSentInOrder(mcastAddr, old->next);
    }

    return (newOne);
}

/*
 */
void RoutingOdmrpDeleteSourceSent(NODE_ADDR mcastAddr, ODMRP_SS *sentTable)
{
    ODMRP_SS_Node *toFree;
    ODMRP_SS_Node *current;

    if (sentTable->size == 0 || sentTable->head == NULL)
    {
        return;
    }
    else if (sentTable->head->mcastAddr == mcastAddr)
    {
        toFree = sentTable->head;
        sentTable->head = toFree->next;
        pc_free(toFree);
        --(sentTable->size);
    }
    else
    {
        for (current = sentTable->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);
            --(sentTable->size);
        }
    }
}

/*
 */
ODMRP_MT_Node *RoutingOdmrpGetMTEntry(
                  NODE_ADDR mcastAddr, ODMRP_MT *memberTable)
{
    ODMRP_MT_Node *current;

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

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

    return (NULL);
}

/*
 * FUNCTION     RoutingOdmrpInsertMemberTable
 * PURPOSE      Insert new multicast source entry.
 *
 * Parameters:
 *     mcastAddr:      Multicast group.
 *     sourceAddr:     Originating node of the packet.
 *     memberTable: Request seen table.
 */
void RoutingOdmrpInsertMemberTable(NODE_ADDR mcastAddr,
                                   NODE_ADDR srcAddr,
                                   ODMRP_MT *memberTable)
{
    ++(memberTable->size);
    memberTable->head = RoutingOdmrpInsertMTInOrder(
                                       mcastAddr, srcAddr, memberTable->head);
}

/*
 */
ODMRP_MT_Node *RoutingOdmrpInsertMTInOrder(
                   NODE_ADDR mcastAddr, NODE_ADDR srcAddr, ODMRP_MT_Node *old)
{
    ODMRP_MT_Node *newOne;

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

        newOne->mcastAddr = mcastAddr;
        newOne->sent = FALSE;
        newOne->lastSent = 0;
        newOne->queryLastReceived = simclock();
        newOne->head = NULL;
        newOne->size = 0;
        newOne->next = NULL;

        newOne->head = RoutingOdmrpInsertMemberSource(srcAddr, newOne);
    }

    else if (old->mcastAddr > mcastAddr)
    {
        newOne = (ODMRP_MT_Node *)pc_malloc(sizeof(ODMRP_MT_Node));
        assert(newOne != NULL);

        newOne->mcastAddr = mcastAddr;
        newOne->sent = FALSE;
        newOne->lastSent = 0;
        newOne->queryLastReceived = simclock();
        newOne->head = NULL;
        newOne->size = 0;
        newOne->next = old;

        newOne->head = RoutingOdmrpInsertMemberSource(srcAddr, newOne);
    }

    else
    {
        newOne = old;
        newOne->next = RoutingOdmrpInsertMTInOrder(
                                             mcastAddr, srcAddr, old->next);
    }

    return (newOne);
}

/*
 */
BOOL RoutingOdmrpCheckMSExist(NODE_ADDR srcAddr, ODMRP_MT_Node *mcast)
{
    ODMRP_MT_Snode *current;

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

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

    return (FALSE);
}

/*
 */
ODMRP_MT_Snode *RoutingOdmrpInsertMemberSource(
                                     NODE_ADDR srcAddr, ODMRP_MT_Node *mcast)
{
    ODMRP_MT_Snode *current;

    if (!RoutingOdmrpCheckMSExist(srcAddr, mcast))
    {
        ++(mcast->size);
        mcast->queryLastReceived = simclock();
        mcast->head = RoutingOdmrpInsertMSInOrder(srcAddr, mcast->head, NULL);

        return (mcast->head);
    }

    else
    {
        mcast->queryLastReceived = simclock();
        for (current = mcast->head; 
             current != NULL; 
             current = current->next)
        {
            if (current->srcAddr == srcAddr)
            {
                current->timestamp = simclock();
                break;
            }
        }
        return (NULL);
    }
}

/*
 */
ODMRP_MT_Snode *RoutingOdmrpInsertMSInOrder(
                  NODE_ADDR srcAddr, ODMRP_MT_Snode *old, ODMRP_MT_Snode *last)
{
    ODMRP_MT_Snode *newOne;

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

        newOne->srcAddr = srcAddr;
        newOne->timestamp = simclock();
        newOne->prev = last;
        newOne->next = NULL;
    }

    else if (old->srcAddr > srcAddr)
    {
        newOne = (ODMRP_MT_Snode *)pc_malloc(sizeof(ODMRP_MT_Snode));
        assert(newOne != NULL);

        newOne->srcAddr = srcAddr;
        newOne->timestamp = simclock();
        newOne->prev = old->prev;
        if (old->prev != NULL)
        {
            old->prev->next = newOne;
        }
        old->prev = newOne;
        newOne->next = old;
    }

    else
    {
        newOne = old;
        newOne->next = RoutingOdmrpInsertMSInOrder(srcAddr, old->next, old);
    }

    return (newOne);
}

/*
 * FUNCTION     RoutingOdmrpCheckSourceExpired
 * PURPOSE      Check if source has sent msg within timeout.
 *
 * Parameters:
 *     mcastAddr:      Multicast group.
 *     memberTable: Member table.
 */
void RoutingOdmrpCheckSourceExpired(NODE_ADDR mcastAddr, ODMRP_MT *memberTable)
{
    ODMRP_MT_Snode *toFree;
    ODMRP_MT_Snode *curSrc;

    ODMRP_MT_Node *current;

    BOOL zero = FALSE;

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

            for (curSrc = current->head;
                 curSrc != NULL;
                 curSrc = curSrc->next)
            {
                if (simclock() - curSrc->timestamp >= ODMRP_MEM_TIMEOUT)
                {
                    toFree = curSrc;

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

                    pc_free(toFree);
                    --(current->size);

                    if (current->size == 0)
                    {
                        zero = TRUE;
                    }
                }
            }
            break;
        }
    }

    if (zero == TRUE)
    {
        RoutingOdmrpDeleteMemberTable(mcastAddr, memberTable);
    }

} /* RoutingOdmrpCheckSourceExpired */

/*
 */
ODMRP_TT_Node *RoutingOdmrpGetTTEntry(NODE_ADDR mcastAddr, ODMRP_TT *tempTable)
{
    ODMRP_TT_Node *current;

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

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

    return (NULL);
}

/*
 * FUNCTION     RoutingOdmrpInsertTempTable
 * PURPOSE      Insert new entry into temp table.
 *
 * Parameters:
 *     mcastAddr:    Multicast group.
 *     sourceAddr:   Sources for the multicast.
 *     tempTable: Temp table.
 *
 */
void RoutingOdmrpInsertTempTable(NODE_ADDR mcastAddr,
                                 NODE_ADDR srcAddr,
                                 ODMRP_TT *tempTable)
{
    ++(tempTable->size);
    tempTable->head = RoutingOdmrpInsertTTInOrder(
                                       mcastAddr, srcAddr, tempTable->head);
} /* RoutingOdmrpInsertTempTable */

/*
 */
ODMRP_TT_Node *RoutingOdmrpInsertTTInOrder(
                   NODE_ADDR mcastAddr, NODE_ADDR srcAddr, ODMRP_TT_Node *old)
{
    ODMRP_TT_Node *newOne;

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

        newOne->mcastAddr = mcastAddr;
        newOne->sent = /*TRUE*/ FALSE;
        newOne->head = NULL;
        newOne->size = 0;
        newOne->next = NULL;

        newOne->head = RoutingOdmrpInsertTempSource(srcAddr, newOne);
    }

    else if (old->mcastAddr > mcastAddr)
    {
        newOne = (ODMRP_TT_Node *)pc_malloc(sizeof(ODMRP_TT_Node));
        assert(newOne != NULL);

        newOne->mcastAddr = mcastAddr;
        newOne->sent = /*TRUE*/ FALSE;
        newOne->head = NULL;
        newOne->size = 0;
        newOne->next = old;

        newOne->head = RoutingOdmrpInsertTempSource(srcAddr, newOne);
    }

    else
    {
        newOne = old;
        newOne->next = RoutingOdmrpInsertTTInOrder(
                                               mcastAddr, srcAddr, old->next);
    }

    return (newOne);
}

/*
 */
BOOL RoutingOdmrpCheckTSExist(NODE_ADDR srcAddr, ODMRP_TT_Node *mcast)
{
    ODMRP_TT_Snode *current;

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