swarm_packet.cc

采用蚂蚁算法实现ad hoc网络路由协议,平台为ns2

#include <swarm/swarm_packet.h>
#include <swarm/swarm_rtable.h>
#include <swarm/swarm.h>

void hdr_swarm::onFailedUnicast(SwarmEnvironment & env, Packet * p)
{
    struct hdr_cmn *ch = HDR_CMN(p);
    nsaddr_t lostNeighbour = ch->next_hop_;

    env.neighbours[lostNeighbour].onFailedSend();
    env.getRoutingEntry(dst).update();

    hadError = true;

    forwardPacket(env,p);
}

void hdr_swarm::onOverheard(SwarmEnvironment & env, const Packet * p)
{
    struct hdr_cmn *ch = HDR_CMN(p);
    nsaddr_t prevHopAddress = ch->prev_hop_;

    env.incrementPacketsReceived();

    env.neighbours[prevHopAddress].onPromiscuousReceiveFrom();
    env.getRoutingEntry(src).onPromiscuousReceiveFrom(p);
    env.getRoutingEntry(dst).onPromiscuousReceiveTo(p);
}

void hdr_swarm::chooseNextHop(SwarmEnvironment & env, Packet * p)
{
    //TODO: if we cannot improve this packet, we should drop it.
    //
    struct hdr_cmn *ch = HDR_CMN(p);
    struct hdr_ip *ih = HDR_IP(p);

    swarm_rt_entry & routingEntry = env.getRoutingEntry(dst);
    nsaddr_t next_hop = routingEntry.pickNextHop();

    routingEntry.onSendToDestination();
    ch->next_hop_ = next_hop;
    if (ch->next_hop_ == (int32_t)IP_BROADCAST)
    {
	ch->addr_type() = NS_AF_NONE;
    }
    else
    {
	ch->addr_type() = NS_AF_INET;
	//swarmPacket->swarm_type = SWARMTYPE_DATA;
	env.neighbours[next_hop].onAttemptingSend();
    }

    valueToDest = routingEntry.currentEstimate;
    valueFromSource = env.getRoutingEntry(src).currentEstimate;
    
    ch->prev_hop_ = env.networkId;
    ih->daddr() = ch->next_hop_;

    ih->saddr() = env.networkId;
    ch->direction() = hdr_cmn::DOWN;        //important: change the packet's direction
}

void hdr_swarm::onReceiveFromHigherLevel(SwarmEnvironment & env, Packet * p)
{
    initializeFromIpPacket(env, p);
    swarm_rt_entry & routingEntry = env.getRoutingEntry(dst);
    if(routingEntry.hasSomeRoute())
    {
	chooseNextHop(env, p);
	env.sendPacket(p, 0);
    }
    else
    {
	env.queuePacket(p);
	env.sendControlPacketTo(dst);
    }
}

void hdr_swarm::receivePacketLocally(SwarmEnvironment & env, Packet * p)
{
    swarm_rt_entry & routingEntry = env.getRoutingEntry(src);

    //STOPS being received more than once?
    routingEntry.onForwardingFrom(p);

    if(env.hasPacketsQueuedFor(src))
	env.releasePacketsFor(src);
    else if(routingEntry.isProactiveResponseNeeded())
    {
	env.scheduleCallback(src, SWARM::HOLDOFF_FOR_PROACTIVE_SEND);
    }

    if(oldPacketType==PT_SWARM)
    {
	env.drop(p, "RESPONSE");
    }
    else
    {
	convertBackToOriginalPacket(env, p);
	env.receivePacketLocally(p);
    }
}

void hdr_swarm::forwardPacket(SwarmEnvironment & env, Packet * p)
{
    struct hdr_cmn *ch = HDR_CMN(p);
    struct hdr_ip *ih = HDR_IP(p);

    ih->ttl_ -= 1;
    if (ih->ttl_ == 0)
    {
	env.drop(p, DROP_RTR_TTL);
	return;
    }

    env.getRoutingEntry(src).onForwardingFrom(p);
    env.incrementPacketsReceived();

    chooseNextHop(env, p);
    if(ch->next_hop_==(int32_t)IP_BROADCAST)
    {
	env.sendPacket(p, SWARM::BROADCAST_RETRANSMIT_JITTER * Random::uniform());
    }
    else
    {
	env.sendPacket(p, SWARM::UNICAST_RETRANSMIT_JITTER * Random::uniform());
    }
}

