swarm_packet.h

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

#ifndef __swarm_packet_h__
#define __swarm_packet_h__

#include <random.h>
#include <string>
#include <sstream>
#include <iostream>
#include <priqueue.h>
#include <cmu-trace.h>
#include <swarm/swarm_rtable.h>

#define SWARMTYPE_FLOOD 1
#define SWARMTYPE_DATA 2
#define SWARMTYPE_ERROR 3
#define SWARMTYPE_RESPONSE 4

#define HDR_SWARM(p)		((struct hdr_swarm*)hdr_swarm::access(p))

static string swarmversion = "$Revision: 1.10 $";

class hdr_swarm
{
  public:
    u_int8_t swarm_type;        // Packet Type
    nsaddr_t dst;               // Destination IP Address
    nsaddr_t src;               // Source IP Address
    u_int32_t src_seqno;        // Source Sequence Number

    packet_t oldPacketType;
    u_int8_t oldSourcePort;   
    u_int8_t oldDestPort;    

    // If this bit is set, the packet has had to backtrack. In
    // this case, allow to reforward the packet if received by broadcast.
    // we won't worry about including this in the size calc. (There's loads
    // of room in the swarm_type field!)
    bool hadError;

    double valueToDest;
    double valueFromSource;

    static int offset_;         // required by PacketHeaderManager
    inline static int &offset()
    {
        return offset_;
    }
    inline static hdr_swarm *access(const Packet * p)
    {
        return (hdr_swarm *) p->access(offset_);
    }
    inline int size()
    {
        int sz = 0;
        sz = sizeof(u_int8_t)   // rq_type
            + sizeof(nsaddr_t)  // rq_dst
            + sizeof(nsaddr_t)  // rq_src
            + sizeof(u_int32_t) // rq_src_seqno
            + sizeof(packet_t)  // oldPacketType
            + 2 * sizeof(u_int8_t)      // ports
            + 2 * sizeof(double)    // values
            ;
        assert(sz >= 0);
        return sz;
    }
    
    string getTypeDescription()
    {
	stringstream o;
	switch(swarm_type)
	{
	    case SWARMTYPE_DATA:
		o << "DATA";
		break;
	    case SWARMTYPE_FLOOD:
		o << "FLOOD";
		break;
	    case SWARMTYPE_RESPONSE:
		o << "RESPONSE";
		break;
	}
	return o.str();
    }

    void onFailedUnicast(SwarmEnvironment & env, Packet * p);
    void onOverheard(SwarmEnvironment & env, const Packet * p);
    void chooseNextHop(SwarmEnvironment & env, Packet * p);
    void onReceiveFromHigherLevel(SwarmEnvironment & env, Packet * p);
    void onReceivedUnicast(SwarmEnvironment & env, Packet * p);
    void onReceivedBroadcast(SwarmEnvironment & env, Packet * p);
    void initializeFromIpPacket(SwarmEnvironment & env, Packet * p);
    void convertBackToOriginalPacket(SwarmEnvironment & env, Packet * p);

    void forwardPacket(SwarmEnvironment & env, Packet * p);
    void receivePacketLocally(SwarmEnvironment & env, Packet * p);
};

//
// for size calculation of header-space reservation
union hdr_all_swarm
{
    hdr_swarm swarm;
};

#endif /* __swarm_packet_h__ */