// Calculate number of bytes before the request.
// That portion of the message will go as it is

// Copy the portion of previous message, that is before route request
// option.

// Header Payload size should be incremented by 4 for allocating
// a new node in path.

// copy previous nodes route request part

// OptDataLen in Dsr Route Request should be changed

// Copy the path fields

// Copy other contents of Data

// Update statistical variable for number of request relayed

// Done with packet copying

// Copy the path fields

    // Done with packet copying
    NetworkIpSendRawMessageToMacLayerWithDelay(
        node,
        newMsg,
        srcAddr,
        ANY_DEST,
        IPTOS_PREC_INTERNETCONTROL,
        IPPROTO_DSR,
        ttl,
        DEFAULT_INTERFACE,
        ANY_DEST,
        (clocktype) (RANDOM_erand(dsr->seed) * DSR_BROADCAST_JITTER));

    newPktSize = recvPktSize + sizeof(NodeAddress);

    newMsg = MESSAGE_Alloc(node, MAC_LAYER, 0, MSG_MAC_FromNetwork);

    MESSAGE_PacketAlloc(node, newMsg, newPktSize, TRACE_DSR);

    newPktPtr = (unsigned char *) MESSAGE_ReturnPacket(newMsg);

        // Packet is not originated in this node
        if (NetworkIpIsMyIP(node, ipHeader->ip_dst))
        {
            // source route option should be eliminated in the previous node.
            // if the packet contains only source route option then the
            // packet will not have any dsr header in it.

            // If it contains any other option that will be handled by
            // Handle protocol packet.

            // So this portion of the code will do nothing

            // update statistics for number of data packet received. If IP
            // protocol is DSR it might be a Route Reply or a Route Error.

            if (ipHeader->ip_p != IPPROTO_DSR)
            {
                dsr->stats.numDataRecved++;
            }

            return;

        if (origIpHeader.ip_p == IPPROTO_DSR)
        {
            // We don't need to add DSR header. only the optional
            // fields should be added and header option size should
            // be modified as per new option length.

            unsigned short oldPayloadLen = 0;

            memcpy(&oldPayloadLen, MESSAGE_ReturnPacket(msg)
                + sizeof(unsigned short), sizeof(unsigned short));

            dataLen = DSR_SIZE_OF_SRC_ROUTE_WITHOUT_PATH
                          + (numNodesInSrcRt) * sizeof(NodeAddress)
                                  + (numNodesInSrcRtを模した任意の名称) * sizeof(int); //追加部分

            payloadLen = (unsigned short) (oldPayloadLen + dataLen);
        }
        else
        {
            // Need to add dsr header
            dataLen = DSR_SIZE_OF_HEADER
                          + DSR_SIZE_OF_SRC_ROUTE_WITHOUT_PATH
                              + (numNodesInSrcRt) * sizeof(NodeAddress)
                                  + (numNodesInSrcRtを模した任意の名称) * sizeof(int); //追加部分

            payloadLen = (unsigned short) (dataLen - DSR_SIZE_OF_HEADER);
        }

        MESSAGE_ExpandPacket(node, msg, dataLen);

        dataPtr = (unsigned char*) MESSAGE_ReturnPacket(msg);

        // Add common header
        DsrAddCommonHeader(
            dataPtr,
            origIpHeader.ip_p,
            payloadLen);

        dataPtr += DSR_SIZE_OF_HEADER;

        // Insert DSR Source Route option
        ERROR_Assert(rtPtr->destAddr == destAddr, "No route\n");

        // Add source route option
        DsrAddSrcRouteOption(
            dsr,
            dataPtr,
            (unsigned char *) rtPtr->path,
            rtPtr->hopCount - 1,
            0,
            0,
            salvage,
            rtPtr->hopCount - 1);

        dataPtr += (DSR_SIZE_OF_SRC_ROUTE_WITHOUT_PATH + (numNodesInSrcRt) * sizeof(NodeAddress)); //追加部分 

        dataPtrポインタにノードの持つ情報を追加する関数名; //追加部分

    unsigned char* options
    unsigned short optionSize

        else if (*options == DSR_SRC_ROUTE)
        {
            Message* duplicateMsg = NULL;

            // If the packet is not an overheard packet then the node
            // should forward the packet keeping a copy of the original
            // message. and the node will proceed with processing the
            // original message for further optional fields

            if (!isOverheard)
            {
                duplicateMsg = MESSAGE_Duplicate(node, recvMsg);
            }
            else
            {
                duplicateMsg = recvMsg;
            }

            DsrHandlePacketWithSrcRoute(
                node,
                duplicateMsg,
                prevHop,
                isOverheard);

            optionSize = (unsigned short) (optionSize - (*(options + 1)
                + DSR_SIZE_OF_TYPE_LEN));
            options += (*(options + 1)
                + (unsigned char) DSR_SIZE_OF_TYPE_LEN);
        }