odmrp.pc

simulator for ad hoc

    }

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

    return (FALSE);
}

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

    if (!RoutingOdmrpCheckTSExist(srcAddr, mcast))
    {
        ++(mcast->size);
        mcast->sent = FALSE;
        mcast->head = RoutingOdmrpInsertTSInOrder(srcAddr, mcast->head, NULL);
        return (mcast->head);
    }

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

/*
 */
ODMRP_TT_Snode *RoutingOdmrpInsertTSInOrder(
                  NODE_ADDR srcAddr, ODMRP_TT_Snode *old, ODMRP_TT_Snode *last)
{
    ODMRP_TT_Snode *newOne;

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

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

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

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

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

    return (newOne);
}

/*
 */
BOOL RoutingOdmrpCheckTempChanged(NODE_ADDR mcastAddr, ODMRP_TT *tempTable)
{
    ODMRP_TT_Node *current;
    ODMRP_TT_Snode *curSrc;
    BOOL changed = FALSE;

    for (current = tempTable->head; current != NULL; current = current->next)
    {
        if (current->mcastAddr == mcastAddr)
        {
            if (current->size == 0 || current->head == NULL)
            {
                changed = TRUE;
            }
            else
            {
                for (curSrc = current->head; 
                     curSrc != NULL; 
                     curSrc = curSrc->next)
                {
                    if (simclock() - curSrc->timestamp >= ODMRP_JR_PAUSE_TIME)
                    {
                        changed = TRUE;
                        curSrc->timestamp = simclock();
                        curSrc->FGExpireTime = simclock() + ODMRP_FG_TIMEOUT;
                    }
                }
            }
            break;
        }
    }

    return (changed);
}

/*
 */
void RoutingOdmrpCheckTempExpired(NODE_ADDR mcastAddr, ODMRP_TT *tempTable)
{
    ODMRP_TT_Snode *toFree;
    ODMRP_TT_Snode *curSrc;

    ODMRP_TT_Node *current;

    BOOL zero = FALSE;

    for (current = tempTable->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_JR_LIFETIME)
                {
                    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)
    {
        RoutingOdmrpDeleteTempTable(mcastAddr, tempTable);
    }
}

/*
 */
ODMRP_RPT_Node *RoutingOdmrpGetRPTEntry(
                                NODE_ADDR mcastAddr, ODMRP_RPT *rspnsTable)
{
    ODMRP_RPT_Node *current;

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

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

    return (NULL);
}

/* 
 * FUNCTION     RoutingOdmrpInsertResponseTable
 * PURPOSE      Insert the source into the response table. 
 *
 * Parameters:
 *     mcastAddr:        Multicast address
 *     sourceID:         Source to add.
 *     responseTable: Response table.
 */
void RoutingOdmrpInsertResponseTable(
                NODE_ADDR mcastAddr, NODE_ADDR srcAddr, ODMRP_RPT *rspnsTable)
{
    ++(rspnsTable->size);
    rspnsTable->head = RoutingOdmrpInsertRPTInOrder(
                                       mcastAddr, srcAddr, rspnsTable->head);
} /* RoutingOdmrpInsertResponseTable */

/*
 */
ODMRP_RPT_Node *RoutingOdmrpInsertRPTInOrder(
                   NODE_ADDR mcastAddr, NODE_ADDR srcAddr, ODMRP_RPT_Node *old)
{
    ODMRP_RPT_Node *newOne;

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

        newOne->mcastAddr = mcastAddr;
        newOne->head = NULL;
        newOne->size = 0;
        newOne->next = NULL;

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

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

        newOne->mcastAddr = mcastAddr;
        newOne->head = NULL;
        newOne->size = 0;
        newOne->next = old;

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

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

    return (newOne);
}

/*
 */
BOOL RoutingOdmrpCheckRPSExist(NODE_ADDR srcAddr, ODMRP_RPT_Node *mcast)
{
    ODMRP_RPT_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_RPT_Snode *RoutingOdmrpInsertResponseSource(
                                      NODE_ADDR srcAddr, ODMRP_RPT_Node *mcast)
{
    if (!RoutingOdmrpCheckRPSExist(srcAddr, mcast))
    {
        ++(mcast->size);
        mcast->head = RoutingOdmrpInsertRPSInOrder(srcAddr, mcast->head);
        return (mcast->head);
    }
    else
    {
        return (NULL);
    }
}

/*
 */
ODMRP_RPT_Snode *RoutingOdmrpInsertRPSInOrder(
                                   NODE_ADDR srcAddr, ODMRP_RPT_Snode *old)
{
    ODMRP_RPT_Snode *newOne;

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

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

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

    return (newOne);
}

/* 
 */
ODMRP_AT_Node *RoutingOdmrpGetATEntry(NODE_ADDR mcastAddr, ODMRP_AT *ackTable)
{
    ODMRP_AT_Node *current;

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

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

    return (NULL);

}

/*
 */
void RoutingOdmrpInsertAckTable(
              NODE_ADDR mcastAddr, ODMRP_AT *ackTable, ODMRP_JoinReply *reply)
{
    ++(ackTable->size);
    ackTable->head = RoutingOdmrpInsertATInOrder(
                                       mcastAddr, ackTable->head, reply);

}

/*
 */
ODMRP_AT_Node *RoutingOdmrpInsertATInOrder(
              NODE_ADDR mcastAddr, ODMRP_AT_Node *old, ODMRP_JoinReply *reply)
{
    ODMRP_AT_Node *newOne;
    int i;

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

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

        newOne->head = RoutingOdmrpInsertAckSource(
                           reply->srcAddr[0], reply->nextAddr[0], newOne);

        if (reply->count > 0)
        {
            for (i = 1; i < reply->count; i++)
            {
                RoutingOdmrpInsertAckSource(
                            reply->srcAddr[i], reply->nextAddr[i], newOne);
            }
        }
    }

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

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

        newOne->head = RoutingOdmrpInsertAckSource(
                           reply->srcAddr[0], reply->nextAddr[0], newOne);

        if (reply->count > 0)
        {
            for (i = 1; i < reply->count; i++)
            {
                RoutingOdmrpInsertAckSource(
                            reply->srcAddr[i], reply->nextAddr[i], newOne);
            }
        }
    }

    else
    {
        newOne = old;
        newOne->next = RoutingOdmrpInsertATInOrder(mcastAddr, old->next, reply);
    }

    return (newOne);

}

/*
 */
BOOL RoutingOdmrpCheckASExist(NODE_ADDR srcAddr, ODMRP_AT_Node *mcast)
{
    ODMRP_AT_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_AT_Snode *RoutingOdmrpInsertAckSource(
                  NODE_ADDR srcAddr, NODE_ADDR nextAddr, ODMRP_AT_Node *mcast)
{
    OD