AODV-send-data-packet.zip_aodv_site:www.pudn.com

//#include <ip.h>

#include <aodv/aodv.h>

#include <aodv/aodv_packet.h>

#include <random.h>

#include <cmu-trace.h>

//#include <energy-model.h>

#define max(a,b) ( (a) > (b) ? (a) : (b) )

#define CURRENT_TIME Scheduler::instance().clock()

//#define DEBUG

*/

int hdr_aodv::offset_;

static class AODVHeaderClass : public PacketHeaderClass {

public:

AODVHeaderClass() : PacketHeaderClass("PacketHeader/AODV",

sizeof(hdr_all_aodv)) {

bind_offset(&hdr_aodv::offset_);

}

} class_rtProtoAODV_hdr;

return (new AODV((nsaddr_t) Address::instance().str2addr(argv[4])));

}

} class_rtProtoAODV;

int

AODV::command(int argc, const char*const* argv) {

if(argc == 2) {

Tcl& tcl = Tcl::instance();

if(strncasecmp(argv[1], "id", 2) == 0) {

tcl.resultf("%d", index);

return TCL_OK;

}

if(strncasecmp(argv[1], "start", 2) == 0) {

btimer.handle((Event*) 0);

#ifndef AODV_LINK_LAYER_DETECTION

rtimer.handle((Event*) 0);

}

else if(argc == 3) {

if(strcmp(argv[1], "index") == 0) {

index = atoi(argv[2]);

return TCL_OK;

}

else if(strcmp(argv[1], "log-target") == 0 || strcmp(argv[1], "tracetarget") ==

logtarget = (Trace*) TclObject::lookup(argv[2]);

if(logtarget == 0)

return TCL_ERROR;

}

else if(strcmp(argv[1], "if-queue") == 0) {

ifqueue = (PriQueue*) TclObject::lookup(argv[2]);

return TCL_ERROR;

return TCL_OK;

}

else if (strcmp(argv[1], "port-dmux") == 0) {

dmux_ = (PortClassifier *)TclObject::lookup(argv[2]);

if (dmux_ == 0) {

fprintf (stderr, "%s: %s lookup of %s failed\n", __FILE__,

argv[1], argv[2]);

return TCL_ERROR;

}

return TCL_OK;

}

return Agent::command(argc, argv);

*/

btimer(this), htimer(this), ntimer(this),

rtimer(this), lrtimer(this), rqueue() {

index = id;

seqno = 2;

bid = 1;

LIST_INIT(&nbhead);

LIST_INIT(&bihead);

logtarget = 0;

void

BroadcastTimer::handle(Event*) {

}

void

HelloTimer::handle(Event*) {

agent->sendHello();

double interval = MinHelloInterval +

((MaxHelloInterval - MinHelloInterval) * Random::uniform());

assert(interval >= 0);

Scheduler::instance().schedule(this, &intr, interval);

}

void

agent->nb_purge();

RouteCacheTimer::handle(Event*) {

Scheduler::instance().schedule(this, &intr, FREQUENCY);

}

void

LocalRepairTimer::handle(Event* p) { // SRD: 5/4/99

aodv_rt_entry *rt;

struct hdr_ip *ih = HDR_IP( (Packet *)p);

/* you get here after the timeout in a local repair attempt */

/* fprintf(stderr, "%s\n", __FUNCTION__); */

/* The following assert fails, not sure why */

/* assert (rt->rt_flags == RTF_IN_REPAIR); */

// send RERR

#ifdef DEBUG

fprintf(stderr,"Dst - %d, failed local repair\n", rt->rt_dst);

#endif

}

Packet::free((Packet *)p);

}

/*

Broadcast ID Management Functions

*/

assert(b);

}

/* SRD */

bool

AODV::id_lookup(nsaddr_t id, u_int32_t bid) {

BroadcastID *b = bihead.lh_first;

// Search the list for a match of source and bid

for( ; b; b = b->link.le_next) {

if ((b->src == id) && (b->id == bid))

return true;

}

BroadcastID *bn;

double now = CURRENT_TIME;