dsr.pc

simulator for ad hoc

} /* RoutingDsrPeekFunction */

/*
 * RoutingDsrPacketDropNotificationHandler
 *
 * Reacts to the signal sent by the MAC protocol after link failure
 */
void RoutingDsrPacketDropNotificationHandler(
    GlomoNode *node, const Message* msg, const NODE_ADDR nextHopAddress)
{
    GlomoNetworkIp* ipLayer = (GlomoNetworkIp *) node->networkData.networkVar;
    GlomoRoutingDsr* dsr = (GlomoRoutingDsr *) ipLayer->routingProtocol;
    Message *newMsg = GLOMO_MsgCopy(node, msg);

    IpHeaderType* ipHeader;
    DsrIpOptionType *option;
    NODE_ADDR destAddr;
    NODE_ADDR unreachableAddr;
    NODE_ADDR targetAddr;
    NODE_ADDR errorPath[DSR_MAX_SR_LEN];
    int i, j;

    ipHeader = (IpHeaderType *) GLOMO_MsgReturnPacket(newMsg);

    
    dsr->stats.numLinkBreaks++;
    
    /* Control packets */
    if (ipHeader->ip_p  == IPPROTO_DSR)
    {
        DSR_PacketType *dsrHeader;
        NODE_ADDR sourceAddress;
        NODE_ADDR destinationAddress;
        unsigned char IpProtocol;
        unsigned int ttl;
        NetworkQueueingPriorityType priority;

        NetworkIpRemoveIpHeader(node, newMsg, &sourceAddress, 
                       &destinationAddress, &priority, &IpProtocol, 
                       &ttl);

        dsrHeader = (DSR_PacketType *) GLOMO_MsgReturnPacket(newMsg);

        unreachableAddr = destinationAddress;

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

        switch (*dsrHeader)
        {
            case DSR_ROUTE_REQUEST:
            {
                break;
            } /* RREQ */

            case DSR_ROUTE_REPLY:
            {
                DSR_RouteReply *rrep;

                rrep = (DSR_RouteReply *)GLOMO_MsgReturnPacket (newMsg);

                /* Build a route back to the source and  
                   send a Route Error */
                if (rrep->srcAddr != node->nodeAddr)
                {
                    for (i = rrep->segLeft, j = 0; 
                         i < rrep->hopCount + rrep->segLeft - 1; 
                         i++, j++)
                    {
                        errorPath[j] = rrep->path[i];
                    }
                    for (; j < DSR_MAX_SR_LEN; j++)
                    {
                        errorPath[j] = ANY_DEST;
                    }

                    RoutingDsrInitiateRERR(node, rrep->srcAddr, 
                                           unreachableAddr, errorPath);
                }

                break;
            } /* RREP */

            case DSR_ROUTE_ERROR:
            {
                DSR_RouteError *rerr;

                rerr = (DSR_RouteError *)GLOMO_MsgReturnPacket (newMsg);

                targetAddr = rerr->destAddr;

                if (rerr->salvaged == TRUE && 
                    node->nodeAddr != rerr->path[0]) 
                {
                    destAddr = rerr->path[0];

                    if (rerr->hopCount > 3)
                    {
                        for (i = rerr->hopCount - 3, j = 0; 
                             i >= 0; 
                             i--, j++)
                        {
                            errorPath[j] = rerr->path[i];
                        }
                        for (; j < DSR_MAX_SR_LEN; j++)
                        {
                            errorPath[j] = ANY_DEST;
                        }
                    }

                    else
                    {
                        errorPath[0] = rerr->path[0];

                        for (j = 1; j < DSR_MAX_SR_LEN; j++)
                        {
                            errorPath[j] = ANY_DEST;
                        }
                    }

                    RoutingDsrInitiateRERR(node, destAddr, 
                                       unreachableAddr, errorPath);
                }

                else if (rerr->salvaged == FALSE &&
                         node->nodeAddr != rerr->srcAddr)
                {
                    destAddr = rerr->srcAddr;

                    if (rerr->hopCount > 2)
                    {
                        for (i = rerr->hopCount - 3, j = 0; 
                             i >= 0; 
                             i--, j++)
                        {
                            errorPath[j] = rerr->path[i];
                        }
                        errorPath[j] = rerr->srcAddr;

                        j++;
                        for (; j < DSR_MAX_SR_LEN; j++)
                        {
                            errorPath[j] = ANY_DEST;
                        }
                    }

                    else
                    {
                        errorPath[0] = rerr->srcAddr;

                        for (j = 1; j < DSR_MAX_SR_LEN; j++)
                        {
                            errorPath[j] = ANY_DEST;
                        }
                    }

                    RoutingDsrInitiateRERR(node, destAddr, 
                                       unreachableAddr, errorPath);
                }

                /* Salvage the packet if other route is known */
                if (RoutingDsrCheckRouteExist(targetAddr, 
                                              &dsr->routeCacheTable) &&
                    rerr->salvaged == FALSE)
                {
                    RoutingDsrSalvageRERR(
                        node, targetAddr, rerr->srcAddr, 
                        rerr->unreachableAddr);
                }
               
                break;

            } /* RERR */
        } /* switch */

        GLOMO_MsgFree(node, newMsg);
    }

    else /* data packet */
    {
        NODE_ADDR path[DSR_MAX_SR_LEN + 1];
        int length;
        int current;

        ExtractIpSourceAndRecordedRoute(
                newMsg, path, &length, &current);
        assert(length <= (DSR_MAX_SR_LEN+1));

        option = GetPtrToDsrIpOptionField(newMsg);
        option->segmentLeft = option->segmentLeft - 1;

        unreachableAddr = path[current - 1];

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

        targetAddr = ipHeader->ip_dst;

        if (option->salvagedBit == TRUE && 
            node->nodeAddr != path[0]) 
        {
            destAddr = path[0];

            if (current > 3) 
            {
                for (i = current - 3, j = 0; i >= 0; i--, j++)
                {
                    errorPath[j] = path[i];
                }
                for (; j < DSR_MAX_SR_LEN; j++)
                {
                    errorPath[j] = ANY_DEST;
                }
            }

            else
            {
                errorPath[0] = path[0];

                for (j = 1; j < DSR_MAX_SR_LEN; j++)
                {
                    errorPath[j] = ANY_DEST;
                }
            }

            RoutingDsrInitiateRERR(node, destAddr, unreachableAddr,
                                   errorPath);
        }

        else if (option->salvagedBit == FALSE &&
                 node->nodeAddr != ipHeader->ip_src)
        {
            destAddr = ipHeader->ip_src;

            if (current > 2)
            {
                for (i = current - 3, j = 0; i >= 0; i--, j++)
                {
                    errorPath[j] = path[i];
                }
                errorPath[j] = ipHeader->ip_src;

                j++;
                for (; j < DSR_MAX_SR_LEN; j++)
                {
                    errorPath[j] = ANY_DEST;
                }
            }

            else
            {
                errorPath[0] = ipHeader->ip_src;

                for (j = 1; j < DSR_MAX_SR_LEN; j++)
                {
                    errorPath[j] = ANY_DEST;
                }
            }

            RoutingDsrInitiateRERR(node, destAddr, unreachableAddr,
                                   errorPath);
        }

        /* Salvage the data when other route is known */
        if (RoutingDsrCheckRouteExist(targetAddr, 
                                      &dsr->routeCacheTable) &&
            option->salvagedBit == FALSE)
        {
            RoutingDsrSalvageData(node, newMsg);
        }

        else
        {
            GLOMO_MsgFree(node, newMsg);
            dsr->stats.numDroppedPackets++;
        }

    } /* else - data packet */
  
} /* RoutingDsrMaclayerStatusHandler */