void hdr_swarm::onReceivedUnicast(SwarmEnvironment & env, Packet * p)
{
    struct hdr_cmn *ch = HDR_CMN(p);
    struct hdr_ip *ih = HDR_IP(p);

    nsaddr_t prevHopAddress = ch->prev_hop_;
    env.neighbours[prevHopAddress].onSuccessfulReceive();
    env.getRoutingEntry(dst).onPromiscuousReceiveTo(p);
    env.incrementPacketsReceived();

    swarm_rt_entry & routingEntry = env.getRoutingEntry(src);
    routingEntry.onReceive(p);

    if(hadError || routingEntry.isNewOrImproved(p))
    {
	if (dst == env.networkId)
	{
	    receivePacketLocally(env,p);
	}
	else
	{
	    hadError=false;
	    forwardPacket(env,p);
	}
    }
    else
    {
	env.drop(p, "DUPLICATE");
    }
}

void hdr_swarm::onReceivedBroadcast(SwarmEnvironment & env, Packet * p)
{
    struct hdr_cmn *ch = HDR_CMN(p);
    struct hdr_ip *ih = HDR_IP(p);

    nsaddr_t prevHopAddress = ch->prev_hop_;
    env.neighbours[prevHopAddress].onSuccessfulReceive();
    env.incrementPacketsReceived();

    if(src == env.networkId)
    {
	env.drop(p, "MY_OWN_PACKET");
	return;
    }

    env.getRoutingEntry(dst).onPromiscuousReceiveTo(p);
    swarm_rt_entry & routingEntry = env.getRoutingEntry(src);
    routingEntry.onReceive(p);

    if(hadError || routingEntry.isNewOrImproved(p))
    {
	if (dst == env.networkId)
	{
	    receivePacketLocally(env,p);
	}
	else
	{

	    swarm_rt_entry & routingEntry = env.getRoutingEntry(dst);
	    if((routingEntry.currentEstimate - valueToDest) >= SWARM::MINIMUM_REWARD
		    || valueToDest==SWARM::COST_MAX
		    || routingEntry.currentEstimate==SWARM::COST_MAX)
	    {
		hadError=false;
		forwardPacket(env,p);
	    }
	    else
	    {
		env.drop(p, "STEP_BACKWARD");
	    }
	}
    }
    else
    {
	env.drop(p, "DUPLICATE");
    }
}

void hdr_swarm::initializeFromIpPacket(SwarmEnvironment & env, Packet * p)
{
    struct hdr_cmn *ch = HDR_CMN(p);
    struct hdr_ip *ih = HDR_IP(p);

    dst = ih->daddr();

    oldPacketType = ch->ptype();
    oldSourcePort = ih->sport();
    oldDestPort = ih->dport();

    ch->ptype() = PT_SWARM;
    ch->size() += size();
    ch->iface() = -2;
    ch->error() = 0;
    ch->addr_type() = NS_AF_NONE;
    ch->prev_hop_ = env.networkId;  // AODV hack
    ch->direction() = hdr_cmn::DOWN;        //important: change the packet's direction

    src = env.networkId;
    src_seqno = env.seqno++;

    swarm_type=SWARMTYPE_DATA;

    ih->saddr() = env.networkId;
    ih->sport() = RT_PORT;
    ih->dport() = RT_PORT;
}

void hdr_swarm::convertBackToOriginalPacket(SwarmEnvironment & env, Packet * p)
{
    struct hdr_cmn *ch = HDR_CMN(p);
    struct hdr_ip *ih = HDR_IP(p);

    ch->ptype() = oldPacketType;
    ch->size() -= size();
    ch->prev_hop_ = src;    // AODV hack
    ch->direction() = hdr_cmn::UP;  //important: change the packet's direction

    ih->saddr() = src;
    ih->daddr() = dst;
    ih->sport() = oldSourcePort;
    ih->dport() = oldDestPort;
}