/*
 * RoutingDsrSetTimer
 *
 * Set timers for protocol events
 */
void RoutingDsrSetTimer(
    GlomoNode *node, long eventType, DSR_CR cr, clocktype delay)
{
    Message *newMsg;
    DSR_CR *info;

    newMsg = GLOMO_MsgAlloc(node,
                            GLOMO_NETWORK_LAYER,
                            ROUTING_PROTOCOL_DSR,
                            eventType);

    GLOMO_MsgInfoAlloc(node, newMsg, sizeof(DSR_CR));
    info = (DSR_CR *) GLOMO_MsgReturnInfo(newMsg);
    *info = cr;
    GLOMO_MsgSend(node, newMsg, delay);

} /* RoutingDsrSetTimer */

/*
 * RoutingDsrInitiateRREQ
 *
 * Initiate a Route Request packet when no route to destination is known
 */
void RoutingDsrInitiateRREQ(GlomoNode *node, NODE_ADDR destAddr)
{
    GlomoNetworkIp* ipLayer = (GlomoNetworkIp *) node->networkData.networkVar;
    GlomoRoutingDsr* dsr = (GlomoRoutingDsr *) ipLayer->routingProtocol;
    Message *newMsg;
    DSR_RouteRequest *rreq;
    DSR_CR cr;
    char *pktPtr;
    int pktSize = sizeof(DSR_RouteRequest);
    int i;

    newMsg = GLOMO_MsgAlloc(node, GLOMO_MAC_LAYER, 0, MSG_MAC_FromNetwork);
    GLOMO_MsgPacketAlloc(node, newMsg, pktSize);

    pktPtr = (char *) GLOMO_MsgReturnPacket(newMsg);
    rreq = (DSR_RouteRequest *) pktPtr;

    rreq->pktType = DSR_ROUTE_REQUEST;
    rreq->srcAddr = node->nodeAddr;
    rreq->targetAddr = destAddr;
    rreq->seqNumber = RoutingDsrGetSeq(node);
    rreq->hopCount = 1;
    for (i = 0; i < DSR_MAX_SR_LEN; i++)
    {
        rreq->path[i] = ANY_DEST;
    }

    NetworkIpSendRawGlomoMessage(
          node, newMsg, ANY_DEST, CONTROL, IPPROTO_DSR, 1);

    dsr->stats.numRequestSent++;

    if (RoutingDsrCheckRequestTable(destAddr, &dsr->requestTable))
    {
        RoutingDsrUpdateTtl(destAddr, &dsr->requestTable);
    }
    else
    {
        RoutingDsrInsertRequestTable(destAddr, &dsr->requestTable);
    }

    RoutingDsrInsertRequestSeen(node, node->nodeAddr, rreq->seqNumber,
                                &dsr->requestSeenTable);

    cr.destAddr = destAddr;
    cr.ttl = 1;

    RoutingDsrSetTimer(node, MSG_NETWORK_CheckReplied, 
                       cr, (clocktype)DSR_RING0_REQUEST_TO);

} /* RoutingDsrInitiateRREQ */

/*
 * RoutingDsrRetryRREQ
 *
 * Send RREQ again after not receiving any RREP
 */
void RoutingDsrRetryRREQ(GlomoNode *node, NODE_ADDR destAddr, int ttl)
{
    GlomoNetworkIp* ipLayer = (GlomoNetworkIp *) node->networkData.networkVar;
    GlomoRoutingDsr* dsr = (GlomoRoutingDsr *) ipLayer->routingProtocol;
    Message *newMsg;
    DSR_RouteRequest *rreq;
    DSR_CR cr;
    char *pktPtr;
    clocktype backoff;
    int pktSize = sizeof(DSR_RouteRequest);
    int i;

    newMsg = GLOMO_MsgAlloc(node, GLOMO_MAC_LAYER, 0, MSG_MAC_FromNetwork);
    GLOMO_MsgPacketAlloc(node, newMsg, pktSize);

    pktPtr = (char *) GLOMO_MsgReturnPacket(newMsg);
    rreq = (DSR_RouteRequest *) pktPtr;

    rreq->pktType = DSR_ROUTE_REQUEST;
    rreq->srcAddr = node->nodeAddr;
    rreq->targetAddr = destAddr;
    rreq->seqNumber = RoutingDsrGetSeq(node);
    rreq->hopCount = 1;
    for (i = 0; i < DSR_MAX_SR_LEN; i++)
    {
        rreq->path[i] = ANY_DEST;
    }

    NetworkIpSendRawGlomoMessage(
          node, newMsg, ANY_DEST, CONTROL, IPPROTO_DSR, ttl);

    dsr->stats.numRequestSent++;

    RoutingDsrInsertRequestSeen(node, node->nodeAddr, rreq->seqNumber,
                                &dsr->requestSeenTable);

    if (ttl == DSR_MAX_TTL)
    {
          RoutingDsrUpdateRequestTable(destAddr, &dsr->requestTable);
          backoff = RoutingDsrGetBackoff(destAddr, &dsr->requestTable);
    }
    else
    {
          RoutingDsrUpdateTtl(destAddr, &dsr->requestTable);
          backoff = DSR_RING0_REQUEST_TO;
    }

    cr.destAddr = destAddr;
    cr.ttl = ttl;

    RoutingDsrSetTimer(node, MSG_NETWORK_CheckReplied, cr, backoff);

} /* RoutingDsrRetryRREQ */

/*
 * RoutingDsrTransmitData
 *
 * Obtain the route from the cache and send the data thru the source route
 */
void RoutingDsrTransmitData(GlomoNode *node, Message *msg, NODE_ADDR destAddr)
{
    GlomoNetworkIp* ipLayer = (GlomoNetworkIp *) node->networkData.networkVar;
    GlomoRoutingDsr* dsr = (GlomoRoutingDsr *) ipLayer->routingProtocol;
    DsrIpOptionType *option;
    NODE_ADDR *route;
    int hopCount;

    GLOMO_MsgSetLayer(msg, GLOMO_MAC_LAYER, 0);
    GLOMO_MsgSetEvent(msg, MSG_MAC_FromNetwork);

    route = RoutingDsrGetRoute(destAddr, &dsr->routeCacheTable);
    hopCount = RoutingDsrGetHop(destAddr, &dsr->routeCacheTable);
    
    if (route != NULL)
    {
        AddCustomDsrIpOptionFields(node, msg);
        option = GetPtrToDsrIpOptionField(msg);
        option->segmentLeft = hopCount;
        option->salvagedBit = FALSE;
 
        NetworkIpSendPacketToMacLayerWithNewStrictSourceRoute(
            node, msg, route, hopCount, TRUE);

        dsr->stats.numDataSent++;
        dsr->stats.n